What Is the 16 KB Page Size?
A memory page is the smallest block of memory the operating system manages. Android has historically used 4 KB pages. Beginning with Android 15, AOSP supports devices configured with a 16 KB page size, and Google is moving the ecosystem toward it.
Larger pages reduce memory-management overhead. Google's initial testing reported:
- App launch under memory pressure: 3.16% faster on average, up to 30% for some apps
- Power draw during app launch: 4.56% lower on average
- Camera launch: 4.48% faster hot starts, 6.60% faster cold starts
- System boot: about 8% faster (roughly 950 ms)
The trade-off is slightly higher memory use on average. Real-device results will vary.
Why Apps Break
Kotlin and Java code does not care about page size. Native code does. A shared library (.so) whose ELF LOAD segments are aligned to 4 KB cannot be loaded correctly on a 16 KB device, which usually ends in a crash at startup or when the library is first loaded. Code that hardcodes 4096 as the page size can also misbehave.
The Google Play Requirement
Google first announced that, starting November 1, 2025, new apps and app updates targeting Android 15 (API level 35) or higher must support 16 KB pages. The enforcement date has since moved. As of October 2026, the official Android guide states:
- All apps targeting Android 15 (API 35) and higher must support 16 KB pages on 64-bit devices.
- Starting February 1, 2027, app updates that don't support 16 KB pages cannot be released on Google Play.
- Until then, Play Console shows a compatibility warning on affected releases.
Because Play's target API level rules already push new apps and updates to recent API levels, practically every actively maintained app that ships native code is in scope.
Who Is Affected?
| App setup | Affected? | What to do |
|---|---|---|
| Pure Kotlin/Java, all dependencies pure JVM | No | Test on a 16 KB environment anyway |
| Own C/C++ code via the NDK | Yes | Rebuild with a recent NDK and AGP |
SDKs that bundle .so files (ads, analytics, crypto, media, ML) | Yes | Update to a 16 KB-compatible SDK version |
| React Native | Yes | Use React Native 0.77 or newer and update native modules |
| Flutter | Yes | Use a recent Flutter release and update plugins with native code |
| Unity / Unreal games | Yes | Follow the engine's 16 KB guide and update the engine |
The most common real-world problem is not your own code but a prebuilt native library inside a third-party dependency.
How to Check Your App
- APK Analyzer – In Android Studio, open Build > Analyze APK, open the
libfolder and look at the Alignment column for warnings. - Lint – Android Studio Lint highlights native libraries that are not 16 KB aligned.
- zipalign – Verify ZIP alignment of the APK:
zipalign -c -P 16 -v 4 app-release.apk
# Output should end with "Verification successful"
- ELF alignment – Google's
check_elf_alignment.shscript (Linux/macOS) printsALIGNEDorUNALIGNEDfor everyarm64-v8alibrary. Manually,llvm-objdump -p libfoo.soshould show LOAD segments withalign 2**14;2**13or lower is a problem. - App bundle – For an AAB, run
bundletool dump config --bundle=app.aab | grep alignmentand look forPAGE_ALIGNMENT_16K. - Play Console – The app bundle explorer flags releases that do not support 16 KB pages.
How to Fix It
Update the Build Tooling
- Android Gradle Plugin 8.5.1 or higher packages uncompressed shared libraries with 16 KB ZIP alignment. On AGP 8.3–8.5, APKs are aligned by default but
bundletooldoes not zipalign APKs by default. - NDK r28 or higher compiles 16 KB-aligned libraries by default.
- On NDK r27 or lower, add the linker flags yourself:
target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
"-Wl,-z,max-page-size=16384"
"-Wl,-z,common-page-size=16384"
)
For ndk-build, add the same flags to LOCAL_LDFLAGS.
If you cannot upgrade AGP, you can ship compressed native libraries instead. This works but increases installed size:
android {
packaging {
jniLibs { useLegacyPackaging = true }
}
}
Fix Dependencies and Code
- Update every SDK and plugin that ships
.sofiles; check release notes for 16 KB support. - If a vendor has no compatible build, contact them or replace the dependency.
- Remove hardcoded page sizes. Query the real value at runtime with
sysconf(_SC_PAGESIZE)orgetpagesize(). - Rebuild, then re-run the checks above. Only
arm64-v8aandx86_64matter for 16 KB devices, but rebuild all ABIs together.
Testing on a 16 KB Environment
Emulator
- In Android Studio's SDK Manager, install the "Google APIs Experimental 16 KB Page Size" system image (ARM 64 v8a or x86_64) for Android 15 (VanillaIceCream) or higher.
- Create a virtual device with that image and boot it.
- Confirm the page size:
adb shell getconf PAGE_SIZE
# 16384
Physical Devices
On Pixel 8 and 8 Pro (Android 15 QPR1 or higher) and some newer devices, the developer option Boot with 16KB page size restarts the device in 16 KB mode. Samsung's Remote Test Lab also offers 16 KB test devices.
What to Test
- Cold start and every screen that loads native code (camera, video, maps, ML, payments)
- Background work and push handling that may load native libraries lazily
- Release builds, not only debug builds, since minification and packaging differ