How to Shrink iOS App Package Size: Practical Optimization Techniques

1. Package Size Overview

During app iteration, package size grows as new features are added. Early versions had limited optimization and users did not notice size, but as functionality expands, size increases and brings negative impacts.

App Store OTA download size limits

Sep 2017: 100 MB

May 2019: 150 MB

iOS 13 and later: users can download over 200 MB with permission.

__TEXT segment size limits

iOS 7 and earlier: total __TEXT segment ≤ 80 MB

iOS 7.x–8.x: each CPU architecture __TEXT ≤ 60 MB

iOS 9.0 and later: total __TEXT ≤ 500 MB

Other impacts

Storage: occupies user disk space, increasing uninstall probability.

Performance: larger app leads to longer launch and response times.

Market adaptability: users may choose lighter alternatives.

2. Package Size Analysis

Mach‑O file

The core executable containing business logic compiled to machine code, static libraries, system call bridges, and runtime metadata.

Business logic code: compiled Swift/Objective‑C.

Static libraries: third‑party and custom libs.

System call interfaces.

Runtime support metadata.

Resource files

Multimedia and configuration resources that form UI and interaction.

Images (Assets.car, bundles, GIF, JPG, PNG, JSON, etc.)

Static web resources: JS, CSS, HTML

View resources: XIB, Storyboard

Audio/video: mp4, mp3, caf

Other: signatures, fonts (TTF/OTF), PLIST, DB, localization, etc.

Frameworks

Modular extensions and dependency management.

Core frameworks such as Foundation.

Third‑party dynamic frameworks.

Next, we introduce optimization practices from compiler configuration, resource compression, dynamic resource delivery, Mach‑O stripping, dead code stripping, link‑time optimization, asset catalog optimization, unused resource cleanup, image compression tools, script‑based analysis, and framework consolidation.

Compiler Optimizations

Xcode provides many size‑reduction options. Important settings include:

Optimization Level

None [-O0]: no optimization, fast compile, default for Debug.

Fast [-O, -O1]: modest performance boost, slight compile‑time increase.

Faster [-O2]: more optimizations, no loop unrolling or inlining.

Fastest [-O3]: enables all optimizations, may increase binary size.

Fastest Smallest [-Os]: all optimizations except those that increase size.

Fastest, Aggressive [-Ofast]: enables -O3 plus aggressive, non‑standard optimizations (generally not recommended).

Strip Link Product

Effective when Deployment Postprocessing is YES. Strip styles:

debugging: removes only debug symbols, no size impact.

non‑global: removes non‑global symbols, keeps global for crash logs (used in Release).

all: removes all symbols, reduces size.

Dead Code Stripping

Removes unreferenced code and symbols at link time.

# Xcode configuration</code><code>DEAD_CODE_STRIPPING = YES  # enable DCS</code><code>OTHER_LDFLAGS = -Wl,-no_dead_strip  # disable DCS for specific modules</code><code># Test project: 100k lines, 30% unused</code><code>+----------------+-----------------+------------------+</code><code>| Language | Size reduction | Typical target |</code><code>+----------------+-----------------+------------------+</code><code>| Objective‑C | 18‑22% | Uncalled classes/categories/static functions |</code><code>| Swift | 12‑15% | Unreferenced generics/protocol extensions |</code><code>| C++ | 25‑30% | Uninstantiated template classes |</code><code>| Pure C | 20‑25% | Unused global functions/macros |</code><code>+----------------+-----------------+------------------+

Link‑Time Optimization (LTO)

LTO performs whole‑program optimization at link time, reducing duplicate symbols and improving launch time.

# Xcode LTO settings</code><code>OTHER_CFLAGS = -flto  # enable compile‑time LTO</code><code>OTHER_LDFLAGS = -flto  # enable link‑time LTO</code><code>+---------------------+------------+---------------+----------------+</code><code>| Config | Size (MB) | Launch (ms) | Compile (min) |</code><code>+---------------------+------------+---------------+----------------+</code><code>| No optimization | 45.8 | 450 | 8.2 |</code><code>| LTOOnly | 39.1 (-15%) | 420 (-6.7%) | 12.5 (+52%) |</code><code>| LTO+DCS | 34.7 (-24%) | 405 (-10%) | 13.1 (+60%) |</code><code>| LTO+DCS+Strip | 31.2 (-32%) | 390 (-13.3%) | 13.8 (+68%) |</code><code>+---------------------+------------+---------------+----------------+

Asset Catalog Compiler

Set ASSETCATALOG_COMPILER_OPTIMIZATION = space to maximize compression while preserving visual quality.

Resource Deep Optimization

Package Component Analysis

We script an IPA component analyzer that outputs type‑wise size distribution.

Unused Resource Cleanup

Tools such as fdupes, LSUnusedResources, or custom shell scripts identify and remove duplicate or unused images, audio, and plist files.

Original Image Compression

Use Asset Catalog for PNGs; Xcode’s actool compresses with algorithms like lzfse, palette_img, deepmap2, zip. For lossy compression, tools include TinyPNG, ImageOptim, pngquant, Guetzli.

$ pngquant --quality=20-30 filename.png

App Packaging Compression

Large third‑party resources can be compressed into a ZIP stored in the sandbox and unpacked at launch.

Mach‑O Optimization

Static Analysis

Run Clang static analyzer:

$ analyze -workspace Huolala.xcworkspace -scheme Huolala -configuration Release -sdk iphoneos CLANG_ANALYZER_OUTPUT=plist-html CLANG_ANALYZER_OUTPUT_DIR="$(pwd)/clang_analysis"

Symbol Table Cross‑Check

# Extract defined symbols</code><code>nm -u xxx.app/xxx | grep 'OBJC_CLASS_$_' > defined_symbols.txt</code><code># Extract used symbols</code><code>otool -v -s __TEXT __objc_methname xxx.app/xxx > used_symbols.txt</code><code># Find unused methods</code><code>comm -23 <(sort defined_symbols.txt) <(sort used_symbols.txt) > unused_methods.txt

Dynamic Analysis

Identify low‑usage pages (<5% traffic) and replace with H5 or remove.

Unused Class Cleanup

Use tool WHC_ScanUnusedClass to detect unused Objective‑C and Swift classes.

Framework Optimization

Dynamic Library Merging

Merge multiple .dylib or .framework files into a single library to eliminate redundancy.

# Extract object files</code><code>ar -x ../libA.dylib</code><code>ar -x ../libB.dylib</code><code>ar -x ../libC.dylib</code><code># Merge objects</code><code>ld -r -o merged.o *.o</code><code># Create new dynamic library</code><code>clang -dynamiclib -o libAllInOne.dylib merged.o -install_name @rpath/libAllInOne.dylib -compatibility_version 1 -current_version 1.0

Dynamic to Static Conversion

Convert dynamic frameworks to static libraries via custom pod plugins or modifying podspec (set s.static_framework = true).

$ sudo gem install cocoapods-mdapbox</code><code># binary.yml example</code><code>program:</code><code>  pod_name: AFNetworking</code><code>  pod_version: 4.0.1</code><code>  repo: huolala-hll-wp-specs-ios</code><code>  swift: true</code><code>  xcframework: true

pod publish --binary

Additional Strategies

On‑demand dependencies: split dynamic libraries into sub‑modules.

Remove unused libraries (e.g., Moya, Toast).

Eliminate duplicate functionality (e.g., keep either SDWebImage or Kingfisher).

Exclude debug‑only libraries from Release builds.

Staticize the entire project using use_frameworks! :linkage => :static.

Continuous Optimization & CI Monitoring

Integrate MDAP platform to monitor package delta before each Release; trigger alerts when size exceeds thresholds.

Conclusion

The article presents a comprehensive iOS client package size reduction practice, covering compiler settings, resource trimming, image compression, code analysis, framework governance, coding guidelines, and anti‑degradation mechanisms. Prioritizing resource cleanup yields the most noticeable gains, and thorough regression testing ensures stability after each optimization.