Android phones have managed memory in 4 KB pages for as long as there have been Android phones. Android 15 added support for devices that use 16 KB pages instead, and Google Play has turned that into a rule. The Android documentation puts it plainly: apps targeting Android 15 (API level 35) or higher must support 16 KB pages on 64-bit devices, and "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."
That sentence is aimed at app updates, which makes it easy to ignore until the day you need one. This post is about finding out now, while it is a chore and not an outage.
Why every update is in scope
The rule covers apps that target Android 15 or higher. That sounds like a filter. It is not. Google Play's target API requirement says that since August 31, 2026, new apps and app updates must target Android 16 (API level 36) to be submitted, with an extension available to November 1, 2026 for apps that asked. Wear OS, Android Automotive, Android TV, and Android XR apps have lower targets, but they are still at Android 14 or 15.
So any phone or tablet app you can still update on Play targets Android 16, which is above the 16 KB threshold. If you plan to ship an update after February 1, 2027, the 16 KB rule applies to you.
Who actually has to change something
Google's answer is short. If your app, including every library and SDK inside it, is written only in Java or Kotlin, it already supports 16 KB devices. The apps that need work are the ones with native code, and the documentation lists three ways to end up with it:
- Your own C or C++ code, anything built with the Android NDK.
- A third-party library or SDK that ships native code. This is the common one.
- An app builder that uses native libraries on the device.
The second line is where the risk sits for most of our clients. Nobody on the team chose to write native code, but the app includes an ads SDK, a PDF viewer, a payments library, an image or video tool, or a database that does. Cross-platform frameworks ship native code too; Google's announcement names React Native and Flutter as already offering compatible versions, which helps only if your app is on a recent one.
Our position: treat this as an inventory problem, not an engineering project. For most apps the fix is updating dependencies and the build tools. The real failure case is a library whose vendor stopped shipping updates, because then the fix is replacing it, and that takes longer than a sprint before a deadline.
Finding out in ten minutes
There are three checks, from least to most technical. Any developer can run them against your current release build.
Play Console. Google says the app bundle explorer page shows whether your bundle meets the 16 KB requirement and where it needs changes. If you have Play Console access, this is the first place to look.
APK Analyzer. In Android Studio, Build > Analyze APK, open the lib folder. No lib folder, or no .so files in it, means no native code: you are done. If there are .so files, the Alignment column flags the ones that are not 16 KB aligned. Each flagged file names the library that needs an update.
Command line. For a CI job or a build server, the documentation gives commands that check the bundle and the APK:
# does the bundle ask for 16 KB zip alignment?
bundletool dump config --bundle=app-release.aab | grep alignment
PAGE_ALIGNMENT_16K good
PAGE_ALIGNMENT_4K the APKs Play builds will have 4 KB aligned .so files
# is the APK zip aligned for 16 KB?
zipalign -v -c -P 16 4 app-release.apk
The documentation also has a check_elf_alignment.sh script that checks each native library inside an APK, and recommends running the app on an Android 15 emulator image configured for 16 KB pages before release.
What the fix usually looks like
The documentation sets a clear baseline: with Android Gradle Plugin 8.5.1 or higher, NDK r28 or higher, and prebuilt dependencies that are 16 KB compatible, an app is 16 KB compatible by default. In practice that means three steps:
- Update the build tools to at least those versions.
- Update every SDK that ships native code to a version that supports 16 KB.
- Rebuild, rerun the checks above, and test on a 16 KB emulator.
There is one trap worth knowing. On Android Gradle Plugin 8.3 to 8.5, apps are 16 KB aligned by default but bundletool does not zipalign APKs by default, so the documentation warns the app "may appear to work, but when built from a bundle in Play, it won't install." Version 8.5.1 is the floor, not 8.3.
If a library has no compatible version, the choice is to replace it or remove the feature. That is a product decision, and it is better made in November than in February.
What you get for it
This is not only a compliance item. Google says devices with 16 KB pages showed app launches between 3% and 30% faster depending on the app, an average battery gain of 4.5%, and system boots about 8% faster in its testing. Google also warns that apps that are not recompiled might not work correctly on these devices as they become more common in future Android releases. The Play rule is a deadline for a change the hardware was going to force anyway.
The takeaway
Run this before the next release you plan after February 1, 2027. If it shows no native code, file it and move on.
The VENDORS line is the one that decides your timeline. Updating an SDK is a day. Replacing one is a project. Keeping dependencies current before a platform deadline forces it is what our support and maintenance work is for. If you want us to run the NATIVE and SDKS lines on your app, send us the build.
// sources
// next step
We work this way on client projects too.
Tell us what you are making. We reply with a plan, a timeline, and a price.
