◉RORK LABJP
●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30
Articles/App Dev
◇ App Dev/2026-08-23Intermediate

Bumping targetSdk to 36 surfaced a 16 KB warning. These are two different deadlines

The target API 36 deadline (August 31, extended to November 1 for those who asked) and the February 1, 2027 16 KB page size requirement are separate conditions. A dependency-free Python check for APKs and AABs, why a LOAD misalignment and a zip boundary miss need different fixes, a symptom-first troubleshooting table, and how to choose between inspection tools, checked against official docs as of November 2026.

Google Play4416 KB page sizetarget API 36Expo237Rork620

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.

ItemTarget API level 3616 KB page size
DateAugust 31, 2026 (November 1 if you requested an extension)February 1, 2027
Applies toAll app updates and new appsApps that target API 35 or higher and ship native code
If you miss itYou cannot submit updatesYou cannot submit updates (after the date)
Where the fix livesBuild config (targetSdkVersion) and behavior changesLink-time alignment of .so files and their position in the zip
Kotlin / Java only appsAffectedNot affected (already compliant)
Status on November 20Passed. Non-compliant updates are blockedAbout 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.

SymptomLikely causeHow to confirmFix
Play Console says your app must support 16 KB memory page sizesYou target API 35+ and at least one .so is not on a 16 KB boundaryApp Bundle Explorer for that version, or the script belowDepends on LOAD=4096 vs zip boundary (see below)
Only zip boundary shows upPackaging position; an older Android Gradle PluginRe-check against an APK, not the AABAGP 8.5.1 or later (Expo SDK 53+ setups already meet this)
LOAD=4096 shows upThe .so itself was linked assuming 4 KB pagesMap the .so to its npm package and read its changelogUpdate or replace the dependency. Your build config cannot fix it
Crashes on launch, but only on 16 KB devices or emulatorsA LOAD=4096 library fails to load, or RELRO issuesadb logcat on a 16 KB system imageSame as above. Compat mode is a stopgap
A "running in compatibility mode" dialog at launchA 16 KB device is running a 4 KB app in compat modeThe dialog is the evidenceRelink the .so. android:pageSizeCompat only hides the dialog
Warning appears even though you ship no .soYou are looking at a different track or an older bundleMatch version codes in App Bundle ExplorerRe-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.

OutputCauseWho fixes it
zip boundary onlyPackaging. Where files land in the APKYou (a tooling update)
LOAD=4096The .so was linked assuming 4 KB pagesThe library's maintainer (or you, by rebuilding it)
no RELRORelocations are not made read-onlyThe 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.

ToolWhat you needWhat it tells youBest for
Play Console App Bundle ExplorerAn uploaded bundlePlay's own verdict on 16 KB complianceThe final call on what you actually submitted
Android Studio APK AnalyzerAndroid StudioPer-.so alignment warningsPinning down the offending .so locally
check_elf_alignment.sh plus zipalign -c -P 16SDK build-tools and the NDKELF and zip, using the official toolsCI with the full toolchain installed
The Python script abovePython 3 onlyELF LOAD and RELRO, plus APK zip boundariesEAS-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:

  1. Download the .aab from EAS Build and run the check. If it finds zero .so files, the requirement does not apply to you
  2. For each .so flagged LOAD=4096, figure out which npm package brought it in. Searching node_modules for the file name is quickest
  3. Read that package's changelog. Most have shipped a release with a "16 KB support" line
  4. If updating does not clear it, see whether you can align build conditions such as ndkVersion through expo-build-properties and rebuild it yourself
  5. 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/*' | head

Before 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.

Share

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

  • ✦Copy-paste ready implementation code
  • ✦New advanced guides published daily
  • ✦$5/mo or $10 for lifetime access
View Membership →

If you found this article helpful, a small tip ($1.50) would mean a lot to us. Your support helps keep this site ad-free and covers server and hosting costs.

Related Articles

◇ App Dev2026-08-18
The three places I had to fix before a Rork project actually targeted API level 36
My app.json said targetSdkVersion 36. The value my build actually read was 35. Here is the script that reports the effective value, and how I split my apps between raising, leaving alone, and requesting an extension.
◇ App Dev2026-11-16
I Set cameraPermission to false for a Photo Picker, and the QR Scanner Lost Its Camera Too
In expo-image-picker, cameraPermission: false deletes NSCameraUsageDescription from Info.plist on iOS and blocks CAMERA for every package on Android. Here is what happens when you also use expo-camera, and a working script that checks permissions before you submit.
◇ App Dev2026-10-28
"Project is incompatible with this version of Expo Go": Three Places to Check Before Blaming Your Project
When Expo Go says your project needs a newer Expo Go, there are three things to compare before you delete node_modules: the project's SDK, the SDK the app supports, and, on Android, a real mix-up in Expo Go 56.0.1. Here is the order I check them in.