A few days ago Google issued a warning stating that if your app doesn’t support 16kb page sizes, you wouldn’t be allowed to release new updates via Playstore by November 1st, 2025. Now, you may be wondering what 16kb support means while hoping that this migration doesn’t break your app and keep you stuck in Gradle debug hell.
No worries! This article explains what the 16kb page size support is all about and then guides you through a simple approach to tackle this issue, after which you can update your app as usual.
16kb Page Sizes: a breakdown
A 16KB page size is a system architecture where the operating system manages memory in 16kb blocks rather than the traditional 4kb blocks. This larger size requires more memory overall but improves performance by allowing more data to be mapped with fewer operations.
What does this mean for users on 16kb configured devices?
- memory management will now be 4x faster, which means faster operations and processes
- 5-10% performance upgrade for apps
- 30% increase in app launch speed
- 4.5% reduction in battery consumption
For your apps to work on 16kb configured devices, you need to ensure that it fully supports 16kb page sizes.
Check if your app is 16kb compliant
Head over to the Google Play console to confirm if your app is 16kb compliant. In the test and release section, select the aab file that’s currently live and check the app details. There, you should see if your app supports 16kb page sizes or not. If not, then it’s time to roll up your sleeves and get to work.
Step-by-Step: 16kb Migration Process
Here are all the steps we are going to take to ensure a smooth and easy migration:
- Update Gradle and Android Gradle Plugin (AGP) to 8.5.1+
- Update Compile and Target SDK
- Update NDK version to r27 or higher
- Clean gradle build process
- Verify with 16kb compatibility script
- Test 16kb enabled emulator
Update Gradle and Android Gradle Plugin (AGP) to 8.5.1+
First, update ACP and kotlin versions in the settings.gradle file.
plugins {
id "dev.flutter.flutter-plugin-loader" version "1.0.0"
id "com.android.application" version "8.11.0" apply false
id "org.jetbrains.kotlin.android" version "2.2.20" apply false
}
In this example, I’ll be using the AGP version 8.11 and Kotlin version 2.2.20. You can check the Kotlin compatibility
Next, update the gradle. To do this, move to your android folder and run the command below twice. This is my favorite way to update this.
./gradlew wrapper --gradle-version=8.13 --distribution-type=bin --gradle-distribution-sha256-sum=544c35d6bd849ae8a5ed0bcea39ba677dc40f49df7d1835561582da2009b961d
In this case, I used the gradle version 8.13 which is currently the latest version but you can use any version provided it’s 8.5.1 or higher. This command will help you update your gradle much easily than ever.
For more information on why we need to run this command twice and other details, you can check out this reference
To check out the different ACP releases and it’s compatible Gradle & NDK versions to use, refer to
Update Compile and Target SDK
The ACP version 8.11 supports API level 36, with this go to your android/app/build.gradle file and update your compile and target sdk to 36.
Update NDK version to r27 or higher
Still in your android/app/build.gradle file, update your ndk to r28
ndkVersion "28.2.13676358"
To check out the various ndk releases, see
If you use ndk r28 version, you are done with this step. However, if you used ndk r27 version, you still need to do some extra configuration in your build.gradle file. Note: r28+ is the recommended version to use.
Update your defaultConfig section with the externalNativeBuild code block.
android {
...
defaultConfig {
...
externalNativeBuild {
cmake {
arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
}
}
}
}
Clean Gradle build process
Move to your android folder and run the following commands.
# Clean previous builds
./gradlew clean
# Rebuild with new configuration
./gradlew assembleRelease
Verify with 16kb compatibility script
Use this
To use this, place the file at the root of your flutter app folder
run this command to make it executable
chmod +x en_check_alignment_elf.sh
make a release build and run the script
./en_check_alignment_elf.sh build/app/outputs/apk/release/app-release.apk
If you are good to go, you should see a success message in your terminal. If not, you may need to update the affected packages to versions that are 16kb ELF aligned.
You can also use this command to find out all the .so libraries your app currently uses so as to find the packages responsible.
find . -name "*.so”
Test 16kb enabled emulator
Finally, head over to android studio and create a 16kb enabled emulator if you don’t have one already. They are typically emulators with API level 36 support. If everything works, your app should install and launch without issues. If not, you’d get a popup during launch that states that your app is not 16kb compatible.
Note: it is recommended you use Android studio Narwhal 2025.1.3+ as earlier versions can show false 16kb warnings.
Conclusion
Cheers! You’ve come to the end of this migration guide. I hope this saved you time and prospective days you could have spent debugging Gradle issues. Performing migrations for projects, especially huge ones can be draining, but with the right guide, you can avoid issues and finish up in record time. Share this with anyone you know who might need this! Likes and comments are also very encouraged! ;D
Follow me for more related articles and find me on X.