Flutter and Google Play's 16 KB Page Size Requirement: How to Check and Fix Your App (2026)

By giosaia (GSPTeck) · Published 2026-10-26 · Last verified 2026-10-26

Does my Flutter app need 16 KB page size support for Google Play?

Yes, if it targets Android 15 (API level 35) or higher, which any app meeting Play's current target API rules does. Google's Android developer documentation says all such apps must support 16 KB memory page sizes on 64-bit devices, and that from 1 February 2027 updates that don't support them can't be released. For most Flutter apps the Flutter engine itself is already fine. The risk is in your build setup, an old Android Gradle Plugin (AGP), and in plugins that ship their own native .so libraries. You can check in about ten minutes with Play Console, the APK Analyzer or zipalign.

This guide covers what the requirement means for a Flutter app, how to check yours, the usual fixes, and how to test before you ship. It reflects Google's page as last updated on 16 October 2026.

Two columns: what Google Play requires, 16 KB page support for apps targeting Android 15 and higher on 64-bit devices, and the key dates up to 1 February 2027
The requirement and the dates.

What changed, and the dates

Android has historically used 4 KB memory pages. From Android 15, devices can be configured with 16 KB pages, which Google says improve app launch times under memory pressure, power use during launch, and camera start-up. Native libraries built only for 4 KB pages can fail to load on those devices.

Treat the February 2027 date as the hard stop and fix it before your next big release, not in January. Play Console shows a compatibility warning on affected releases, so you'll usually see it coming. If you're also catching up on target API levels, read our note on the target API 36 deadline alongside this one.

Why most Flutter apps are close already

A Flutter Android app always contains native code: the Flutter engine (libflutter.so) and your compiled Dart code (libapp.so). The Flutter team has stated that Flutter supports 16 KB page sizes from the SDK side, and that alignment for third-party plugins is the responsibility of each plugin's maintainers. So the usual problems are:

WhereWhat goes wrongTypical fix
Android Gradle PluginAGP older than 8.5.1 doesn't 16 KB zip-align uncompressed libraries in bundlesUpgrade AGP to 8.5.1 or higher
Plugins with prebuilt .so filesA plugin ships a library with 4 KB ELF alignmentUpdate the plugin, or replace it if no aligned version exists
Your own C/C++ (FFI) codeBuilt with NDK r27 or lower without 16 KB linker flagsBuild with NDK r28+, or add the linker flags
Code that assumes 4 KBHard-coded PAGE_SIZE or 4096 in native codeUse getpagesize() or sysconf(_SC_PAGESIZE)
Grid of where Flutter apps break on 16 KB pages: the engine is supported, but old AGP, plugins with 4 KB native libraries, older NDK builds and hard-coded page sizes are risks
Where Flutter apps break.

How to check your app in ten minutes

  1. Look in Play Console. Open your latest release in App bundle explorer. Google shows a compatibility warning when a bundle isn't 16 KB ready.
  2. Build a release bundle. Run flutter build appbundle --release, then check what alignment it requests with bundletool dump config --bundle=app-release.aab | grep alignment. PAGE_ALIGNMENT_16K is what you want. PAGE_ALIGNMENT_4K means the APKs Play builds will have 4 KB-aligned libraries.
  3. Open an APK in APK Analyzer. In Android Studio, use Build > Analyze APK. Look in the lib folder: the Alignment column flags libraries with problems, which tells you which plugin to look at.
  4. Run zipalign. With build-tools 35.0.0 or higher: zipalign -c -P 16 -v 4 app-release.apk. The last line should say "Verification successful".
  5. Check ELF alignment if needed. Google's check_elf_alignment.sh script, or llvm-objdump -p on each .so, shows the LOAD segment alignment. Values of 2**14 or higher are fine. 2**13 or lower are not.

Step 2 matters for Flutter because Play doesn't install your bundle. It builds APKs from it, so an APK you built locally can pass while the bundle still asks for 4 KB alignment.

Four checks for a Flutter app: Play Console's bundle warning, bundletool PAGE_ALIGNMENT_16K, the APK Analyzer alignment column and zipalign
Check your app in ten minutes.

The fixes, in order

  1. Upgrade AGP to 8.5.1 or higher. In current Flutter projects the version sits in android/settings.gradle or settings.gradle.kts, in the com.android.application plugin line. Older projects set it in android/build.gradle. Upgrade Gradle to a version that AGP supports at the same time.
  2. Upgrade Flutter and your plugins. Run flutter upgrade, then flutter pub outdated and update plugins that ship native code, such as databases, media, ML or crypto libraries.
  3. Rebuild and recheck. Repeat the bundletool and zipalign checks. If one library is still unaligned, find the plugin that ships it and check its issue tracker.
  4. If you can't upgrade AGP yet. Google documents a fallback: set jniLibs { useLegacyPackaging = true } in packagingOptions so libraries are compressed and extracted at install. It works, but the installed app takes more space. Our app size review routine helps you keep an eye on that.
  5. For your own native code. NDK r28 and higher compile 16 KB-aligned by default. With r27 or lower, add -Wl,-z,max-page-size=16384 and -Wl,-z,common-page-size=16384 to your linker flags.

Test in a 16 KB environment

Passing alignment checks doesn't prove the app runs. Test it:

On a 16 KB device, an app with 4 KB-aligned libraries may run in a backcompat mode and show a warning at launch. Treat that warning as a failure. Then ship through a staged rollout and watch crashes and ANRs; our guides to staged rollouts and Android vitals thresholds cover what to watch.

Four fixes in order: upgrade AGP to 8.5.1 or higher, update plugins, use NDK r28 or 16 KB linker flags, and test on a 16 KB emulator
Fix it in this order.

Add it to your release checklist

Once you've fixed it, keep it fixed. A new plugin can quietly bring back a 4 KB library. Add two lines to your Flutter and Firebase release checklist: run the bundletool alignment check on every release bundle, and look for the Play Console compatibility warning before you start a rollout.

Honest limits: this is a guide for typical Flutter and Firebase apps. Games built on engines, apps with heavy custom native code and apps with custom memory allocators have extra steps that Google documents separately.

Vertical Pinterest graphic with a five-step Flutter 16 KB page size checklist
Pinterest pin: Flutter 16 KB checklist.

FAQ

What is the deadline for 16 KB page size support on Google Play?

Google's page-sizes documentation says that from 1 February 2027, updates to apps targeting Android 15 or higher can't be released unless they support 16 KB memory page sizes on 64-bit devices.

Is Flutter compatible with 16 KB page sizes?

The Flutter engine supports 16 KB page sizes. Problems usually come from an Android Gradle Plugin older than 8.5.1 or from plugins that ship their own native libraries with 4 KB alignment.

How do I check if my Flutter app supports 16 KB pages?

Check Play Console's App bundle explorer for a warning, run bundletool dump config on your bundle and look for PAGE_ALIGNMENT_16K, and run zipalign -c -P 16 -v 4 on a release APK.

Do I need to change my Dart code?

Usually not. Dart code is compiled into a library that Flutter's tooling aligns. Only native code that assumes a 4 KB page size, such as a hard-coded PAGE_SIZE, needs changes.

Sources