Why App Size Matters

App size isn't just a technical metric—it directly impacts how many people download your app. Research from Google found that for every 6MB increase in app size, install conversion rates drop by 1%. Apple hasn't published similar numbers, but the logic is the same: bigger apps mean more friction.

The 200MB limit is the critical threshold. Above that, users on cellular need to either wait for WiFi or manually allow the download in Settings. Most won't bother. That "Download on WiFi" prompt has killed countless potential installs.

Measure Your App Size First

Before optimizing anything, you need to understand what's actually taking up space. The file size you see in Finder is NOT what users download—Apple applies compression and App Thinning.

Method 1: App Store Connect

The most accurate way to see your real-world size:

1. Upload a build to App Store Connect
2. Go to TestFlight or the App Store tab
3. Click on your build and find "App File Sizes"
4. You'll see the compressed download size for each device

Method 2: Xcode App Size Report

For quick local checks:

1. Archive your app (Product → Archive)
2. Select your archive, click "Distribute App"
3. Choose "Development" or "Ad Hoc"
4. Check "App Thinning" and select a specific device
5. Export—you'll get a size report showing compressed sizes

# Generate app size report from archive
xcodebuild -exportArchive -archivePath MyApp.xcarchive \
  -exportPath ./export \
  -exportOptionsPlist ExportOptions.plist \
  -allowProvisioningUpdates

# Check the App Thinning Size Report.txt in the export folder

Method 3: Analyzing the IPA

To see exactly what's taking up space:

# Rename .ipa to .zip and extract
mv MyApp.ipa MyApp.zip
unzip MyApp.zip -d extracted/

# Find largest files
find extracted -type f -exec ls -la {} \; | sort -k 5 -rn | head -20

# Or use du to see folder sizes
du -sh extracted/Payload/MyApp.app/*

Understanding App Thinning

App Thinning is Apple's umbrella term for three technologies that reduce download size. It's been around since iOS 9, and you get most of it for free.

App Slicing happens automatically if you're using Asset Catalogs correctly. The key is to never embed device-specific resources directly—always use Asset Catalogs so the App Store knows what can be sliced out.

Asset Optimization

Assets are almost always the biggest culprit for bloated apps. Images, videos, and audio files often account for 60-80% of total app size.

Images

Audio & Video

• Audio: Use AAC or MP3 instead of WAV/AIFF. A 44.1kHz stereo WAV is 10MB/minute; AAC at 128kbps is under 1MB/minute.
• Video: Stream from a server instead of bundling. If you must bundle, use HEVC (H.265) for iOS 11+ devices.
• Sound Effects: Use CAF format with IMA4 compression. Perfect for short sounds in games.

Code & Dependencies

Compiled code is usually 10-30% of your app, but dependencies can balloon that quickly. A "small" SDK might add 10-50MB.

Build Settings

# In your xcconfig or Build Settings:

# Enable optimizations for Release
SWIFT_OPTIMIZATION_LEVEL = -Osize  # Optimize for size over speed
GCC_OPTIMIZATION_LEVEL = s         # Same for Objective-C

# Strip debug symbols
STRIP_INSTALLED_PRODUCT = YES
STRIP_STYLE = all
COPY_PHASE_STRIP = YES

# Remove dead code
DEAD_CODE_STRIPPING = YES

# Link-Time Optimization (can significantly reduce size)
LLVM_LTO = YES  # or Monolithic for more aggressive

Audit Your Dependencies

Third-party SDKs are often the hidden size killer. Here's a typical example:

Swift-Specific Tips

• Avoid generics abuse: Heavy use of generics causes code duplication in the binary. Sometimes concrete types are better.
• Use @inlinable sparingly: It copies code to every call site, increasing size.
• Prefer static over dynamic dispatch: Using final classes and private methods enables better optimization.
• Check for bloated enums: Associated values in enums can unexpectedly increase code size.

On-Demand Resources

On-Demand Resources (ODR) let you host assets on the App Store and download them only when needed. Perfect for apps with content that not every user accesses.

Good Candidates for ODR

Implementation

// 1. In Xcode, select your asset in the Asset Catalog
// 2. In the Attributes Inspector, set "On-Demand Resource Tags"
// 3. Give it a meaningful tag like "level-2" or "premium-templates"

// Request resources in code:
let tags: Set = ["level-2"]
let resourceRequest = NSBundleResourceRequest(tags: tags)

resourceRequest.beginAccessingResources { error in
    if let error = error {
        print("Failed to download: \(error)")
        return
    }

    // Resources are now available
    // Load your assets as normal
    let image = UIImage(named: "level-2-background")
}

// When done, release the resources
resourceRequest.endAccessingResources()

Advanced Techniques

1. Dynamic Frameworks vs Static Libraries

Dynamic frameworks add overhead because each framework includes its own copy of the Swift runtime (if Swift is used). For size optimization:

• Prefer static libraries where possible
• If using CocoaPods, add use_frameworks! :linkage => :static to your Podfile
• For SPM, static linking is the default

2. Remove Unused Architectures

This matters less now with App Slicing, but during development:

# Check architectures in a framework
lipo -info Framework.framework/Framework

# Remove simulator architectures from release builds (if needed)
lipo -remove x86_64 -remove i386 -output Framework Framework

3. Use App Clips for Preview

If your app is large by nature, consider creating an App Clip. App Clips must be under 15MB (50MB for experiences from Safari) and let users try your app before committing to the full download.

4. Lazy Loading of Features

For features most users won't use immediately, consider:

• Loading view controllers lazily instead of in storyboards
• Using container views that load content on demand
• Deferring SDK initialization until the feature is accessed

5. Monitor Size in CI/CD

# After building, check size
APP_SIZE=$(stat -f%z "build/App.ipa" 2>/dev/null || stat -c%s "build/App.ipa")
MAX_SIZE=209715200  # 200MB in bytes

if [ "$APP_SIZE" -gt "$MAX_SIZE" ]; then
    echo "WARNING: App size ($APP_SIZE bytes) exceeds 200MB cellular limit"
    exit 1
fi

Frequently Asked Questions