Guides
Google Play's 16 KB Page Size Requirement: Does It Affect a Website App? (2026)
Google Play will block updates that lack 16 KB page size support from February 1, 2027. An app built from a website is affected only if it contains native libraries; here is how to check yours in minutes.
Google Play's 16 KB page size requirement affects an app built from a website only if the app contains native code, and some website-to-app builders do ship native libraries. According to Android's documentation, apps targeting Android 15 (API 35) or higher must support 16 KB memory page sizes on 64-bit devices, and from February 1, 2027 updates that don't will be blocked from release. An app made only of Java or Kotlin code needs no changes; an app with native libraries needs a rebuild. You can check yours in about five minutes. Rules checked November 21, 2026.
What is the 16 KB page size requirement?
Android has historically managed memory in 4 KB pages. Starting with Android 15, devices can be configured to use 16 KB pages, and Google says that if an app uses any NDK libraries, directly or through an SDK, it must be rebuilt to work on those devices. Google's Android documentation on 16 KB page sizes also says that, without recompiling, such apps won't work on 16 KB devices in future Android releases.
Rule applies to
API 35+
apps targeting Android 15 or higher, on 64-bit devices
Updates blocked from
Feb 1, 2027
per Android docs, last updated Nov 4, 2026
Date in the May 2025 announcement
Nov 1, 2025
still quoted in older articles
Google's May 2025 announcement gave November 1, 2025 as the start date for new apps and updates targeting Android 15 and higher. The current documentation instead gives February 1, 2027 as the date from which app updates that don't support 16 KB page sizes can't be released. Because older articles still show the earlier date, treat the documentation page as the source of truth and recheck it before each release.
Does the 16 KB page size requirement affect a website app?
It depends on whether the app shell contains native code. Android's documentation says your app uses native code if any of these apply: it uses C or C++ code through the NDK, it links with third-party native libraries or SDKs, or it is built by a third-party app builder that uses native libraries on device. The third case is the one that matters here, because the person who publishes a website app usually did not write its code.
Google also says that an app using only Java or Kotlin code, including all of its libraries and SDKs, already supports 16 KB devices. Whether a particular converter's output contains native libraries is something to verify on the actual build you plan to publish, not something to assume. If you rely on a converter for updates, the same dependency problem appears in the target API level requirement, where apps get stuck when the builder does not update its template.
How do you check a website app for 16 KB support?
- 1
Open the APK in APK Analyzer
In Android Studio choose Build, then Analyze APK, and pick your APK. Open the lib folder. If there is no lib folder or no .so files, the app has no native code.
- 2
Read the Alignment column
If .so files are present, the Alignment column shows warning messages for any file with an alignment problem.
- 3
Verify zip alignment
Run zipalign -c -P 16 -v 4 on the APK with the build tools from Android SDK Build-Tools 35.0.0 or higher. The last line says Verification successful when the libraries are aligned correctly.
- 4
Check the bundle
For an AAB, run bundletool dump config --bundle=your-app.aab and look for alignment. PAGE_ALIGNMENT_16K means the bundle requests 16 KB zip alignment, while PAGE_ALIGNMENT_4K means the APKs built from it will have 4 KB aligned .so files.
- 5
Look in Play Console
Google says the app bundle explorer page in Play Console shows your build's compliance and guidance, and Play Console also shows a compatibility warning about the February 1, 2027 date.
- 6
Test in a 16 KB environment
Google recommends testing even Java and Kotlin-only apps. Use an emulator with a 16 KB system image or the Boot with 16KB page size developer option on supported Pixel devices, then confirm adb shell getconf PAGE_SIZE returns 16384.
What do the results mean, and what if the check fails?
| What you find | What it means | What to do |
|---|---|---|
| No lib folder and no .so files | No native code. Google says the app already supports 16 KB devices. | Still test it in a 16 KB environment before release. |
| .so files present, no alignment warnings, zipalign passes | The native libraries appear to be aligned. | Test on a 16 KB emulator or device, then keep the build as is. |
| .so files with alignment warnings | At least one native library is not 16 KB aligned. | Ask the builder for a rebuild with updated libraries; you cannot fix this by editing your website. |
| AAB shows PAGE_ALIGNMENT_4K | APKs built from the bundle will have 4 KB aligned .so files. | Ask the builder to repackage; Google's guide points to Android Gradle Plugin 8.5.1 or higher for this. |
If you did not build the app yourself, the fix sits with whoever did. Google's guide says native libraries must be recompiled with 16 KB alignment, that NDK r28 and higher compile 16 KB aligned by default, and that SDK providers publish which versions are compatible. A converter or developer can act on that; a website owner cannot. If your tool cannot produce a compatible build, the checklist in free website to APK converters covers what to look for in a replacement.
Android also has a 16 KB backcompat mode on 16 KB devices. When an app's .so files are 4 KB aligned, the package manager can run it in that mode and show a warning at first launch. Google says this lets some apps work but that apps should still be 16 KB aligned for best reliability and stability, so do not treat it as a plan.
The 16 KB rule sits alongside other Android changes that reach website apps. The post on Android 17 behavior changes for website apps covers the items that apply once you target API 37.
Frequently asked questions
- Does the 16 KB page size requirement apply to apps built from a website?
- Only if the app contains native code. Android's documentation lists an app built by a third-party app builder that uses native libraries on device as native code, so check your actual APK. Google says apps made only of Java or Kotlin code, including all libraries, already support 16 KB devices.
- What is the deadline for 16 KB page size support on Google Play?
- Android's documentation says that starting February 1, 2027, app updates that don't support 16 KB memory page sizes can't be released. Google's May 2025 announcement gave November 1, 2025 as an earlier start date, so older articles may show a different date. Check the current documentation page.
- How do I check whether my APK contains native code?
- Open the APK in Android Studio's APK Analyzer (Build, then Analyze APK) and look in the lib folder. If there are .so files, the app uses native code and the Alignment column flags any problems. If there is no lib folder or no .so files, it has no native code.
- Will my app still run if its libraries are not 16 KB aligned?
- On devices with a 16 KB kernel, Android can run an app with 4 KB aligned libraries in a backcompat mode and show a warning at first launch. Google says this lets some apps work, but apps should still be 16 KB aligned for reliability, so rebuild rather than rely on it.
- Does a Java or Kotlin-only app need any changes?
- No. Google says an app that uses only Java or Kotlin code, including all libraries and SDKs, already supports 16 KB devices. Google still recommends testing it in a 16 KB environment to confirm there are no unexpected regressions.