10 Tips to Reduce iOS & Android App Size

Reducing the size of your mobile app is crucial for providing a better user experience. Smaller apps download faster, require less storage space, and perform better - leading to more installations and fewer uninstalls due to storage issues.

Here are the key tips to make your iOS and Android apps smaller:

Remove Unused Resources
- Use tools like FengNiao (iOS) and lint (Android) to detect and remove unused resources
- Leverage Android App Bundles to optimize resources for different devices
Optimize Images and Media
- Use efficient image formats like WebP and HEIC
- Compress images with lossless or lossy tools like Imagify, TinyPNG, and ImageOptim
- Resize images to optimal sizes for each platform and device
- Compress and use efficient video formats like H.264 and H.265
Shrink and Obfuscate Code
- Use ProGuard (Android) and Link-Time Optimization (iOS) to remove unused code
- Optimize remaining code by renaming classes, removing debug info, and compressing
Leverage App Thinning and App Bundles
- Use App Thinning (iOS) to deliver optimized assets based on device
- Use Android App Bundles to generate optimized APKs for different devices
Implement On-Demand Resources and Dynamic Delivery
- Use On-Demand Resources (iOS) to download resources only when needed
- Use Dynamic Delivery (Android) to create modular apps with downloadable modules
Optimize Third-Party Libraries
- Evaluate library necessity and choose lightweight alternatives
- Use tree shaking to remove unused library code
- Monitor library performance with tools like ProGuard, Firebase, and LeakCanary
Enable Bitcode and Runtime Optimizations (iOS)
- Bitcode allows Apple to recompile your app for specific devices
- Use whole-module optimization and the swiftc compiler
Modularize and Lazy Load
- Break your app into smaller modules or frameworks
- Lazy load modules or features only when needed
Optimize Updates and Network Transfers
- Use delta updates to send only changes made to the app
- Compress content and optimize network requests
Continuous Optimization

-   Regularly monitor and analyze app size
-   Use automated testing, CI pipelines, and analytics tools
-   Conduct code reviews and refactoring to maintain a lean codebase

By following these tips, you can significantly reduce the size of your iOS and Android apps, leading to faster downloads, better performance, and an improved user experience.

Getting Started

Before you start reducing your app size, it's important to know the basics of mobile app development for both iOS and Android. Understanding the build tools and optimization methods for each platform is key to making your app smaller.

Understanding the Build Process

The build process for mobile apps includes:

Compiling code
Packaging resources
Creating the final app bundle

Both iOS and Android have ways to make this process more efficient, which can help reduce the app size.

Identifying Areas for Optimization

To start optimizing your app size, look at these areas:

Unused resources and code
Inefficient image and media compression
Unoptimized code and libraries
Ineffective use of app bundles and thinning

By focusing on these areas, you can make your app smaller and improve the user experience.

Tools and Techniques

Get to know the tools and techniques for app size optimization:

iOS: Use Xcode's tools like App Thinning and Bitcode.
Android: Use tools like ProGuard and the Android Asset Packaging Tool.

These tools can help you reduce the size of your app effectively.

Remove Unused Resources

Removing unused resources is a key step in reducing the size of your iOS and Android app. As you update your app, some features may become obsolete, and some layouts, colors, strings, etc., may no longer be used. Removing these unused resources will help keep your app size small.

Remove Unused Resources in iOS

Open your app in Xcode to see all the resources in the resource list.
Use a tool like FengNiao to detect unused resources. This tool helps you find and remove unused resources from the IPA file.

Remove Unused Resources in Android

Use the lint tool to detect unused resources in your APK file. The lint tool shows warnings about unused resources, which you can then remove.

Use Android App Bundle for Android

The Android App Bundle is a pre-APK publishing format that contains all of your app's resources and code. Google Play uses it to create multiple APKs, each optimized for different devices.

Platform	Tool	Description
iOS	FengNiao	Detects and removes unused resources from the IPA file
Android	lint	Detects unused resources in the APK file
Android	Android App Bundle	Pre-APK format that optimizes resources for different devices

Optimize Images and Media

Optimizing images and media is key to reducing the size of your iOS and Android app. Large image files can make your app bigger, leading to slower downloads and more storage use. Here are some ways to optimize image and media assets for both platforms.

Efficient Image Formats

Using efficient image formats can help reduce image size:

Format	Developer	Size Reduction
WebP	Google	Up to 25% compared to JPEG
HEIC	MPEG Group	Up to 50% compared to JPEG

Compression Tools

Compression tools can further reduce image sizes without losing quality. Here are some tools you can use:

Tool	Type	Description
Imagify	Lossless/Lossy	Reduces image sizes
TinyPNG	Lossless/Lossy	Compresses PNG and JPEG images
ImageOptim	Lossless	Optimizes images without losing quality

Best Practices

Follow these best practices when optimizing images and media:

Use vector graphics for icons and logos.
Resize images to the optimal size for each platform and device.
Compress images using lossless or lossy compression tools.
Use lazy loading to load images only when needed.
Optimize video content by compressing videos and using efficient formats like H.264 and H.265.

Shrink and Obfuscate Code

Shrinking and obfuscating code helps reduce the size of your iOS and Android app. This involves removing unused code, optimizing the remaining code, and making it harder for others to reverse-engineer your app.

Code Shrinking Tools

Platform	Tool	Description
Android	ProGuard	Removes unused classes, methods, and fields; obfuscates code
iOS	Link-Time Optimization (LTO)	Removes unused functions and data

How Code Shrinking Works

Code shrinking tools analyze your code to find and remove unused elements, a process known as "tree shaking." They also optimize the remaining code by:

Renaming classes, methods, and fields to shorter names
Removing debug information
Compressing code using algorithms like Huffman coding

Benefits of Code Shrinking

Benefit	Description
Smaller File Sizes	Reduces APK and IPA file sizes
Better Performance	Improves app performance
Increased Security	Makes code harder to reverse-engineer
Faster Loading	Speeds up app loading times

App Thinning and App Bundles

App Thinning and App Bundles help optimize app delivery based on device configuration, reducing app size for faster downloads and installations.

App Thinning for iOS

App Thinning, introduced in iOS 9, allows developers to create apps optimized for specific devices. It includes three processes: Slicing, On-Demand Resources, and BitCode.

Process	Description
Slicing	Packs assets based on the device, so users only install relevant assets.
On-Demand Resources	Divides app resources into packages downloaded only when needed.
BitCode	Intermediate representation of a compiled program, allowing Apple to recompile the app for specific devices.

Android App Bundles

Android App Bundles package and distribute Android apps efficiently. They create a single bundle with all necessary resources for different device configurations. When a user downloads the app, the Google Play Store generates an optimized APK for their specific device.

Feature	Description
Modular Download	Divides the app into modules downloaded only when needed.
Device-Specific APKs	Generates optimized APKs for different devices, reducing app size.

On-Demand Resources and Dynamic Delivery

On-Demand Resources and Dynamic Delivery help reduce the initial app size, making it more user-friendly.

On-Demand Resources for iOS

On-Demand Resources, introduced in iOS 9, let developers tag resources that can be hosted on the App Store. These resources are downloaded only when needed, reducing the initial app size. This is useful for apps with large resources, like games or educational apps.

To use On-Demand Resources:

Tag the resources in your app.
The App Store hosts these resources.
Resources are downloaded in the background as needed.

Dynamic Delivery for Android

Dynamic Delivery, introduced in Android 10, allows developers to create modular apps. Users only download the modules they need, reducing the initial app size.

Dynamic Delivery uses Android App Bundles to package and distribute apps. When a user downloads the app, the Google Play Store generates an optimized APK for their device.

To use Dynamic Delivery:

Create a modular app architecture.
Use the Android App Bundle to package and distribute your app.

Benefits of On-Demand Resources and Dynamic Delivery

Benefit	Description
Reduced App Size	Smaller initial download size
Faster Downloads	Quicker installation times
Improved User Experience	Users download only what they need
Efficient Storage Use	Saves space on devices
Easier Maintenance	Supports modular app architecture

Optimize Third-Party Libraries

Optimizing third-party libraries is key to reducing app size. These libraries can add value but also increase size, loading time, and memory use. Here's how to minimize their impact:

Evaluate Library Necessity

Before adding a library, ask if it's truly needed. Consider if the functionality can be achieved through native code or alternative libraries. Remove any unnecessary libraries to reduce size and improve performance.

Choose Lightweight Libraries

Opt for smaller, specialized libraries over large, comprehensive ones. Smaller libraries contribute less to the overall app size and often provide specific functionalities without extras. Use mobile-friendly libraries optimized for mobile devices.

Use Tree Shaking

Tree shaking removes dead code during the build process, ensuring only necessary code is included in the final bundle. Implement tree shaking to reduce library size and improve performance.

Monitor Library Performance

Use tools to shrink and obfuscate code, track errors, and measure performance:

Tool	Purpose	Description
ProGuard/R8	Code Shrinking	Reduces size and complexity
Firebase/Crashlytics	Error Tracking	Reports errors and crashes
LeakCanary/Instruments	Memory Leak Detection	Detects and prevents memory leaks
Lighthouse/Android Studio	Performance Monitoring	Measures performance impact

Bitcode and Runtime Optimizations (iOS)

Bitcode

Bitcode helps make iOS apps smaller and faster. When you enable Bitcode, Apple can recompile your app's code to use the latest optimizations and improvements. This means your app will be smaller and perform better.

Benefits of Bitcode

Benefit	Description
Smaller App Size	Apple creates separate versions for each device architecture, reducing the overall size.
Improved Performance	Uses the latest compiler optimizations for better performance.

Important Notes

Bitcode is no longer required for watchOS and tvOS apps.
The App Store does not accept Bitcode submissions from Xcode 14.

Runtime Optimizations

Apple has introduced runtime optimizations in recent iOS versions to help reduce app size and improve performance. These include whole-module optimization, which allows the compiler to optimize the entire module.

How to Enable

Use the Latest Xcode: Ensure you're using the latest version of Xcode.
Enable Whole-Module Optimization: Go to your project settings and enable whole-module optimization.
Use swiftc Compiler: Compile your Swift code with the swiftc compiler for better optimization and size reduction.

Modularize and Lazy Load

Breaking your app into smaller parts and loading them only when needed can help reduce app size and improve performance.

Modularization in iOS

In iOS, you can create separate frameworks for each feature of your app. This helps you optimize each part separately.

Steps to modularize your iOS app:

Identify features that can be modularized.
Create a framework for each feature.
Optimize each framework using code shrinking and obfuscation.

Modularization in Android

In Android, you can create separate modules for each feature. This allows you to optimize each part independently.

Steps to modularize your Android app:

Identify features that can be modularized.
Create a module for each feature.
Optimize each module using code shrinking and obfuscation.

Lazy Loading

Lazy loading means loading parts of your app only when they are needed. This reduces the initial app size and improves performance.

Steps to implement lazy loading:

Identify parts of your app that can be lazy loaded.
Create a mechanism to load these parts only when needed.
Optimize the loading mechanism to keep the app size small.

Optimize Updates and Network Transfers

Optimizing app updates and network transfers helps reduce app size and improve user experience. Here are some strategies:

Delta Updates

Delta updates send only the changes made to the app instead of the entire app package. This reduces update sizes, making them faster to download and install. Google’s file-by-file patching reduces update sizes by an average of 65%.

Content Compression

Compressing content reduces the size of network transfers. Use lossless and lossy compression to minimize image sizes without losing quality. Algorithms like Run Length Encoding (RLE) and Quite OK Image format can achieve lossless compression.

Optimize Network Requests

Optimizing network requests reduces the size of network transfers. Techniques like caching, lazy loading, and reducing the number of requests help minimize data transfer. This improves app performance, reduces latency, and enhances user experience.

Strategy	Description
Delta Updates	Send only changes made to the app, reducing update sizes.
Content Compression	Use lossless and lossy compression to minimize image sizes.
Optimize Network Requests	Use caching, lazy loading, and reduce the number of requests.

Continuous Optimization

Continuous optimization is key to keeping your app's size manageable throughout its development. Regularly monitor and analyze your app's size to find areas for improvement. Track changes in app size over time, identify trends, and make data-driven decisions to optimize resources.

Use various tools and processes to achieve continuous optimization. Automated testing and continuous integration (CI) pipelines can detect size increases early, allowing you to address issues promptly. Analytics tools can track user behavior and highlight areas where optimization can enhance the user experience.

Regular code reviews and refactoring help maintain a lean codebase. This involves removing unused code, optimizing algorithms, and improving resource use. By making optimization a continuous process, you can ensure your app remains efficient, fast, and user-friendly.

Tool/Process	Description
Automated Testing	Detect size increases early and take corrective action
CI Pipelines	Integrate size monitoring into your development workflow
Analytics Tools	Track user behavior and identify areas for optimization
Code Reviews	Regularly review code to remove unused code and optimize resources
Refactoring	Improve code efficiency and reduce size

Final Thoughts

By following these 10 tips, you can make your iOS and Android apps smaller, leading to a better user experience, improved app store visibility, and more downloads. Remember, reducing app size is a continuous process that needs regular attention.

Key Takeaways:

Regularly check and optimize your app's resources, code, and media to keep the size down and improve performance.
Use tools like automated testing, CI pipelines, and analytics to spot size increases and find areas to improve.
Stay proactive in reducing app size to stay competitive and meet user expectations.

FAQs

How do I reduce and optimize iOS app size?

To reduce and optimize your iOS app size, create an App Size Report by archiving your app in Xcode, exporting it as an Ad Hoc, Development, or Enterprise build, and choosing "All compatible device variants" for app thinning. Sign your app and export it to your Mac. This will help you identify areas to optimize and reduce your app's size.

How to decrease the app size in Android?

To decrease the app size in Android, upload your app with Android App Bundles, understand the APK structure, reduce resource count and size, remove unused resources, minimize resource use from libraries, reduce native and Java code, and maintain multiple lean APKs.

Can using R8 Proguard help reduce app size?

Proguard

Yes, using R8 Proguard can help reduce app size. Proguard and R8 are code shrinkers that can significantly reduce the size of your APK by removing unused code, renaming classes, and making your code more compact. They are integrated into Android Studio and are easy to use.

How to do app thinning?

To do app thinning, create an App Size Report by archiving your app in Xcode, exporting it as an Ad Hoc, Development, or Enterprise build, and choosing "All compatible device variants" for app thinning. Sign your app and export it to your Mac. This will help you reduce your app's size by removing unnecessary resources and code.

How to reduce IPA file size?

To reduce IPA file size, inspect your app's IPA file and identify areas to optimize. Consider using asset files instead of putting data into your code. For example, use a property list for bundling any data with your app instead of using strings in code. This will help reduce the size of your IPA file and improve your app's performance.