Google Play Says Your App Doesn’t Support 16 KB Page Sizes? Let’s Fix the Native Libraries.

What Google requires

• “All apps targeting Android 15 (API level 35) and higher must support 16 KB memory page sizes on 64-bit devices on Google Play.”
• Since 1 November 2025, new apps and updates to existing apps that target Android 15+ must support 16 KB page sizes.
• “Starting February 1, 2027, if your app updates don’t support 16 KB memory page sizes, you won’t be able to release these updates.”

Sources: Android Developers, Support 16 KB page sizes, and the Android Developers Blog announcement (linked in the sources panel; verified 22 September 2026). Community threads mention case-by-case extensions granted through Play Console; Google’s documentation does not describe them, so plan on the dates above.

Who is affected

How to check your bundle

1. Play Console — the app’s policy status or the release warnings name the issue; the App bundle explorer lists the native libraries per ABI.
2. APK Analyzer (Android Studio → Build → Analyze APK): the lib folder shows an alignment column with warnings for misaligned .so files.
3. zipalign -c -P 16 -v 4 app.apk — must end with “Verification successful”. Bundles: bundletool dump config --bundle=app.aab | grep alignment should show PAGE_ALIGNMENT_16K.
4. ELF check per library: llvm-objdump -p lib.so | grep LOAD — every LOAD segment needs align 2**14 or higher; 2**12 / 2**13 fail. Google’s check_elf_alignment.sh script does this for a whole APK.
5. Run it on a 16 KB device or emulator image (adb shell getconf PAGE_SIZE returns 16384) — a warning dialog on first launch means the app is running in backcompat mode.

Alignment itself can only be proved from the built bundle, so nothing you paste into a form can confirm it. What a configuration file can show is whether the toolchain is capable of producing aligned libraries at all and which dependencies are likely to ship native code — our update readiness checker flags exactly that, and says plainly that the 16 KB check itself still has to happen on the artefact.

How the fix works

Native code you build

• NDK r28 or newer links 16 KB-aligned by default — no flags needed.
• NDK r27 and older: add -Wl,-z,max-page-size=16384 -Wl,-z,common-page-size=16384 to the linker flags (LOCAL_LDFLAGS in ndk-build, target_link_options in CMake).
• Remove hard-coded 4096 / PAGE_SIZE assumptions; use getpagesize() or sysconf(_SC_PAGESIZE). Custom allocators and mmap arithmetic are the usual suspects.
• Android Gradle Plugin 8.5.1 or newer packages uncompressed libraries with 16 KB zip alignment. If AGP cannot be upgraded yet, packagingOptions { jniLibs { useLegacyPackaging = true } } compresses the libraries as a fallback — slower installs, but compliant.

Third-party SDKs

Upgrade to the vendor’s 16 KB-ready release; if the vendor has none, replace the SDK. Most major SDKs shipped aligned builds during 2025, but transitive dependencies pinned by an old plugin or a resolutionStrategy often drag the old version back in — check the resolved dependency tree, not the declared one.

Flutter, React Native, Unity

• Flutter: upgrade the Flutter SDK and every plugin with native code; then verify the plugin .so files in the bundle, because a plugin can declare compatibility and still ship an old binary.
• React Native: upgrade to a release with aligned Hermes/core, then each native module; check node_modules/**/android for prebuilt .so files.
• Unity: move to a Unity version with 16 KB support and rebuild; re-import Google and third-party plugins. Unreal: follow Epic’s Android page-size guidance.

What we do

1. Pull the native-library inventory from your bundle (or from the dependency tree if you cannot share a build) and run the alignment checks per ABI.
2. Attribute each failing .so to its owner: your code, a plugin, or a transitive SDK.
3. Upgrade, rebuild or replace — including the AGP/NDK/Gradle changes that come with it — and re-verify with zipalign and llvm-objdump.
4. Test on a 16 KB device image, then produce the release bundle and rollout notes. If the same release needs the target API 36 or Billing Library 8 change, we do them together.

Checklist

• Every .so in every ABI folder passes the ELF alignment check
• zipalign -c -P 16 succeeds on the APK; bundletool shows PAGE_ALIGNMENT_16K
• NDK r28+ or linker flags in place for own native code; no hard-coded page size
• AGP 8.5.1+ (or legacy packaging as a documented fallback)
• Third-party SDKs at 16 KB-ready versions, verified in the resolved dependency tree
• Tested on a 16 KB emulator image or Pixel device without the backcompat warning
• Release plan aligned with the target API level and Billing Library requirements

Frequently asked questions