App Size Optimization in Mobile Development: Fundamentals, Methods, and Practices

What is App Size Optimization

App Size Optimization is a mobile development discipline aimed at minimizing the size of the application installation package. It includes removing dead code and resources, compressing images, optimizing libraries, splitting builds for different architectures, and using on-demand delivery technologies.

Application size affects unevenly different user segments. In regions with developed mobile infrastructure (USA, Europe, Japan) the difference between 50 and 100 MB may be unnoticeable. In developing regions (India, Indonesia, Brazil) every extra megabyte reduces installation conversion due to data plan limits and mobile internet speed. Google Play limits APK size to 200 MB, but recommends keeping it below 100 MB.

For the iOS App Store, the maximum download size over cellular is 200 MB (it was 150 MB before 2023). If the IPA exceeds this limit, the user can only install the app via Wi-Fi. Apple also supports App Thinning, which includes Slicing, Bitcode, and On-Demand Resources — technologies that automatically reduce installation size on a specific device without developer involvement.

Why App Size Matters

App size affects not only installation conversion, but also retention, update frequency, and first launch speed. Every additional megabyte is a barrier between the user and using your product.

Impact on Installation Conversion

According to Google I/O 2024, reducing APK by 10 MB increases installation conversion by an average of 3.5%. For apps sized 150+ MB, conversion can be 20–30% lower than for apps of the same class sized 50 MB. The effect is especially pronounced on Google Play, where the user sees the size before installation. In the App Store, the size is shown on the app page, and users with limited data plans postpone installation to Wi-Fi, after which they often forget about the app.

Update Frequency and Over-the-Air Updates

Large apps are updated over the air less frequently — users postpone downloading patches to Wi-Fi, missing critical security fixes. Google Play allows Incremental Updates (patches up to 10 MB), but a full reinstallation still downloads the complete APK or AAB. The Apple App Store uses Delta Updates, transferring only changed files, but even the delta can be significant when resources change.

First Launch and Unpacking

Size directly affects first launch time: the app must unpack resources, compile code (Android) or sign the cache (iOS). A 200 MB app can launch 10–15 seconds slower than a 50 MB app on an average device. This worsens the Onboarding Experience — the user may close the app without waiting for it to load.

Optimizing Resources and Assets

Resources — images, fonts, sounds, videos — make up 60–80% of a typical mobile app’s size. Resource optimization gives the biggest gain with minimal effort. The main directions are: compression, removing duplicates and unused assets, choosing the right formats.

Image Optimization

WebP — an image format from Google that provides 25–35% better compression than PNG and 15–20% better than JPEG at the same visual quality. Android supports WebP natively since API 18. For iOS, WebP is supported via SDWebImage or Kingfisher libraries, and native support appeared in iOS 17. AVIF — a more modern format that gives an additional 10–15% savings over WebP, but with slower decoding.

Removing unused resources — the simplest way to reduce size. In Android, use refactoring with Android Studio: Analyze → Run Inspection → Unused Resources. In iOS — Build Settings → Remove Unused Resources. Often projects retain sprites from early versions, old icons, unused launch screen images that bloat the size without any functional load.

Font and Audio Optimization

Custom fonts can take up 5–15 MB, especially if the entire typeface is included (all styles: Regular, Bold, Italic, BoldItalic). Use only the necessary styles and character subsets through subsetting — removing glyphs for languages not supported by the application. Services like Google Fonts and Transfonter allow creating a minimal character set. For audio, use AAC/HE-AAC instead of WAV and uncompressed formats — saving up to 90% without quality loss.

Optimizing Code and Libraries

Code makes up 20–40% of the app size, but optimizing it is more complex than resources because it requires dependency analysis, obfuscation, and dead code removal without risking breaking functionality.

ProGuard and R8 for Android

ProGuard is an Android tool that performs obfuscation, minification, and code optimization. R8 — its successor, built into the Android Gradle Plugin, works faster and more efficiently. R8 removes unused classes and methods, shortens variable names, and rewrites code to reduce the number of instructions. Typical DEX file size reduction with R8 is 30–50%.

// build.gradle — R8 configuration for minification
android {
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
                'proguard-android-optimize.txt')
            shrinkResources true
        }
    }
}

Library and Dependency Optimization

Libraries — a common cause of bloated size. One library can pull transitive dependencies that increase size by 5–20 MB without direct benefit to the application. Use Gradle Version Catalog for Android and Swift Package Manager for iOS with explicit dependency declarations. Analyze size using Build Analyzer in Android Studio or Xcode Build Timeline. Replace heavy libraries with lighter alternatives: for example, OkHttp (3 MB) instead of Apache HTTP (15 MB).

Removing Unused Code in iOS

Dead Code Stripping — automatic removal of unused methods and classes at the linking stage in Xcode. Enabled via Build Settings → Dead Code Stripping = YES. Bitcode — an intermediate representation that Apple can recompile for different architectures, removing unused functions. However, since Xcode 14, Bitcode has become optional, and its contribution to size reduction is 5–15% for Objective-C projects and less for Swift.

App Thinning and On-Demand Delivery

App Thinning — Apple’s technology that automatically reduces the size of the installed app by delivering only the resources needed by a specific device. It consists of three components: Slicing, On-Demand Resources, and Bitcode. On Android, the equivalent is Android App Bundle (AAB) with Dynamic Delivery.

Android App Bundle (AAB)

AAB — a publishing format on Google Play where the store generates APKs for each device separately, including only resources for its architecture (armeabi-v7a, arm64-v8a), screen density (mdpi, hdpi, xhdpi, xxhdpi, xxxhdpi), and languages. Typical installation size reduction when switching from a universal APK to AAB is 20–40%. Play Feature Delivery allows loading modules on demand, while Install-time modules are included in the base installation.

// build.gradle — AAB and Dynamic Features configuration
android {
    bundle {
        language {
            enableSplit = true
        }
        density {
            enableSplit = true
        }
        abi {
            enableSplit = true
        }
    }
}

On-Demand Resources in iOS

On-Demand Resources (ODR) — an iOS mechanism where resources (game levels, high-resolution images, videos) are downloaded from Apple’s servers only when they are actually needed by the user. The initial installation size can be reduced by 50–80%. Resources are divided into three categories: Initial Install Tags (downloaded during installation), Prefetched Tag Order (downloaded in the background after installation), and On-Demand (downloaded only on request). Apple recommends using ODR for content that is not needed on the first screen: game levels, additional content, video tutorials.

SwiftUI supports ODR via the Bundle.module attribute, while UIKit uses NSBundleResourceRequest. For games on Unity and Unreal Engine, ODR is integrated at the native wrapper level. The main limitation is that ODR resources are deleted by the system when storage is low, so critical data must be included in the main build.