Android 17 ships a new per-app memory limit that can swap an app's memory into compressed RAM, then kill the process outright, and the crash report that lands in your dashboard won't say why. Google announced the change in an Android Developers Blog post in August 2026, and it's rolling out on Pixel devices first before spreading to other manufacturers over the coming year. If your Android app has been logging unexplained terminations lately, this is the first thing worth ruling out.
What Android 17's per-app memory limit actually does
Google built the feature to protect the overall user experience from apps that use excess memory and slow the whole system down. It's live on Pixel devices first, and Google says other manufacturers will adopt it over the coming year, across devices with anywhere from 4GB to 16GB and up of RAM. The post doesn't name a single non-Pixel OEM, a version number, or a date. Anything more specific than "the coming year" is a guess, not something Google has published.
If your app ships on Pixel today, assume the limit already applies to it. If it doesn't, you don't know when that changes, only that Google has said it will, at some point in the next year.
How enforcement escalates
Cross the threshold and Android doesn't kill your process right away. It moves to zRAM swapping first: the app's memory pages get compressed and pushed into a compressed RAM pool, which produces "noticeable UI jank and experience slowdowns" instead of a crash. Apps built on Jetpack Compose's declarative rendering often show that jank first, dropped frames and stutter during scroll or animation, because recomposition is competing for the same pages the system just swapped out.
Keep exceeding the limit after that and Android terminates the process. That's the moment a report that looks like a routine out-of-memory crash is actually the memory limiter doing exactly what it's supposed to do.
How to detect a memory-limit kill in production
Teams running Kotlin Multiplatform need to wire this up specifically on the Android target, since it's an OS-level behavior with no iOS equivalent. If you're weighing how KMP teams share platform-level code, this is one of the places sharing has to stop.
1. Check ApplicationExitInfo.getDescription()
Query ApplicationExitInfo for exit reason REASON_OTHER and read the description string it returns. When Android's memory limiter caused the exit, the description contains the literal string MemoryLimiter:AnonSwap. Grep your crash pipeline for that exact string and you can separate memory-limit kills from every other REASON_OTHER exit your app already logs.
2. Capture heap dumps with ProfilingManager
On Android 15 (API level 35) and above, the same post says ProfilingManager can auto-capture a heap dump the moment the limit is reached if you register a trigger of type TRIGGER_TYPE_ANOMALY. That gives you the actual heap contents at the point of the swap, not just an exit reason logged after the fact.
3. Watch Android vitals in Play Console
Play Console's Android vitals already track Memory Usage, split into Anonymous RSS and swap, plus Bitmap Memory Usage. Watch the swap figure specifically. A rising swap number on devices that never showed one before tends to show up days before the exit-reason spike does.
4. Upgrade Crashlytics for OOM tracking
If you're on Firebase Crashlytics, move to version 20.1.0, which Google says adds debug data for out-of-memory exceptions and memory limiter kills. Older versions won't tag these kills the same way, so you'll see the crash volume without the context that explains it.
What's still unknown
Google's post doesn't publish a memory threshold for any RAM tier. There's no MB or GB figure to test against on a 4GB device or a 16GB one, so you can't budget your app's memory usage against a known ceiling yet. Until that number shows up somewhere, the honest answer to "how much memory can my app use" is: less than before, by an amount nobody outside Google has stated.
The same gap applies to timing on non-Pixel hardware. There's no manufacturer named, no version tied to a specific OEM, and no date beyond "an increasing number of manufacturers" over the coming year. Build the detection now and you won't need either number to notice when it starts happening to your users.
FAQ
Does this affect all Android devices right now?
No. The limit is live on Pixel devices only at launch, and Google says other manufacturers will pick it up over the coming year across devices from 4GB to 16GB+ of RAM. If your users skew away from Pixel, you likely have time before this reaches most of your install base, but the source doesn't say how much.
What's the difference between a memory-limit kill and a normal OOM crash?
A memory-limit kill reports exit reason REASON_OTHER with MemoryLimiter:AnonSwap inside the description string. A standard system-level OOM kill won't carry that string. If you're already parsing ApplicationExitInfo output, that string is the entire difference between the two.
Do I need to change my app's memory usage before this rolls out?
Not urgently. There's no compliance deadline in Google's post and no published threshold to build against yet. What's worth doing now is wiring up detection, so instead of chasing a mystery crash spike after the rollout reaches your users, you already know what MemoryLimiter:AnonSwap looks like in your own data.