Swift By Rahul
September 16, 2026 · 9 min read ·

Reducing iOS App Size: Practical Techniques

In the competitive world of mobile apps, every kilobyte counts. A large app size can deter potential users, lead to slower downloads, consume more cellular data, and take up valuable storage space on a user's device. All of these factors can negatively impact your app's download conversion rates and user retention. As iOS developers, understanding how to effectively reduce your app's footprint is a crucial skill.

Apple provides powerful tools and mechanisms like App Thinning to help optimize your app for various devices, but there are many strategies you can employ at every stage of development to keep your app lean. In this article, we'll dive into practical techniques, from asset optimization to leveraging On-Demand Resources, to help you ship smaller, more efficient iOS applications.

Impact of App Size on User Experience Large App Size Slow Download User Frustration / Uninstallation Optimized App Size Fast Download Positive User Experience

Understanding App Size Components

Before optimizing, it's essential to know what contributes to your app's size. When you archive your app and export it for App Store distribution, Xcode generates an .ipa file. This file contains:

  • Executable Code: Your compiled Swift code, third-party libraries, and system frameworks.
  • Assets: Images, audio, video, 3D models, fonts, etc.
  • Resources: Plist files, storyboards, NIBs, Core Data models, etc.
  • Localization Data: Strings and resources for different languages.

Apple's App Thinning process then takes this universal .ipa and creates smaller, device-specific variants for users to download. This involves:

  • App Slicing: Delivering only the executable architectures and resources (e.g., @2x, @3x images) relevant to the user's specific device.
  • Bitcode: (Primarily for watchOS/tvOS, less relevant for iOS now) An intermediate representation of your compiled program that allows Apple to re-optimize your app binary later.
  • On-Demand Resources (ODR): Assets and data that are hosted on the App Store and downloaded by your app only when needed.

While App Thinning helps, your initial .ipa size directly impacts the final thinned size.

Optimizing Assets: The Low-Hanging Fruit

Assets often account for the largest portion of an app's size. Focus your efforts here first.

Images

  1. Use Asset Catalogs (.xcassets): Always import images into an asset catalog. This allows Xcode to perform App Slicing, delivering only the resolution needed for a specific device (@1x, @2x, @3x). It also optimizes image formats and metadata.
  2. Vector Assets (PDFs): For simple icons and illustrations, use vector PDFs. Xcode can generate device-specific PNGs from a single PDF, ensuring crisp scaling without multiple raster files. Make sure to check the "Preserve Vector Data" option in the Assets catalog.
  3. Choose the Right Format:
    • PNG: Best for images with transparency, sharp edges, and fewer colors (e.g., UI elements, logos).
    • JPEG: Ideal for photographs and complex images with smooth color gradients, as it uses lossy compression to achieve smaller file sizes. Adjust compression quality carefully.
    • WebP: While WebP offers superior compression, it's not natively supported by iOS UIImage. You'd need to include a third-party library, which adds to your app's binary size. Weigh the pros and cons. 4. Compress Images: Even within PNG/JPEG, ensure images are compressed. Tools like ImageOptim or TinyPNG can significantly reduce file sizes without noticeable quality loss. 5. Avoid Redundant Images: Review your assets for duplicates or images that are no longer used. 6. on-demand resources for large assets: If you have many large images or image sequences that aren't critical for the initial launch (e.g., onboarding screens, tutorials, specific feature assets), consider making them On-Demand Resources. We'll discuss ODR in more detail later.

Audio and Video

  1. Compression: Use efficient codecs and appropriate bitrates for audio (e.g., AAC, HE-AAC) and video (e.g., H.264, HEVC).
  2. Streaming vs. Bundling: For large video or audio content, consider streaming it from a server rather than bundling it with your app. Only include essential, short clips locally.
  3. Optimize Resolution: For video, only include resolutions that are strictly necessary for your target devices.

Code and Framework Optimization

Your compiled code and the frameworks you link also contribute to the app's size.

Removing Unused Code and Features

  • Dead Code Elimination: Xcode's linker (ld) is generally good at removing unused code, but you can help it.
    • Conditional Compilation: Use #if DEBUG and #endif to exclude debug-only code, logging, or test features from release builds.
    • Feature Flags: For features that might be temporarily disabled or A/B tested, ensure their code and assets are truly removed if the feature is not shipped.
    • Auditing Third-Party Libraries:
    • Dependency Bloat: Every framework you include adds to your app's size. Regularly audit your dependencies. Do you really need that large analytics library if you only use 1% of its features? Can you implement a smaller, specific solution yourself?
    • Static vs. Dynamic Libraries: Static libraries are linked directly into your app's executable, potentially making the executable larger but removing the need for a separate dynamic library file. Dynamic libraries (frameworks) are loaded at runtime. For App Store apps, dynamic frameworks are embedded within your app bundle. If you have many small dynamic frameworks, the overhead of each framework might add up. Swift Package Manager (SPM) typically builds static libraries by default for targets within the same package, which can lead to smaller overall app sizes compared to dynamic frameworks from CocoaPods/Carthage if not configured carefully.

Compiler Optimization Levels

For release builds, ensure you're using appropriate compiler optimization settings:

  • Optimization Level: In your target's Build Settings, for "Release" configuration, set "Optimization Level" to Optimize for Speed [-O] or Optimize for Size [-Os]. [-Os] prioritizes smaller binary size, which is often desirable for app store builds.

On-Demand Resources (ODR)

ODR is a powerful App Thinning feature that allows you to tag assets and data to be downloaded only when your app needs them. This is perfect for:

  • Game levels
  • Tutorials or onboarding videos
  • Premium content
  • Seldom-used features

How to Use ODR

  1. Tag Assets: In your Asset Catalog or the File Inspector for any resource, assign an "On-Demand Resource Tag."
  2. Request Resources: Use NSBundleResourceRequest to request tags programmatically.
import Foundation

class OnDemandResourceManager {

    static let shared = OnDemandResourceManager()

    enum ODRTag: String, CaseIterable {
        case tutorialVideos = "TutorialVideos"
        case premiumContent = "PremiumContent"
        case levelPack1 = "LevelPack1"
    }

    private var activeRequests: [ODRTag: NSBundleResourceRequest] = [:]

    func requestResources(for tag: ODRTag, progressHandler: ((Progress) -> Void)? = nil, completion: @escaping (Result<Void, Error>) -> Void) {

        if let existingRequest = activeRequests[tag] {
            // If already active, just monitor progress or complete if done
            if existingRequest.progress.isFinished {
                completion(.success(()))
            } else {
                existingRequest.progress.cancellationHandler = { completion(.failure(URLError(.cancelled))) }
                existingRequest.progress.pausingHandler = { completion(.failure(URLError(.cancelled))) }
                // Optionally, attach a new progress handler
                existingRequest.progress.observe(\.fractionCompleted, options: [.new]) { progress, _ in
                    progressHandler?(progress)
                }
            }
            return
        }

        let request = NSBundleResourceRequest(tags: [tag.rawValue])
        activeRequests[tag] = request

        request.progress.observe(\.fractionCompleted, options: [.new]) { progress, _ in
            progressHandler?(progress)
        }

        request.beginAccessingResources { error in
            DispatchQueue.main.async {
                self.activeRequests[tag] = nil // Request finished or failed
                if let error = error {
                    print("Failed to access resources for tag \(tag.rawValue): \(error.localizedDescription)")
                    completion(.failure(error))
                } else {
                    print("Successfully accessed resources for tag \(tag.rawValue)")
                    completion(.success(()))
                }
            }
        }
    }

    func endAccessingResources(for tag: ODRTag) {
        activeRequests[tag]?.endAccessingResources()
        activeRequests[tag] = nil
        print("Ended accessing resources for tag \(tag.rawValue)")
    }

    func conditionallyBeginAccessingResources(for tag: ODRTag) {
        let request = NSBundleResourceRequest(tags: [tag.rawValue])
        request.conditionallyBeginAccessingResources { available in
            if available {
                print("Resources for \(tag.rawValue) are already available.")
            } else {
                print("Resources for \(tag.rawValue) are not available yet.")
            }
        }
    }
}

Usage Example:

// Requesting tutorial videos
OnDemandResourceManager.shared.requestResources(for: .tutorialVideos) { progress in
    print("Download progress: \(progress.fractionCompleted * 100)%")
} completion: { result in
    switch result {
    case .success:
        print("Tutorial videos ready!")
        // Use the resources, e.g., load a video from bundle
        if let path = Bundle.main.path(forResource: "intro_video", ofType: "mp4", inDirectory: "TutorialVideos") {
            print("Video found at: \(path)")
        }
    case .failure(let error):
        print("Error downloading tutorial videos: \(error.localizedDescription)")
    }
}
On-Demand Resources Workflow User Device Download App Minimal App Bundle App Store App Runs Requests ODR ODR Assets Downloads ODR Uses ODR

ODR is an excellent way to provide a small initial download while still offering rich content. Resources are automatically cached by the OS and can be purged if storage runs low, so your app must be prepared to re-request them.

Stripping Symbols and Debug Information

During the build process, Xcode generates debug symbols (dSYM files) that are crucial for symbolication of crash reports. However, these symbols are not needed in the app bundle itself for distribution.

Check your target's Build Settings:

  • Strip Style: Set to All Symbols for Release builds. This removes symbols from the linked product.
  • Strip Linked Product: Set to Yes for Release builds.
  • Strip Debug Symbols During Copy: Set to Yes for Release builds.

These settings ensure that your app binary is as small as possible while still generating the necessary dSYM files for crash reporting, which are uploaded separately to App Store Connect.

Data Storage and Caching

If your app uses local databases (e.g., Core Data, Realm, SQLite) that come pre-populated with data, consider if this data is truly essential for the initial launch.

  • Download on First Launch: For large datasets, download them from your server after the app is installed, rather than bundling them.
  • Efficient Formats: If bundling, ensure your data files are compressed and in efficient formats.

Final Review

Before submitting your app, always perform a final review:

  1. Analyze App Size: Use Xcode's "Distribute App" workflow to generate an App Store Connect build. After archiving, select "Distribute App" -> "App Store Connect" -> "Export" or "Upload". Xcode will show you an estimate of the "App Store File Size" and "Download Size" for various device configurations. This is your most accurate gauge.
  2. Review Build Phases: Look for any "Copy Files" or "Copy Bundle Resources" phases that might be inadvertently including large, unnecessary files.
  3. Check Info.plist: Ensure no large, unused files are referenced that could prevent App Thinning from removing them.
┌───────────────────────┐             ┌───────────────────────────┐
│     Large App Bundle  │             │   Optimized App Bundle    │
│ ┌───────────────────┐ │             │ ┌───────────────────────┐ │
│ │  Executable (Fat) │ │             │ │ Executable (Thinned)  │ │
│ ├───────────────────┤ │             │ ├───────────────────────┤ │
│ │ All @3x Images    │ │             │ │ Device-Specific Images│ │
│ ├───────────────────┤ │             │ ├───────────────────────┤ │
│ │ Unused Libraries  │ │             │ │ Essential Libraries   │ │
│ ├───────────────────┤ │             │ ├───────────────────────┤ │
│ │ Debug Symbols     │ │             │ │ No Debug Symbols      │ │
│ ├───────────────────┤ │             │ ├───────────────────────┤ │
│ │ Bundled Videos    │ │             │ │ Base UI Assets        │ │
│ └───────────────────┘ │             │ └───────────────────────┘ │
│                       │             │                           │
└───────────┬───────────┘             └───────────┬───────────────┘
            │                                     │
            │ Download to Device                  │ Download to Device
            ▼                                     ▼
┌───────────────────────┐             ┌───────────────────────────┐
│ Device Storage Impact │             │ Device Storage Impact     │
│       (High)          │             │         (Low)             │
└───────────────────────┘             └───────────┬───────────────┘
                                                  │
                                                  │   On-Demand Request
                                                  ▼
                                        ┌───────────────────────────┐
                                        │ Downloaded ODR (as needed)│
                                        │ ┌───────────────────────┐ │
                                        │ │ Videos, Tutorials     │ │
                                        │ ├───────────────────────┤ │
                                        │ │ Game Levels, etc.     │ │
                                        │ └───────────────────────┘ │
                                        └───────────────────────────┘

Summary

Reducing your iOS app's size is an ongoing process that yields significant benefits for user acquisition and experience. By proactively optimizing your assets, carefully managing third-party dependencies, leveraging App Thinning features like On-Demand Resources, and configuring your build settings correctly, you can deliver a lean, fast-downloading application. Make app size optimization a regular part of your development and release cycle, and your users will thank you for it.

Happy Swifting!

Tagged: