How to Reduce Flutter App Size for Better Performance

Flutter app size optimization is a key factor for improving performance, user retention & store acceptance in the competitive arena of mobile development. A big app is harder to install, needs more internet data, and takes up more space on the phone. In this easy-to-follow guide, we’ll show you clear and useful ways to reduce Flutter app size without removing any important features or slowing it down.

Understanding Flutter App Size and Its Components

To effectively reduce size, we must first understand what contributes to the Flutter app binary:

Flutter Engine: The core runtime responsible for rendering and platform communication.

Dart Code: The business logic and UI logic written by the developer.

Assets: Images, fonts, icons, videos, and audio files.

Native Code: Platform-specific Android or iOS dependencies.

Third-Party Packages: Any additional libraries added via pubspec.yaml.

Each of these can be optimized using a methodical, layered approach.

Enable Flutter App Size Analysis

Begin by identifying what exactly is inflating your app. Run the following command:

flutter build apk --analyze-size

Or for iOS:

flutter build ios --analyze-size

Generates a .json file which can be visualized using Flutter DevTools. Pinpoint the largest contributors and use the insight to trim down the build.

Use –split-per-abi for Smaller Android Builds

By default, Flutter builds a fat APK containing binaries for all ABIs. This significantly increases the app size.

To reduce the size, use:

flutter build apk --split-per-abi

Command creates multiple APKs for each ABI (e.g., armeabi-v7a, arm64-v8a, x86_64). Distribute the appropriate APKs to relevant devices via the Play Store, which automatically serves the correct one.

Minimize Dependencies and Unused Packages

Review your pubspec.yaml file regularly. Each package added can introduce code and resources, even if partially used.

• Remove unused packages.

• Replace heavy packages with lighter alternatives.

• Avoid using packages for trivial utilities that can be manually coded.

Use this command to detect unused packages:

flutter pub deps --style=compact

Audit the output and eliminate what’s unnecessary.

Shrink Assets with Compression and Optimization

Assets like images, videos, and audio can balloon your app size. Apply the following:

• Compress PNGs using tools like TinyPNG.

• Convert images to more efficient formats like WebP.

• Use vector graphics (SVGs or Flutter’s CustomPaint) instead of raster images where feasible.

• Downscale images to exact display sizes.

• Use audio codecs like AAC or OPUS instead of WAV.

Flutter also supports asset compression at build time when you enable --release builds, but manual compression yields better results.

Remove Unused Fonts and Icons

Custom fonts and icons are often over-included. Only include:

• Characters needed for your language and symbols.

• Icons used within the app interface.

For fonts, define subsets using font-subset:

flutter build apk --release --tree-shake-icons

The --tree-shake-icons flag removes unused Material icons, reducing app size significantly, especially for apps using the full icon set.

Enable Dart Tree Shaking in Release Mode

Tree shaking eliminates unused Dart code during compilation. It’s automatically enabled in release mode.

Ensure you’re building with:

flutter build apk --release

Avoid debug or profile modes for release distribution. For web builds, run:

flutter build web --release

This approach guarantees that only the critical components of your Dart codebase are included in the final compilation.

Use Deferred Components (Split AOT Compilation)

Deferred components allow loading parts of your app only when needed (supported for Android with Play Feature Delivery).

1. Split non-critical features into separate Dart libraries.

2. Load them at runtime using deferred as imports.

import 'heavy_module.dart' deferred as heavy;

await heavy.loadLibrary();
heavy.runFeature();

It keeps the base app size small while loading additional features on demand.

Use ProGuard and R8 for Android Code Shrinking

Android builds can be reduced further by shrinking Java/Kotlin code:

1. In android/app/build.gradleEnable shrinking:

buildTypes {
    release {
        minifyEnabled true
        shrinkResources true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}

2. Customize proguard-rules.pro to retain essential classes and remove the rest.

It helps reduce native library sizes from dependencies and platform channels.

Optimize Native Libraries and Plugins

Native dependencies often include support for multiple ABIs, architectures, or unnecessary code. Where possible:

• Use plugins that offer pure Dart implementations.

• Strip unused native code or fork and trim plugins.

• Avoid including support for all architectures unless absolutely necessary.

For custom native code, compile only required components for target platforms.

Limit Use of Platform Channels and Codecs

Interfacing with native code via platform channels often brings in large native libraries or codecs.

• Avoid redundant platform channel communication.

• Replace native-heavy packages with Flutter-native solutions.

• Minimize dependency on plugins that wrap native SDKs unless essential.

Use Web-Specific and Mobile-Specific Build Targets

When targeting web, iOS, and Android, consider conditional imports and platform-specific code to avoid shipping unnecessary code.

import 'mobile_widgets.dart' if (dart.library.html) 'web_widgets.dart';

flutter build web --release --source-maps