Hi everyone,
We are facing a persistent issue with our iOS app related to memory limits and would greatly appreciate any insights or guidance from the community.
Context:
Platform & Version: iOS
Development Environment: Xcode 15.4, macOS 14.6.1
Runtime Configuration: iOS 17.6.1, iPad Air 1TB (16GB RAM)
Issue Summary:
Our app crashes when it hits memory usage around 5–6GB after being distributed through the App Store. To address this, we enabled the com.apple.developer.kernel.increased-memory-limit entitlement, which allowed much higher memory usage (up to ~15GB) during local testing with a development build.
What We Tested:
Local Build (Development Profile):
Added the com.apple.developer.kernel.increased-memory-limit entitlement to the app. Tested on a physical iPad and found that the app could use nearly 15GB of RAM before crashing. This confirmed that the entitlement was having a positive effect in this non-App Store scenario. App Store Build (Distribution Profile):
Used the same entitlement-enabled code and configuration for distribution. After installing the App Store version on the same device, we found the app now crashes around the 6GB RAM usage mark—essentially the standard limit. It appears that the entitlement is not taking effect in the App Store environment.
Key Concern:
Why is the com.apple.developer.kernel.increased-memory-limit entitlement not having any effect on the App Store version of the app, even though it works perfectly when testing with a locally signed development build?
What We’ve Considered So Far:
Entitlement Restrictions: Is com.apple.developer.kernel.increased-memory-limit restricted or only allowed for certain first-party or special partner apps?
Profile Differences: Could differences between development and distribution provisioning profiles cause the entitlement to be ignored?
App Store Validation: Does the App Store review or signing process remove or nullify certain restricted entitlements?
Request for Assistance:
If anyone has experience with this entitlement or similar restricted entitlements, we would greatly appreciate your advice. Specifically, we are looking to understand:
Has anyone successfully enabled increased memory limits in an App Store build using this or a similar entitlement?
Is there an official Apple process or documentation for requesting or enabling such entitlements for third-party apps?
Are there any known workarounds or best practices for handling large memory usage within the standard limits?
We’ve contacted Apple Developer Support, and they recommended posting this on the forum for community feedback before they proceed further. Any guidance or shared experiences would be extremely helpful.
Thank you!
Hi,
So, first off, there are actually three entitlements involved here that overlap each other to a significant extent:
-
"Increased Memory Limit" -> "com.apple.developer.kernel.increased-memory-limit" entitlement.
-
"Increased Debugging Memory Limit" -> "com.apple.developer.kernel.increased-debugging-memory-limit"
-
"Extended Virtual Addressing" -> "com.apple.developer.kernel.extended-virtual-addressing"
The first two (1 & 2) are fairly similar, with the difference being that, by design, the second ("Debugging") variant will never be included in release builds. If you unintentionally used the second version, then that would immediately explain the failure you're seeing. In the interest of getting a response out I won't try to describe the difference between 1 & 3 beyond saying that the issues here are more complicated than "get more memory".
That leads to here:
Used the same entitlement-enabled code and configuration for distribution. After installing the App Store version on the same device, we found the app now crashes around the 6GB RAM usage mark—essentially the standard limit. It appears that the entitlement is not taking effect in the App Store environment.
The first thing you should verify here is that the entitlement IS part of your app store release. I suspect that it simply isn't, which basically makes this about codesigning, not memory. I posted a detailed explanation of how to manually validate the entitlements of a build in this post and then followed that with extended example of the output in the next post. Note that while both of those posts are about DEXT validation, the process itself is identical.
Finally, a note here:
...best practices for handling large memory usage within the standard limits?
Off the top of my head, there are two things I'd pay attention to:
- Don't assume the entitlement will actually get you more memory. The entitlement page includes this note and it should be followed:
Note An increased memory limit is only available on some device models. Call the os_proc_available_memory function to determine the amount of memory available. Higher memory use can affect system performance.
- The results you get on your test device will often be MUCH better than you'll get on a real world device. When you're running on a dedicated development device you generally end up running that app as the "only" app but that's not how consumer devices are actually used. Real world usage is far more variable and, most importantly, often involves multiple apps which can and will have higher system priority than your app (even in the foreground).
__
Kevin Elliott
DTS Engineer, CoreOS/Hardware
