How to Reduce App Size in Flutter (Easy Steps to Follow)

In the realm of cross-platform application development, Flutter has gained significant popularity among developers across the world. With an ever-increasing number of newbies trying to make a mark in this field, it is relevant to illustrate the common issues faced by Flutter developers.

Following the initial development stage, one of the most common issues one might come across is the significantly large size of the application. The majority of the users avoid downloading large-sized apps given the limited data plans. Therefore, it is essential to decrease the app size to ensure that all your efforts and dedicated time allotted to the development are not wasted.

If you are looking for ways to optimize your Flutter application size, you have come to the right place. This blog is a comprehensive guide to the tried and tested approaches to reducing the app size in Flutter.

Estimate Total App Size in Flutter (Android and iOS)

In 2024, Flutter is widely utilized by developers to create mobile applications for more than one platforms, including Android and iOS. However, before launching the application on the Google Play Store or Apple Store, it is pertinent to do the size analysis of that application.

Steps for Estimating Android App Size

To identify the apk file size, follow these steps:

• After completing the development process, generate the application package with this command: flutter build appbundle.
• Now log into the Google Play Console.
• Upload the generated .aab file.
• To confirm the application’s install and download size, tap on the “app size” tab in the Android vitals option.

Steps for Estimating iOS App Size

Once the iOS application is developed and tested for any bugs, the next step is to check the app size before launching it on the Apple Store. These steps are your guidelines for estimating iOS app size in Flutter:

• Configure the app version
• Run “flutter build ipa –export-method development”
• To access and open the archive in Xcode, run this command: “open build/ios/archive/*.xcarchive”
• Now select the “Distribute App” option
• Choose a suitable distribution method
• Now, choose the Strip Swift symbols
• Sign and export the IPA
• This directory includes the file “App Thinning Size Report.txt,” containing all the details about the projected application size

It’s important to note that the size of IPAs is larger than APKs in most cases.

How to Reduce App Size in Flutter? – Step by Step

Uploading a large-sized app on Google Play Store or App Store is not recommended because many users prefer downloading smaller applications owing to data limitations. The larger the size of the application, the longer the download time and the more storage space it requires on the device. If, despite your best efforts, your app is not attracting the target audience, what’s the reward for all your tireless efforts?

An advantage of using flutter is that you can reduce apk size and ipa size. To ensure that the size of your Flutter project is decreased and optimized, make sure to give preference to the following points:

• Code Refactoring
• Asset and Image Optimization
• Remove Unnecessary Imports
• Remove Unused Code
• Utilize Dynamic Loading

Here are the points that you must consider to decrease the size of the ipas and apks built in flutter:

1) Code Refactoring

To ensure the development of a small-sized application in Flutter, code refactoring is one of the most important elements. Regularly review and improve your code by eliminating redundancy and improving code quality. Consequently, this reduces the size of your app by removing unnecessary lines and making it more efficient.

2) Asset and Image Optimization

Unnecessary assets and large-sized apps have a great influence on the large size of a Flutter application. Therefore, as a Flutter developer, you must ensure to compress and optimize images and assets to reduce their file sizes without compromising quality. Moreover, use image formats like WebP and SVG for better compression and resolution control.

3) Remove Unnecessary Imports

In order to reduce unnecessary overhead and streamline your codebase, eliminate unused or redundant imports, directly contributing to a smaller app size. Unused imports that are still part of the code are a big factor in the noticeably large size of the Flutter application.

4) Remove Unused Code

Removing Unused Code is crucial for optimizing your Flutter app’s size. By consistently reviewing your codebase, you can identify and eliminate functions, variables, or classes that are no longer in use. This declutters your project, reduces its memory footprint, and ultimately trims the app’s size.

Such an approach also enhances code maintainability and improves the overall efficiency of your application, making it a key practice for efficient app development.

5) Utilize Dynamic Loading

Dynamic Loading, achieved through code splitting, is a powerful strategy for optimizing your Flutter app’s size and enhancing the overall performance. By implementing this approach, your app loads resources and components on-demand rather than upfront, reducing the initial download size. This directly leads to quicker startup times and improved user experiences.

It is pertinent to mention that this is a key technique to enhance app efficiency, as it ensures that only necessary code and assets are fetched when required, promoting a faster and more streamlined user experience.

Why My Flutter App Size is Big?

There are a number of factors that contribute to the significantly large size of a Flutter mobile application. The next section will shine a light on a few of the most common ones:

• The default Flutter binary includes support for both ARM and x86 architectures. This allows testing on emulators and devices but adds extra unused native code, contributing to a large-sized application.
• Unused Dart and Flutter framework code can bloat app size. While Flutter’s tree shaking removes unused app code, unused portions of the framework still get included. Using code obfuscation tools like dart_dev can help minimize framework code.
• You must keep in mind that Images, fonts, audio files, and other resources contribute heavily to overall app size. Compressing images, optimizing quality, and delivering resources over the network on-demand reduces resource overhead.
• Flutter’s rendering engine and UI widgets use Skia graphics library at the native level. Additional graphics code and layers add to the binary footprint. Where possible, simplify the widget tree structure and use lightweight widgets.
• Third-party dependencies, especially those with native integration, increase method count and app size. Before releasing the application, audit dependencies only include what’s absolutely necessary.
• Release builds are not fully optimized for size by default. You must release flags like –no-sound-null-safety and –no-pub-upgrade further to reduce app size in Flutter.

Best Practices for Developing a Small-Sized Flutter Application

When building a small Flutter app, such as a simple productivity tool or game, it’s important to follow best practices that will keep your codebase clean, performant, and maintainable. Here are some key recommendations to minimize the android or iOS app size in Flutter:

First, ensure your app structure is modularized into separate widgets, models, and services. Break down your app into reusable components that have clear responsibilities. This makes the code more organized and prevents bulky classes. Use stateless widgets whenever possible, as these are more optimized than stateful widgets.

Second, manage the state properly with provider, bloc, or other state management approaches like Getx, Riverpod, etc. Centralizing state makes it easier to reason about and avoids cascading updates across widgets. For small apps, the provider is often simple and sufficient for state management.

Moreover, you should use asynchronous programming techniques like FutureBuilder and StreamBuilder to keep the UI responsive. These will prevent janky experiences by asynchronously loading data or waiting for operations to complete.

Another suggestion is to incorporate immutable data models for performance and simplicity. That is because immutable models are easier to reason about as they cannot be changed after creation. Use equatable to efficiently compare immutable models.

Additionally, utilize Flutter’s powerful debugging tools like the widget inspector and built-in logging to identify issues quickly. Logging complex UI and business logic flows helps understand behavior.

Other tips include using dependency injection to improve testability, separating business logic from UI code, adding animations carefully to avoid resource overhead, and ensuring accessibility with proper semantics.

Following these patterns will ensure your small Flutter app adopts community best practices around performance, testing, and maintaining a scalable code architecture as the project grows. It is pertinent to keep your app lightweight, leverage built-in Flutter tools, and focus on modular, high-quality code.

Conclusion

The size of a mobile app is a critical factor in increasing the number of downloads and targeting a broader audience. In Flutter, there are several elements that contribute to the large size of the final cross-platform application. This blog illustrated some of the key approaches every Flutter developer must know in order to reduce the application size in Flutter.

At Ropstam Solutions, we have a team of dedicated Flutter developers who are experts in creating optimized mobile applications. We have been providing custom app development services for more than a decade. If you are interested in developing a mobile application to promote your business, contact us now!