I had just bumped one of my wallpaper apps to target API level 36 and pushed it to internal testing when Play Console showed a warning I had not seen before: "Your app must support 16 KB memory page sizes."
I was racing the August 31 deadline at the time, and for a moment I braced myself: did this have to be fixed this week too? The short answer is no. These are two separate conditions with two separate dates.
Mixing them up pulls work that has months of runway into a week that has none. The opposite mistake is just as easy: fix one, assume it covered the other, and move on. I wrote this piece in August and revisited it in November, once the dates had shifted. The target API extension (November 1) has now passed too, which leaves the 16 KB date as the one still ahead.
The two conditions in Play Console differ in scope and in date
The target API requirement and the 16 KB page size requirement are triggered by different things. The table below reflects what Android Developers and the Play Console Help pages say as of November 2026.
| Item | Target API level 36 | 16 KB page size |
|---|---|---|
| Date | August 31, 2026 (November 1 if you requested an extension) | February 1, 2027 |
| Applies to | All app updates and new apps | Apps that target API 35 or higher and ship native code |
| If you miss it | You cannot submit updates | You cannot submit updates (after the date) |
| Where the fix lives | Build config (targetSdkVersion) and behavior changes | Link-time alignment of .so files and their position in the zip |
| Kotlin / Java only apps | Affected | Not affected (already compliant) |
| Status on November 20 | Passed. Non-compliant updates are blocked | About two and a half months left |
So the moment you move targetSdk from below 35 up to 36, the 16 KB requirement starts applying to you. The warning appeared when it did not because the deadlines overlap, but because I had just stepped inside the condition.
For the target API 36 side, I have written up auditing the effective targetSdkVersion and how August 31 means different things depending on whether you ship updates. This piece covers only the 16 KB side.
The primary source for the date is Support 16 KB page sizes on Android Developers. Earlier dates — November 1, 2025, extendable to May 31, 2026 — were widely shared, but the current official wording is that updates without 16 KB support cannot be released after February 1, 2027. Older articles are not a reason to panic, but the runway is not endless either.
Working backwards from the symptom
The warning shows up differently for different people. Find your row first; it tells you which of the following sections matter for you.
| Symptom | Likely cause | How to confirm | Fix |
|---|---|---|---|
| Play Console says your app must support 16 KB memory page sizes | You target API 35+ and at least one .so is not on a 16 KB boundary | App Bundle Explorer for that version, or the script below | Depends on LOAD=4096 vs zip boundary (see below) |
Only zip boundary shows up | Packaging position; an older Android Gradle Plugin | Re-check against an APK, not the AAB | AGP 8.5.1 or later (Expo SDK 53+ setups already meet this) |
LOAD=4096 shows up | The .so itself was linked assuming 4 KB pages | Map the .so to its npm package and read its changelog | Update or replace the dependency. Your build config cannot fix it |
| Crashes on launch, but only on 16 KB devices or emulators | A LOAD=4096 library fails to load, or RELRO issues | adb logcat on a 16 KB system image | Same as above. Compat mode is a stopgap |
| A "running in compatibility mode" dialog at launch | A 16 KB device is running a 4 KB app in compat mode | The dialog is the evidence | Relink the .so. android:pageSizeCompat only hides the dialog |
Warning appears even though you ship no .so | You are looking at a different track or an older bundle | Match version codes in App Bundle Explorer | Re-evaluate against your latest upload |
The last row is the easy one to miss. If an older bundle is still sitting on internal or closed testing, you can end up chasing its warning as if it belonged to your new build. Match the version code first. It is unglamorous, but getting the direction wrong here throws off every step after it.
Checking your APK or AAB without installing the NDK
The official procedure uses llvm-objdump (via the check_elf_alignment.sh script) and zipalign. Both need the Android SDK and the NDK. In a CI container, or on a machine where EAS Build normally does the heavy lifting and no toolchain is installed, that means pulling down several gigabytes just for this check.
All the check actually needs are two things: the ELF program headers inside each .so, and where each file sits in the zip. Python's standard library can read both. I ran the version below on Python 3.10.
#!/usr/bin/env python3
"""Inspect .so files in an APK / AAB for 16 KB alignment (no dependencies)"""
import sys, zipfile, struct
PT_LOAD, PT_GNU_RELRO = 1, 0x6474e552
def read_program_headers(data):
if data[:4] != b"\x7fELF":
return None
is64, little = data[4] == 2, data[5] == 1
end = "<" if little else ">"
if not is64:
return {"arch": "32bit", "loads": [], "relro": False}
e_machine, = struct.unpack_from(end + "H", data, 18)
e_phoff, = struct.unpack_from(end + "Q", data, 32)
e_phentsize, e_phnum = struct.unpack_from(end + "HH", data, 54)
loads, relro = [], False
for i in range(e_phnum):
off = e_phoff + i * e_phentsize
p_type, = struct.unpack_from(end + "I", data, off)
p_align, = struct.unpack_from(end + "Q", data, off + 48)
if p_type == PT_LOAD:
loads.append(p_align)
elif p_type == PT_GNU_RELRO:
relro = True
return {"arch": {0xB7: "arm64-v8a", 0x3E: "x86_64"}.get(e_machine, hex(e_machine)),
"loads": loads, "relro": relro}
def data_offset(z, info):
"""Read the local header and return where the data starts (what zipalign aligns)"""
f = z.fp
f.seek(info.header_offset + 26)
n, m = struct.unpack("<HH", f.read(4))
return info.header_offset + 30 + n + m
def main(path):
ng = 0
is_aab = path.lower().endswith(".aab")
with zipfile.ZipFile(path) as z:
infos = [i for i in z.infolist() if i.filename.endswith(".so")]
if not infos:
print("No .so files under lib/. The app ships no native code")
return 0
for info in sorted(infos, key=lambda i: i.filename):
hdr = read_program_headers(z.read(info))
if hdr is None:
continue
worst = min(hdr["loads"]) if hdr["loads"] else 0
aligned = worst >= 16384
stored = info.compress_type == zipfile.ZIP_STORED
# Positions inside an AAB do not match the delivered APK, so only judge zip boundaries on APKs
zip_ok = (data_offset(z, info) % 16384 == 0) if (stored and not is_aab) else None
flags = []
if not aligned: flags.append("LOAD=%d" % worst); ng += 1
if not hdr["relro"]: flags.append("no RELRO")
if zip_ok is False: flags.append("zip boundary"); ng += 1
state = "UNALIGNED" if flags else "ALIGNED"
print("%-10s %-12s %-9s %s" % (state, hdr["arch"],
"stored" if stored else "deflated", info.filename),
("[" + " / ".join(flags) + "]") if flags else "")
if is_aab:
print("\n(AAB: zip boundaries not checked. Re-run on an APK)")
print("\nNeeds action: %d" % ng)
return 1 if ng else 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1]))p_align is a 64-bit value 48 bytes into each program header. 16 KB is 16384, so if every PT_LOAD segment has p_align of at least 16384, the ELF side is fine. It is the same value llvm-objdump prints as align 2**14, just written differently.
data_offset() reads the zip's local file header to find where the data actually begins. The header_offset that zipfile gives you is the position of the header, not the data, and zipalign aligns the data. Mixing the two up flags correctly aligned APKs as broken. I did exactly that the first time, and failed a build that was fine.
The change since the August version is that the script no longer judges zip boundaries when the file is an .aab. An AAB is the raw material Play uses to assemble per-device APKs, and where a file sits inside the AAB is not where it will sit in the APK a phone downloads. Counting zip misses on an AAB puts perfectly fine setups on the to-do list. ELF from the AAB, zip boundaries from the APK. Keeping those two straight turned out to be the line that mattered most in this whole check.
For an APK, I use an EAS Build profile with buildType: "apk", or one generated from the AAB with bundletool. I would not claim either is byte-for-byte what Play delivers, so I treat the Play Console result, covered below, as the final word.
Reading the output: LOAD=4096 and a zip boundary miss need different fixes
To test it, I built one .so linked for 4 KB pages and one linked for 16 KB, packed them into a zip with the same layout as an APK, and ran the check. This is the actual output.
$ python3 check_16kb.py sample-app.apk
UNALIGNED x86_64 stored lib/arm64-v8a/libapp.so [zip boundary]
ALIGNED x86_64 deflated lib/arm64-v8a/libhermes.so
UNALIGNED x86_64 stored lib/arm64-v8a/libthirdparty.so [LOAD=4096 / zip boundary]
Needs action: 3
The arch column says x86_64 because of my test environment; a real APK shows arm64-v8a. The column reads the machine field from the ELF header, so if a file under lib/arm64-v8a/ is actually built for a different architecture, you will notice that too.
Next, I rebuilt the zip with padding so each .so started on a multiple of 16384, and ran the same check.
$ python3 check_16kb.py aligned-app.apk
ALIGNED x86_64 stored lib/arm64-v8a/libapp.so
ALIGNED x86_64 deflated lib/arm64-v8a/libhermes.so
UNALIGNED x86_64 stored lib/arm64-v8a/libthirdparty.so [LOAD=4096]
Needs action: 1
The zip boundary flag on libapp.so went away. The LOAD=4096 on libthirdparty.so did not. That difference is the one that matters in practice.
| Output | Cause | Who fixes it |
|---|---|---|
zip boundary only | Packaging. Where files land in the APK | You (a tooling update) |
LOAD=4096 | The .so was linked assuming 4 KB pages | The library's maintainer (or you, by rebuilding it) |
no RELRO | Relocations are not made read-only | The maintainer. It can cause crashes on 16 KB devices |
A zip boundary miss alone goes away once you are on Android Gradle Plugin 8.5.1 or later. LOAD=4096 does not respond to anything in your build config. It is a property of the binary you were handed, so the decision is whether to wait for an updated dependency or replace it.
Treat both as one vague "16 KB support" task and you end up trying build settings against a problem they cannot reach. For a solo developer, those hours are the margin between you and the deadline.
Which inspection tool to reach for
There are now several ways to check 16 KB compliance besides a homemade script. Each one fits a different moment, so here is how I split them.
| Tool | What you need | What it tells you | Best for |
|---|---|---|---|
| Play Console App Bundle Explorer | An uploaded bundle | Play's own verdict on 16 KB compliance | The final call on what you actually submitted |
| Android Studio APK Analyzer | Android Studio | Per-.so alignment warnings | Pinning down the offending .so locally |
check_elf_alignment.sh plus zipalign -c -P 16 | SDK build-tools and the NDK | ELF and zip, using the official tools | CI with the full toolchain installed |
| The Python script above | Python 3 only | ELF LOAD and RELRO, plus APK zip boundaries | EAS-only setups and lightweight CI without the NDK |
Put as one sentence: use local tools to learn whether you can fix it, and Play Console to learn whether you can ship it. The script is for getting close to the cause quickly; Play's verdict decides submission. If the script says zero and Play Console still warns, I trust Play Console and go looking again.
Three misconceptions worth clearing up
These are ones I half-believed myself at some point.
First: "Raising targetSdk takes care of 16 KB." targetSdk only decides whether the requirement applies to you. It does nothing to .so alignment. If anything, moving to 35 or higher is what puts you inside the requirement.
Second: "When the warning appears, start with the build config." If LOAD=4096 is showing, the build config is mostly beside the point. The official docs say native libraries need to be relinked on 16 KB boundaries. Sorting the cause first, then deciding where to work, is faster.
Third: "Adding android:pageSizeCompat means you're compliant." It suppresses the compat mode dialog. It does not make the app 16 KB compatible. More on that below.
What actually helps in an Expo or Rork project
React Native itself added 16 KB page size support in 0.77 (React Native 0.77 release notes). On the Expo side that corresponds to SDK 53 and later, and Expo's own notes are in expo/fyi on Android 16 KB page sizes. If you use the setup Rork currently generates (the SDK 58 line as of November 2026) as-is, it is unlikely the core will produce LOAD=4096.
The trouble comes from third-party native modules you added later. Maps, video, payments, and on-device ML libraries are often slow to update, and even when the repository has a fixed release, the latest version on npm may still carry an old .so.
The quickest order I have found:
- Download the
.aabfrom EAS Build and run the check. If it finds zero.sofiles, the requirement does not apply to you - For each
.soflaggedLOAD=4096, figure out which npm package brought it in. Searchingnode_modulesfor the file name is quickest - Read that package's changelog. Most have shipped a release with a "16 KB support" line
- If updating does not clear it, see whether you can align build conditions such as
ndkVersionthroughexpo-build-propertiesand rebuild it yourself - If it still remains, decide whether to replace the library or resolve it before the date
For step 2, this one-liner did most of the work. Once you have the .so name, the package is usually obvious.
# Find which package ships libthirdparty.so
find node_modules -name 'libthirdparty.so' -not -path '*/intermediates/*' | headBefore touching anything native, I would check whether a change in expo prebuild defaults will wipe out your edits. I wrote up that procedure in auditing native changes that prebuild --clean removes. What to look for in your dependencies after moving to targetSdk 36 is covered separately in where to look in your dependencies after targetSdk 36.
16 KB backcompat mode, and what it costs
The official docs describe a compatibility mode that lets 16 KB devices run apps built for 4 KB pages. When a .so has 4 KB LOAD alignment and uncompressed .so files sit on 4 KB boundaries, the package manager turns this mode on.
The catch is a warning dialog on first launch saying the app is running in compatibility mode. From the user's side, that dialog is the first thing they see when they open your app. Setting android:pageSizeCompat in the manifest suppresses it, but the app is still running in compat mode.
I treat it as a stopgap until the date. Running and being in the intended state are not the same thing. Lean on compat mode and forget about it, and the next time this topic comes up will be a user asking why something strange appears at launch.
Where to draw the line now (as of November)
Here it is as a task list, revised for where things stand now.
Target API 36 has passed, extension included. If an app is not on 36 yet, that comes before anything 16 KB related, because without it you cannot ship updates at all. The 16 KB warning, red as it looks in Play Console, is due February 1, 2027.
Run the check today anyway. The reason is narrow: if LOAD=4096 shows up, you cannot fix it yourself, and waiting on a dependency takes calendar time — which the year-end holidays tend to stretch further. Knowing how many unfixable items you have is what determines how many options you still have. If all you see is zip boundary, it is a tooling update and there is no rush.
The next thing you will hit: launching on a real 16 KB kernel
Once the check reaches zero, the question most people run into next is whether the app actually runs on a 16 KB device. The check looks at file layout; it does not prove launch behavior.
In Android Studio's Device Manager, pick a system image labeled "16 KB Page Size" and create an emulator from it. Once it boots, confirm the page size before installing the app.
adb shell getconf PAGE_SIZE
# 16384 means you are on a 16 KB kernel
adb install app-release.apk
adb logcat | grep -iE 'dlopen|page size|linker'If the app dies right after launch, logcat shows a dlopen failure naming the .so it stopped on. With that name, you are back at the third row of the troubleshooting table, tracing the package.
For the behavior changes that tend to surface alongside a target API 36 bump, deciding when to fix predictive back on Android 16 walks through the same kind of split between what the deadline forces and what can wait.
When deadlines stack up, the instinct is to work down the red warnings in the order they appear. What this summer taught me is that writing the condition and the date next to each one often halves what actually belongs in today. If you do one thing, run a single recent APK or AAB through the check above. If it says zero, you can put this out of your head until February.