FAQ

This page collects common questions about Flutter. You can also check out the following specialized FAQs:

• Web FAQ
• Performance FAQ

Flutter is Google's open source framework for crafting beautiful, natively compiled applications for mobile (iOS, Android), web, desktop (macOS, Windows, Linux), and embedded devices from a single codebase. Flutter works with existing code, is used by developers and organizations worldwide, and is free and open source.

For developers, Flutter accelerates app development and reduces the cost and complexity of building across platforms.

For designers, Flutter provides a flexible canvas for high-end user experiences. It turns concepts into production code without the compromises imposed by traditional cross-platform frameworks.

For engineering managers and businesses, Flutter enables the unification of app developers into a single team, building branded apps for multiple platforms from a single codebase. Flutter speeds feature development and synchronizes release schedules across your customer base.

Flutter is approachable to programmers familiar with object-oriented and imperative or declarative programming concepts. Experience with languages such as Java, Kotlin, Swift, TypeScript, or C# helps you learn Dart and Flutter quickly.

Flutter supports building mobile apps on Android and iOS, web applications, desktop apps on macOS, Windows, and Linux, and embedded device interfaces.

Apps that require custom, branded designs are well suited for Flutter. You can also create pixel-perfect experiences that match Android's Material Design and iOS's Cupertino design languages.

Flutter's package ecosystem on pub.dev supports a wide variety of hardware (such as camera, GPS, Bluetooth, network, and local storage) and cloud services (such as authentication, notifications, payments, and storage).

Flutter is an open source project managed by Google, with contributions from a global community of developers, companies, and individuals.

Developers and organizations worldwide use Flutter to build natively compiled applications. To explore apps built with Flutter, visit the showcase.

Flutter differs from most cross-platform alternatives because it doesn't rely on web browser views or system-provided platform widgets. Instead, Flutter renders its UI using its own high-performance rendering engine (Impeller).

In addition, Flutter implements most of its framework (including compositing, gestures, animation, and widgets) in Dart. This architecture gives you deep control over the UI, high predictability, and the ability to inspect or modify the framework at any level.

Yes. Thousands of organizations, from early-stage startups to large enterprises, deploy production Flutter apps to hundreds of millions of users. Explore real-world examples in the showcase.

Flutter releases updates on a regular cadence, bringing performance improvements, new features, and platform updates to the stable channel.

The Flutter SDK includes:

• High-performance 2D rendering engine (Impeller)
• Modern, reactive framework written in Dart
• Rich set of widgets implementing Material Design 3 and Cupertino (iOS-style)
• APIs for unit, widget, and integration tests
• Interop and plugin APIs to connect to system features and native SDKs
• Headless test runner for running tests on Windows, Linux, and macOS
• Flutter DevTools for profiling, debugging, and inspecting your app
• Command-line tools for creating, building, testing, and compiling apps

Flutter provides plugins and extensions for VS Code, Antigravity (an AI-assisted IDE), Android Studio, and IntelliJ IDEA. See editor configuration for setup details, and VS Code and Android Studio/IntelliJ for usage guidance.

You can also run the flutter command from a terminal along with any editor that supports editing Dart.

Yes. Flutter includes a modern, reactive framework. The framework is layered and customizable, allowing you to use high-level widgets or interact directly with lower layers of the rendering pipeline.

Yes. Flutter ships with a collection of high-quality Material Design and Cupertino (iOS-style) widgets, layouts, and themes. You can use these widgets as provided, customize them, or create custom widgets.

Yes. Flutter provides full support for Material Design 3, Google's design system.

Yes. Flutter provides built-in support for unit, widget, and integration testing. To learn more, see Testing overview.

Yes. Flutter includes Flutter DevTools. For more information, see Debugging Flutter apps and the Flutter DevTools documentation.

Flutter doesn't require an opinionated dependency injection framework. The Flutter ecosystem offers several packages for dependency injection and service location, such as Riverpod, get_it, Provider, and injectable.

Flutter is built with C, C++, and Dart. It uses Impeller as its default rendering engine, taking advantage of modern graphics APIs such as Metal on iOS and macOS, and Vulkan on Android. For a detailed description of Flutter's layered architecture, read the architectural overview.

The engine's C and C++ code is compiled using Android's NDK. The Dart code (both the framework and your application code) is ahead-of-time (AOT) compiled into native machine code. These libraries are packaged into a runner Android project and built into an APK or Android App Bundle (AAB). When launched, the app loads the Flutter engine, which executes the compiled code and renders the UI.

During debug mode, Flutter runs inside the Dart VM to enable stateful hot reload, allowing you to make changes to your running code without recompiling. A "debug" banner in the top right corner indicates that the app is running in debug mode.

The engine's C and C++ code is compiled with LLVM. The Dart code (both the framework and your application code) is ahead-of-time (AOT) compiled into native ARM machine code. The compiled code is packaged into a runner iOS project and built into an .ipa bundle. When launched, the app loads the Flutter engine, which executes the compiled code and renders the UI using Impeller.

During debug mode, Flutter runs inside the Dart VM to enable stateful hot reload. A "debug" banner in the top right corner indicates that the app is running in debug mode.

No. Instead, Flutter renders widgets directly using its own engine, providing implementations of Material Design and Cupertino (iOS-style) widgets. You can explore the available widgets in the widget catalog.

By rendering pixels directly, Flutter avoids the performance constraints and behavioral differences of platform widget abstractions. This approach delivers consistent performance and appearance across platforms.

For cases where you need a platform-native component (such as Google Maps or a web view), Flutter supports embedding platform views directly into the widget tree.

The Flutter team and community track new design guidelines and platform widgets from Apple and Google, updating Flutter's widget libraries accordingly. Because Flutter widgets are written in Dart, you can also build or adapt widgets immediately without waiting for an OS or SDK update.

Flutter's plugin architecture, platform channels, and native interop tools (such as Dart FFI, ffigen, and jnigen) allow you to access new OS APIs immediately. You don't need to wait for a Flutter SDK release to integrate new platform capabilities.

Flutter doesn't provide built-in code push functionality. Third-party solutions, such as Shorebird, provide code push support for Flutter applications.

Flutter supports development on macOS, Windows, Linux, and ChromeOS. For details on system requirements, see the install guide.

The Flutter framework is written in Dart. The underlying engine and graphics pipeline are implemented in C and C++.

During initial development, the Flutter team evaluated multiple languages and runtimes before selecting Dart for the framework and widgets. Dart scored highest across several key evaluation criteria:

Developer productivity

Dart supports both JIT (Just-in-Time) compilation for fast development with stateful hot reload, and AOT (Ahead-of-Time) compilation for efficient native machine code in production. Because the framework is written in Dart, developers can inspect, debug, and modify the entire stack.

Object orientation and UI composition

Dart's object-oriented structure matches the requirements of building composable user interfaces without requiring a separate markup language.

Predictable, high performance

Dart compiles directly to native machine code without an interpreter or bridge, delivering consistent frame rates without unpredictable runtime pauses.

Fast memory allocation

Flutter's reactive framework creates many short-lived objects. Dart's generational garbage collector is optimized for fast allocation and cleanup of ephemeral objects.

Flutter can run any Dart code that doesn't depend on libraries unavailable on the target platform. For example, mobile and desktop apps can't import web-specific libraries, and web apps can't use dart:io.

Flutter compiles Dart for the web to both JavaScript and WebAssembly (Wasm). WebAssembly compilation (WasmGC) delivers high-performance rendering comparable to native desktop and mobile apps. For details, see the Flutter web documentation.

A minimal release Flutter application includes the Flutter engine, the framework, and your application code. The engine adds a small baseline footprint (a few megabytes compressed), which varies by target platform and architecture.

App size is largely determined by bundled assets, fonts, and third-party packages. To analyze and minimize the size of your application, see Measuring your app's size.

Flutter uses logical pixels, which correspond roughly to physical pixels on a standard-density display. Flutter automatically maps logical pixels to physical device pixels based on the view's devicePixelRatio.

Flutter is designed to deliver smooth 60fps and 120fps animations. Flutter apps compile directly to native machine code or WebAssembly, eliminating interpreter overhead. To learn more about performance optimization, see the Performance FAQ.

Flutter implements a stateful hot reload developer cycle. You can expect sub-second reload times on physical devices, emulators, and simulators.

Hot reload preserves your application state, allowing you to iterate rapidly without navigating back to the current screen after every code change.

Hot reload injects updated source code files into the running Dart VM without clearing the application state. Hot restart resets the application state and re-executes main(), which takes slightly longer than hot reload but remains faster than a full recompile.

For more information, see Hot reload.

You can compile and deploy Flutter apps to iOS, Android, web, desktop (macOS, Windows, Linux), and embedded devices.

Flutter supports a broad range of operating systems and hardware platforms:

• Mobile: Android (ARM32, ARM64, x86_64) and iOS (ARM64).
• Desktop: macOS (x86_64, ARM64), Windows (x86_64, ARM64), and Linux (x86_64, ARM64).
• Web: Modern browsers supporting WebAssembly or JavaScript.

For the complete list of supported OS versions, see Supported platforms.

Yes. Flutter web support is available on the stable channel and supports compilation to both WebAssembly (Wasm) and JavaScript. For more details, see Web support for Flutter.

Yes. Desktop support is available on the stable channel for macOS, Windows, and Linux. For details, see Desktop support for Flutter.

Yes. You can integrate Flutter into existing Android and iOS applications using Add-to-App.

Yes. Flutter provides access to platform-specific APIs and hardware through plugins available on pub.dev. You can also create custom integrations using platform channels or native interop (Dart FFI).

Yes. Flutter's widget system is built around composition. Instead of subclassing complex widgets, you compose smaller, single-purpose widgets to create custom designs. This architecture provides control over layout, painting, and gesture handling.

Sharing layout and UI code reduces engineering effort, keeps feature releases synchronized, and ensures a consistent brand experience across platforms. When you want platform-specific behavior or styling, you can adapt the UI using platform checks or responsive layouts.

Yes. Flutter supports calling native code on all supported platforms:

• On Android: Kotlin and Java via platform channels and JNI interop (jnigen).
• On iOS and macOS: Swift and Objective-C via platform channels and Objective-C/Swift interop (ffigen).
• On desktop and mobile: C and C++ via Dart FFI (dart:ffi).

No. Dart disables dart:mirrors in Flutter to enable aggressive ahead-of-time (AOT) compilation and dead-code elimination (tree shaking). This keeps binary sizes small and startup times fast. For metadata inspection and serialization, Flutter applications use compile-time code generation.

Yes. Flutter provides built-in internationalization (i18n) and localization (l10n) support, including pluralization, bidirectional text, and date formatting. To learn more, see Internationalizing Flutter apps.

Flutter supports standard accessibility features (a11y), including screen readers (TalkBack, VoiceOver), large text scaling, high-contrast themes, and hardware switch access. For details, see Accessibility.

Dart uses an event loop for asynchronous operations (Future and Stream). For CPU-intensive tasks, Flutter supports isolates—isolated execution threads with independent memory heaps that communicate through message passing. You can use Isolate.run() or the compute() function to run heavy computations in the background.

Yes. You can execute Dart code in background processes on Android and iOS using background execution packages and platform service integrations.

Yes. The Dart ecosystem provides packages on pub.dev for JSON serialization, XML parsing, Protocol Buffers, and other data formats. For details on working with JSON, see JSON and serialization.

Yes. Flutter supports 3D graphics through Flutter GPU and packages such as flutter_scene, which use the Impeller rendering backend to draw 3D scenes. You can also embed third-party 3D views (such as Unity or native 3D engines) using platform views.

App bundle size includes the Flutter engine, framework code, application logic, and bundled assets (such as images, fonts, and audio). Always create a release build (flutter build apk or flutter build appbundle for Android, and flutter build ipa for iOS), which removes debug symbols and enables compiler optimizations. To analyze and reduce app size, see Measuring your app's size.

Flutter and Dart don't provide application binary interface (ABI) compatibility across different compiler releases. Always compile your application using matching SDK versions.

Flutter provides platform-specific scroll physics that match the native scrolling behavior of each platform (such as momentum scrolling on iOS and overscroll stretch on Android). For more details, see the scrolling documentation.

Placing the Widget build(BuildContext context) method on State rather than StatefulWidget provides greater flexibility when subclassing StatefulWidget and managing lifecycle state. For a detailed explanation, see the API documentation for State.build.

Flutter UIs are defined in Dart code rather than a declarative markup language. Defining UI in code enables:

• Fast development with stateful hot reload.
• Full access to programming language features (loops, conditionals, functions).
• Strong type safety and compiler checks.
• Easy refactoring and code reuse across widgets.

Because build methods are standard code, you can also create widgets dynamically from data or external configurations.

By default, flutter run launches the app in debug mode. The debug build configuration runs code inside the Dart VM to enable stateful hot reload, and enables runtime assertions to catch errors early. The "Debug" banner indicates that these checks are active.

To run without assertions and with optimized performance, run the app in release mode using flutter run --release or build a release binary.

Flutter uses a combination of programming paradigms, applying each where it is most effective:

Composition

The primary paradigm in Flutter is composing small, single-purpose widgets into complex user interfaces. For example, the Material TextButton widget is composed of an IconTheme, an InkWell, a Padding, a Center, a Material, an AnimatedDefaultTextStyle, and a ConstrainedBox.

Functional programming

Applications can define UI using StatelessWidget instances, which act as functions mapping configuration inputs to child widgets. Flutter uses immutable data structures across its widget hierarchy, including Widget, TextStyle, and Rect.

Event-driven programming

User interactions are represented by event objects dispatched to callbacks registered on widgets. Classes like Listenable formalize event subscription models.

Class-based object-oriented programming

The framework APIs use inheritance to specialize behavior. For example, RenderBox extends RenderObject to establish a Cartesian coordinate system for 2D layout.

Prototype-based object-oriented programming

The ScrollPhysics class chains instances to compose scrolling physics dynamically at runtime.

Imperative programming

Imperative code manages encapsulated state and test execution, where step-by-step logic is clearest.

Reactive programming

Constructor parameters propagate changes down the widget tree, and user interactions trigger updates back up the tree through callbacks. State changes schedule rebuilds of affected subtrees.

Declarative programming

Widget build methods describe the desired UI state declaratively, leaving layout and rendering updates to the framework.

Generic programming

Generic types enforce type safety across the framework, such as parameterizing State<T> with its widget type and GlobalKey<T> with its state type.

Concurrent programming

Flutter uses Future and Stream for asynchronous operations, and isolates for parallel background computation.

Constraint programming

The layout system uses box constraints (minimum and maximum width and height) passed down from parent to child to compute geometry in a single pass.

To report bugs or request features, file an issue in the Flutter issue tracker.

For community discussion, troubleshooting, and advice:

• Join the Flutter Discord.
• Ask questions on Stack Overflow using the flutter tag.
• Participate in discussions on Reddit r/FlutterDev.
• Visit the Community page for additional resources.

Flutter is open source, and contributions are welcome. You can help by:

• Reporting bugs and feature requests on the issue tracker.
• Contributing code and documentation by following the Contributing guide.
• Triaging issues or helping other developers on Discord and Stack Overflow.

Yes. Flutter is open source and available under the BSD 3-Clause License on GitHub.

Flutter includes two main components: the engine (compiled binary with dependencies) and the framework (Dart source code).

• The framework is licensed under the BSD 3-Clause License.
• The engine uses open source dependencies listed in its license file.
• Dart packages on pub.dev specify their own individual licenses.

Flutter provides built-in APIs to display open source licenses:

• If your application uses a Drawer, add an AboutListTile.
• If your application uses Material Design, call showAboutDialog or showLicensePage.
• For custom presentations, access the raw licenses from the LicenseRegistry.

Flutter is developed by engineers at Google along with hundreds of open source contributors worldwide. To join the community, see contribute to Flutter.

Flutter is built around three core principles:

Control

Developers have full access to and control over every layer of the system.

Performance

Applications deliver smooth, responsive, jank-free experiences.

Fidelity

Applications achieve pixel-perfect, beautiful user experiences on every platform.

No. Thousands of Flutter apps are published, approved, and featured in the Apple App Store and Google Play Store. As with any application, ensure your app complies with Apple's App Store Review Guidelines and Google Play's Developer Program Policies.