App thinning

On this page 7

App thinning is a set of Apple platform technologies that make the App Store deliver only the binaries and assets a specific device needs, instead of one universal package containing everything for every model. In mobile distribution, it reduces download size, installation size and update size on iPhone, iPad, Apple TV and Apple Watch without forcing developers to maintain separate builds by hand.

Apple introduced app thinning with iOS 9 in 2015 as three cooperating mechanisms: app slicing, on-demand resources and the now-retired bitcode recompilation. Developers still upload a single archive to App Store Connect; the store then produces device-specific variants and serves the right one to each customer.

How app thinning produces device-specific variants

App thinning works by treating the uploaded archive as a master package from which the App Store generates many smaller app variants. Each variant targets a combination of device traits, such as the CPU architecture, the screen scale factor (@1x, @2x or @3x), the GPU family and the Metal feature set, and the amount of memory available.

When a customer taps Get or Update, the device reports its traits and the store selects the matching variant. Assets that the device can never display, such as @2x images on a @3x screen or textures compressed for another GPU, are simply not downloaded. The developer never ships these variants manually, which keeps the distribution workflow as simple as a single upload.

The following table summarizes the three mechanisms that originally made up app thinning and their current status.

MechanismWhat it doesCurrent status
App slicingRemoves code and assets irrelevant to the target deviceActive and automatic
On-demand resourcesHosts tagged assets and downloads them when neededActive, being superseded by Background Assets
BitcodeLet Apple recompile intermediate code for new CPUsDeprecated in Xcode 14 (2022)
The three app thinning mechanisms

App slicing and the asset catalog

App slicing is the core of app thinning and depends on resources being stored in an asset catalog (the .xcassets bundle) rather than as loose files. Xcode compiles the catalog into a Assets.car file that records trait metadata for every image, data set and texture, so the store knows which device each item belongs to.

Loose PNG files placed directly in the bundle cannot be sliced, because the store has no reliable metadata about which screen they serve. For that reason, the most important practical step for developers is to move images, colors, symbol variants and Metal textures into asset catalogs and to mark each asset with the correct scale and device idiom.

The traits below are the main dimensions along which slicing separates content.

TraitExample valuesContent affected
Screen scale@2x, @3xRaster images and icons
Device idiomiPhone, iPad, Watch, TVInterface assets and layouts
GPU familyApple GPU families by chip generationCompressed textures
Memory class1 GB to 8 GB and aboveHigh-resolution data sets
Architecturearm64, arm64eExecutable code slices
Device traits used for slicing

Since Apple dropped 32-bit support, the architecture dimension matters far less than it once did; almost all current savings come from image scale and texture variants. Games and media-heavy apps therefore benefit most, while small utility apps built mainly from code and vector symbols may see only modest reductions.

On-demand resources and deferred content

On-demand resources (ODR) extend app thinning beyond the device dimension by letting developers tag assets that the App Store hosts separately and the app requests at runtime. A game can install only its first levels and fetch later levels while the player progresses, which shrinks the initial install size considerably.

Tags belong to three categories: initial install tags downloaded with the app, prefetched tags downloaded right after installation, and tags fetched only when the code calls NSBundleResourceRequest. The system may purge downloaded tags under storage pressure, so code must always check availability and handle a failed or slow request gracefully.

Apple now positions the Background Assets framework, with Apple-hosted asset packs, as the more flexible successor for large downloadable content, although ODR remains supported in existing apps.

App thinning compared with Android delivery models

App thinning is Apple-specific, but Google Play solves the same problem through the Android App Bundle (AAB) and Play Feature Delivery. In both ecosystems, the developer uploads one publishing format and the store generates optimized installation packages for each device, while the old universal APK and universal IPA approaches shipped everything to everyone.

The comparison below shows how the concepts map across platforms in mobile distribution.

ConcernApple platformsGoogle Play
Upload formatXcode archive exported to IPAAAB
Per-device splittingApp slicingSplit APKs by ABI, density and language
Deferred contentOn-demand resources, Background AssetsPlay Feature Delivery, Play Asset Delivery
Signing of variantsApple re-signs thinned variantsPlay App Signing
Language splittingNot part of slicingLanguage splits by default
Equivalent concepts on Apple and Google platforms

One notable difference is localization: Android bundles routinely split language resources, while app slicing on Apple platforms keeps all localizations in every variant. Teams with dozens of languages and large localized media should therefore consider downloadable content for those assets on iOS.

Measuring thinned size and avoiding common mistakes

Developers should measure thinned sizes before release rather than rely on the size of the uploaded IPA, which is always larger than what customers download. Exporting an archive with the App Thinning option set to all compatible devices produces an App Thinning Size Report.txt listing the compressed and uncompressed size of each variant, and App Store Connect later shows the actual download and install sizes per device model.

The following mistakes most often reduce or cancel the benefit of app thinning.

MistakeEffectFix
Images stored as loose filesNo slicing for those imagesMove them into an asset catalog
Universal assets for all scalesEvery device downloads the largest imageProvide per-scale or vector assets
Large embedded media filesInstall size stays high on all devicesUse on-demand resources or Background Assets
Assuming ODR tags persistCrashes or missing content after purgeCheck and request tags before use
Judging size from the IPAMisleading size estimatesRead the thinning size report
Frequent mistakes and their fixes

A further consideration is the cellular download limit: App Store downloads above a size threshold, historically 200 MB, triggered a confirmation prompt on mobile data, and users can configure this behavior. Keeping each thinned variant small therefore has a direct effect on conversion and update adoption, especially in markets where mobile data is expensive.

In everyday language

App thinning means your phone downloads only the parts of an app it can actually use. A developer sends Apple one big package that contains pictures and code for every iPhone and iPad. Apple then cuts it into smaller versions, one for each kind of device.

Think of a clothing catalog that lists every size. Instead of mailing you the whole rack, the shop sends only the shirt in your size. The result is a faster download and more free storage, and sometimes extra content arrives later, only when you reach the part of the app that needs it.

Seen in the real world

A small studio prepares a puzzle game for iPhone and iPad. Its universal archive weighs about 1.4 GB, mostly because every texture exists in several resolutions and every one of 60 levels ships with its own music and background art. The team moves all images into asset catalogs with separate @2x, @3x and iPad variants, and tags levels 11 to 60 as on-demand resources.

The thinning size report then shows that a recent iPhone downloads roughly 310 MB at first install, while an iPad receives about 380 MB because of its larger textures. Later levels are fetched in the background while the player solves earlier puzzles. After launch, the studio sees fewer abandoned downloads on cellular connections and faster adoption of updates, since each update now carries only the changed, device-relevant files.