16 KB page sizes: what it means for your Android app and how to fix it

Android 15 and higher support devices that use 16 KB memory pages instead of 4 KB. From February 1, 2027, Google Play blocks app updates that don't support 16 KB page sizes.

Most apps need little or no work. The ones that do are apps with native code, and the work usually comes from places you don't control, like third-party SDKs. Here's how to find out where you stand and what to do.

Are you affected?

Your app is affected only if it contains native code: shared libraries (.so files). You have native code if any of these apply:

• you use the Android NDK or write C or C++
• you use an SDK that ships native libraries (common in payments, security, analytics, media, maps, machine learning and game engines)
• your app is built by a cross-platform framework or app builder that ships native libraries

Quick check: open your APK (rename a copy to .zip, or use Android Studio's Build > Analyze APK) and look in the lib/ folder. If there are no .so files, your app already supports 16 KB devices. Google still recommends testing in a 16 KB environment.

If there are .so files, each one for the 64-bit ABIs (arm64-v8a and x86_64) needs two things:

1. 16 KB ELF alignment. The library was linked so its memory segments line up on 16 KB boundaries.
2. 16 KB zip alignment. If the library is stored uncompressed in the APK, it starts on a 16 KB boundary inside the file.

The four fixes that cover most apps

1. Rebuild your own native code with NDK r28 or newer

NDK r28 and higher compile 16 KB-aligned libraries by default. On NDK r27 and lower, add these linker flags:

-Wl,-z,max-page-size=16384
-Wl,-z,common-page-size=16384

Games on Unity or Unreal should follow their engine's own 16 KB guidance, which Google links from its page.

2. Update SDKs that ship native libraries

Many SDKs already support 16 KB, especially recent releases. Some older prebuilts don't. Google's advice is to check each SDK provider's website for the version that supports 16 KB. This step usually takes the longest, because it depends on someone else's release schedule, so start here.

3. Build with Android Gradle Plugin 8.5.1 or newer

Uncompressed native libraries must start on a 16 KB boundary inside the APK. AGP 8.5.1 and higher handle this. On older AGP versions a library can be correctly built and still be misaligned in the package.

4. Check your App Bundle's alignment

For App Bundles, the bundle config decides the zip alignment of the APKs Google Play generates. Check it with:

bundletool dump config --bundle=<your.aab> | grep alignment

PAGE_ALIGNMENT_16K is what you want. PAGE_ALIGNMENT_4K means the generated APKs will align native libraries for 4 KB.

Don't skip: code that assumes 4 KB

A correctly aligned app can still break if code assumes a 4 KB page. Google's checklist:

• remove hardcoded PAGE_SIZE or 4096 assumptions; use getpagesize() or sysconf(_SC_PAGESIZE)
• review mmap() and other calls that need page-aligned arguments
• check custom memory allocators

How to test

1. Use the Android 15 SDK or higher and one of: the 16 KB Android Emulator system image, Cuttlefish with 16 KB pages, 16 KB mode in developer options on a supported device, or Samsung Remote Test Lab.
2. Confirm the environment: adb shell getconf PAGE_SIZE should print 16384.
3. Check the APK's zip alignment: zipalign -c -P 16 -v 4 your-app.apk.
4. Walk through the parts of your app that use native code: camera, media, maps, crypto, games.

A note on RELRO

Google's page also asks that a library's RELRO segment end on a 16 KB boundary. Android's loader only fails when writable data shares a 16 KB page with that segment, and libraries from modern linkers often miss the strict boundary yet work. If a tool flags RELRO, check whether writable data actually shares the page before you treat it as a crash risk.

Check your app in one step

The Adaptwise Scan does the checks above in your browser: drop an APK or AAB and see every native library graded for ELF alignment, RELRO and zip alignment, plus your bundle config, with Google's fix for each failure. It's free, and your app file never leaves your computer.

Sources

• Android Developers: Support 16 KB page sizes
• Google Play's 16 KB requirement and deadline are described on the same page.

Checked against Google's documentation on October 7, 2026. Adaptwise is not affiliated with or endorsed by Google.