Android’s Memory Evolution: From 4 KB Pages to 16 KB Pages

Introduction

Google is making a quiet but powerful change under the hood of Android: the default memory page size is shifting from 4 KB to 16 KB. At first glance, this may sound like a minor technical adjustment—but in practice, it has wide-reaching effects on performance, battery efficiency, and app compatibility. Let’s break down what’s happening, why it matters, and what developers need to know

Why Memory Pages Matter –

Most users never think about memory management, but it plays a critical role in how smooth, fast, and reliable Android feels. A memory page is the smallest chunk of memory that the operating system manages at a time. Until now, Android used 4 KB pages, but starting with Android 15 (API 35), the OS supports 16 KB pages on ARM64 devices.

This shift may feel small, but fewer, larger pages reduce overhead for the OS—unlocking improvements in speed and efficiency.

The New Policy and Deadlines

Here’s the key timeline developers need to track: – Android 15 (API 35) → Support for 16 KB page sizes introduced. Devices may ship with either 4 KB or 16 KB pages. – November 1, 2025 → All new apps and app updates targeting Android 15 or higher must support 16 KB pages to be published on Google Play.

In short: If your app (or its native components like shared libraries) isn’t compatible with 16 KB pages, future submissions may be rejected.

Let discuss what’s changed –

1. Platform-Level Support – Starting in Android 15, ARM64 kernels can run with 16 KB page sizes. – OEMs and developers can already enable it in custom builds to prepare for the transition.
2. Google Play Enforcement – From November 1, 2025, Play Store submissions (new apps and updates) targeting API 35+ must work correctly with 16 KB pages.
3. Why It Matters – Larger pages bring measurable performance gains: – Faster app launches – Quicker camera startup – Smoother boot times – Better battery life
Much like the migration to 64-bit architecture, this step future-proofs Android’s memory strategy.

Visualizing the Change :

Memory pages are like the drawers of a filing cabinet. The OS stores data inside these drawers and keeps track of which ones are in use.

• With 4 KB pages, a 64 KB block is divided into 16 small drawers.
• With 16 KB pages, that same block is divided into just 4 bigger drawers.

This shift has important effects:

• Less Overhead → The OS has fewer drawers to manage, so bookkeeping becomes simpler and faster.
• Faster Access → Reading/writing requires fewer lookups.
• More Cache-Friendly → Larger pages reduce Translation Lookaside Buffer (TLB) misses, improving CPU efficiency.
• Slight Tradeoff → If you only need to store a small amount of data, bigger drawers may “waste” unused space.

Visualization of page size

How to Check Page Size on Your Device

Run this in an adb shell:

 
adb shell getconf PAGE_SIZE
4096 → 4 KB pages
16384 → 16 KB pages

Code-Level Considerations for Developers
1. Checking Page Size in Native Code (C/C++)
If you’re using the NDK or writing custom allocators, check the page size dynamically:#include <unistd.h>

#include <stdio.h>

int main() {
long page_size = sysconf(_SC_PAGESIZE);
printf("Page size: %ld bytes\n", page_size);
return 0;
}

This ensures your app doesn’t assume a fixed 4 KB page size.

2. Kotlin/Java Example

import android.os.Build
import android.system.Os

fun logPageSize() {
val pageSize = Os.sysconf(Os._SC_PAGESIZE)
println("Page size: $pageSize bytes")

if (pageSize == 16384L) {
println("Running on a 16 KB page device")
} else {
println("Running on a 4 KB page device")
}
}

Compatibility Challenges

• Some legacy native libraries may assume fixed 4 KB pages and could crash or behave unpredictably. Custom memory allocators may need adjustments.
• Developers distributing apps outside Google Play may still need to adapt, since OEMs will ship more devices with 16 KB pages.

Conclusion

Android is reorganizing memory into bigger drawers (16 KB pages). The result: less overhead, faster launches, and smoother overall performance. While invisible to users, this low-level change carries very real benefits.
For developers, the clock is ticking: by November 2025, Play Store submissions must support 16 KB pages. Preparing now ensures your apps are ready for the next era of Android performance.