Android 16 KB page size: is your app ready?
Short answer: Newer Android devices can use a 16 KB memory page size instead of the traditional 4 KB, and apps with native code built for 4 KB pages may crash or fail to install on them. If your app is pure Kotlin or Java, including every library, it already works. If it bundles native libraries, directly or through an SDK, rebuild them 16 KB-aligned with current tools, check the alignment, and test on a 16 KB emulator. Google Play requires this for apps targeting Android 15 and higher, and from February 1, 2027 non-compliant updates can't be released.
What changed
Every operating system manages memory in fixed-size blocks called pages. Android has used 4 KB pages for a long time. Android's developer guide explains that beginning with Android 15, the Android Open Source Project supports devices configured with 16 KB pages, and manufacturers are building devices that use them.
Most app code never notices the page size. Native code does. Shared libraries (.so files) contain segments that must line up with page boundaries, and a library aligned only for 4 KB won't load correctly on a 16 KB device.
Does it affect your app?
Google's guidance boils down to one question: does your app contain native code?
- No native code. Google says that if your app only uses code written in Java or Kotlin, including all libraries and SDKs, it already supports 16 KB devices. It still recommends testing in a 16 KB environment.
- Native code. If your app uses NDK libraries, either directly or indirectly through an SDK, you need to rebuild it for 16 KB devices.
The "indirectly" part catches many business apps. You may never have written C or C++, but your app could include native libraries from a payments SDK, a barcode scanner, an image or video library, a database engine, a game engine or a cross-platform framework.
How to check. Android's guide suggests opening your APK in the APK Analyzer in Android Studio to see whether any native libraries are present, then checking the alignment of their ELF segments. Android Studio's analyser shows an Alignment column with a warning for any shared object that isn't 16 KB aligned. On Linux or macOS, Google also provides a check_elf_alignment.sh script you can run against your APK.
The deadline
Google Play states that all apps targeting Android 15 (API level 35) and higher must support 16 KB page sizes on 64-bit devices. Starting February 1, 2027, if your app's updates don't support 16 KB page sizes, you won't be able to release them. The Play Console shows a compatibility warning when it detects the problem, so check your release pages for it.
In practice, that means an app that ignores this may be unable to ship even an urgent bug fix after that date.
Fixing it
Google's guide includes a shortcut: if you update to Android Gradle Plugin 8.5.1 or higher and NDK r28 or higher, and use 16 KB-compatible prebuilt dependencies, your app is 16 KB compatible by default. Otherwise, work through these steps.
1. Update the Android Gradle Plugin. Upgrade to AGP 8.5.1 or higher and package shared libraries uncompressed. You can check your bundle with bundletool dump config; Google says that if you see PAGE_ALIGNMENT_16K, the bundle requests 16 KB zip alignment.
2. Rebuild your own native code. NDK r28 and higher compiles 16 KB-aligned libraries by default. On NDK r27 or lower, Google gives linker flags to add:
-Wl,-z,max-page-size=16384 -Wl,-z,common-page-size=16384
The guide shows where these go for ndk-build and CMake builds.
3. Update SDKs and libraries. For native libraries you don't build yourself, update to a version the vendor says is 16 KB compatible. If a vendor hasn't released one, ask them for a date. Google's guide has a section on checking SDKs for 16 KB support.
4. Fix code that assumes 4 KB. Google warns about code that uses the PAGE_SIZE constant or assumes a page is 4,096 bytes. Use getpagesize() or sysconf(_SC_PAGESIZE) instead, and review calls such as mmap() that need page-aligned arguments.
5. Verify the APK. Run zipalign with the 16 KB check option from build tools 35.0.0 or later, as shown in Google's guide, and re-run the alignment check in Android Studio.
Testing on a 16 KB environment
You don't need special hardware to start. Google's guide explains how to test using Android 15 system images for the Android Emulator configured for 16 KB pages. Test the paths that load native code: camera scanning, payments, maps, video playback, offline databases. A library that loads lazily may only fail when that feature is used, not at launch.
If your framework or a key SDK can't be updated yet, plan the work now rather than waiting for the release block.
For business owners working with an agency
You may not need the technical detail, but you can ask your developer or agency three questions:
- Does our app include any native libraries, including inside SDKs?
- Have they been rebuilt or updated for 16 KB page sizes, and has the app been tested on a 16 KB emulator?
- Does the Play Console show any 16 KB compatibility warning for our latest release?
A worked example
A hypothetical Toronto parking app is written in Kotlin, so the team assumes it's unaffected. The APK Analyzer shows two native libraries: one from a licence plate scanning SDK and one from an offline map library. The alignment check flags both. The team updates the map library to a version its vendor lists as 16 KB compatible, but the scanning SDK has no update yet, so they contact the vendor and track the issue. Meanwhile, they upgrade the Gradle plugin and test the rest of the app on a 16 KB emulator image.
FAQ
Will my app stop working on existing phones?
On 4 KB devices, a properly rebuilt app keeps working. The change is about supporting 16 KB devices as well.
Does this affect iOS?
No. This is an Android platform change.
What about apps built with Flutter or React Native?
These frameworks include native code, so check that you're on a framework version that supports 16 KB pages, and check any plugins with native parts.
Do I need to change my app's target API level?
The Play requirement applies to apps targeting Android 15 and higher. Store rules on target levels are separate, so check both.
If you're not sure whether your Android app is ready for 16 KB devices, send us your app's details and we'll help you check.