What Is Flutter?
Flutter is an open-source UI toolkit from Google for building natively compiled mobile, web, desktop, and embedded applications from a single Dart codebase. Unlike frameworks that wrap the operating system’s widgets, Flutter renders its own interface directly to a graphics canvas, and that is the central trade-off when comparing Flutter vs React Native.
During development, Flutter runs in the Dart virtual machine with just-in-time (JIT) compilation, which powers sub-second stateful hot reload. For production, it compiles Dart ahead of time (AOT) into native ARM or x64 machine code for mobile and desktop, or into JavaScript and WebAssembly for the web.
Because Flutter draws its own Material Design 3 and Cupertino widgets, interfaces behave the same across OS versions. When a screen needs a platform control, such as a native map or web view, developers embed it with Platform Views.
Flutter is free software under the BSD 3-Clause license. Google uses it for NotebookLM, Google Pay, Google Earth, Google Ads, and YouTube Create, and organizations such as Betterment and the US Department of Veterans Affairs run it in production. Recent releases added stable widget previews, web hot reload, Swift Package Manager support, and official AI packages; see the official Flutter documentation for release notes.
How Flutter Works
Flutter has a three-layer architecture: a reactive Dart framework, a C/C++ engine powered by the Impeller renderer, and platform-specific embedders that connect to the host operating system. The layers are summarized in the table below.
In the framework layer, interfaces are built from immutable Widget configurations. Flutter turns the widget tree into a persistent Element tree that caches structure across frames and a RenderObject tree that handles geometry and painting. Layout is a single linear pass: constraints go down, sizes go up, and the parent sets the position.
Impeller is the rendering engine. Earlier Flutter versions used Skia, which could drop frames while compiling shaders at runtime. Impeller precompiles a smaller set of shaders when the engine is built. As of Flutter 3.47 (August 2026), Impeller is the only engine on iOS and the default on Android API 29+, macOS, Windows, and Linux; Flutter Web still uses Skia.
For native interop, developers use Platform Channels (MethodChannel), the jnigen and ffigen binding generators, or synchronous calls into C, C++, Rust, and Go through dart:ffi. Dart now runs on the platform’s main thread on all native platforms, so CPU-heavy work is moved to Dart Isolates with Isolate.run().
Dart disables runtime reflection in Flutter, which lets the AOT compiler strip unused code from release binaries but means JSON serialization and metadata rely on compile-time code generation.
| Layer | Implementation language | Primary responsibility |
|---|---|---|
| Framework | Dart | Reactive UI composition, animation, painting, gestures, and the Material and Cupertino widget libraries. |
| Engine | C and C++ | Low-level rendering through dart:ui, the Impeller pipeline, text layout, and the Dart runtime. |
| Embedder | Java/C++ (Android), Swift/Objective-C++ (iOS, macOS), C++ (Windows, Linux) | Rendering surfaces, accessibility, input events, and message loops on each operating system. |
Flutter is our recommendation when a product needs a custom, brand-first interface that looks and animates the same on iOS and Android, or when one team must cover mobile, desktop, and web from one codebase. Teams usually stumble by benchmarking debug builds, rebuilding huge widget subtrees on every state change, building long lists upfront instead of using ListView.builder, and parsing large JSON on the main thread instead of in an Isolate. We separate UI and data layers with MVVM and repositories from day one, keep build() methods pure, and scope state listeners to the widgets that change.
Cross-platform UI toolkit
Dart, compiled AOT to native code
iOS, Android, web, Windows, macOS, Linux, embedded
BSD 3-Clause
Years in business
Senior engineers
Projects delivered
What Flutter Is Used For
Software teams use Flutter for brand-consistent mobile apps, multi-platform desktop and web products, Flutter modules inside existing native apps, and AI-driven interfaces.
Brand-Driven Mobile Apps
When a product needs custom animations, vector graphics, or identical behavior across OS versions, one team ships both iOS and Android apps from a single Dart codebase. Google Pay, Betterment, and Reflectly run on Flutter.
Desktop and Web Applications
Flutter compiles to native macOS, Windows, and Linux executables and to JavaScript and WebAssembly web apps. Google uses it for Google Earth, Google Ads, and YouTube Create, and public sector teams use it for unified portals.
Add-to-App Modernization
Companies with existing Kotlin or Swift apps embed Flutter feature modules inside the native shell instead of rewriting everything, using embedders, Platform Views, and generated interop bindings.
AI and Generative Interfaces
With the Flutter AI Toolkit and GenUI SDK, teams build conversational and generative interfaces that compose widgets in real time from LLM responses, as in Google’s NotebookLM.
Flutter vs React Native and .NET MAUI
When comparing Flutter vs React Native, the core divide is rendering: Flutter compiles Dart to native code and paints every pixel itself, while React Native and .NET MAUI map to the operating system’s own controls. Teams already invested in React should also weigh React Native. Fully native iOS and Android remain the reference for the smallest binaries and day-one OS features.
| Criterion | |||
|---|---|---|---|
| Language & runtime | Dart; JIT in development, AOT to native ARM/x64 (or JS/WebAssembly on web) in release. | JavaScript or TypeScript with React; JSI and Turbo Native Modules in the New Architecture. | C# and XAML on the .NET runtime. |
| UI rendering | Draws its own Material 3 and Cupertino widgets with Impeller. | Renders native platform widgets through the Fabric renderer. | Maps cross-platform controls to native controls through handlers. |
| Native interop | Platform Channels, jnigen/ffigen, and synchronous dart:ffi. | Synchronous and asynchronous calls through JSI and Turbo Native Modules. | .NET platform APIs and handler customization. |
| Layout & styling | Composable layout widgets plus a built-in CustomPaint canvas and icons. | Flexbox through StyleSheet.create; icons and canvas from third-party libraries. | XAML markup or C# mapped to native layout containers. |
| Binary footprint | Larger baseline, since the engine and framework ship in the app. | Uses the platform’s own widgets but ships a JavaScript engine. | Bundles the .NET runtime and MAUI libraries. |
| Over-the-air updates | No built-in code push; third-party services such as Shorebird. | JavaScript bundle updates through code push services. | No built-in code push on mobile stores. |
| Target platforms | iOS, Android, web, Windows, macOS, Linux, embedded. | Android and iOS, plus Windows and macOS through Microsoft-maintained projects and web through React Native Web. | Android, iOS, macOS, Windows. |
When to Choose Flutter
Choose Flutter when you want pixel-identical UI across OS versions, heavy custom 2D graphics or animations that benefit from Impeller’s precompiled shaders, or one codebase spanning iOS, Android, web, and desktop. It is also a strong fit when the app relies on native C, C++, or Rust libraries through dart:ffi. Teams already invested in React should weigh React Native’s familiar component model.
When Flutter Is Not the Right Fit
Flutter is not the right fit when your app must adopt brand-new OS visual widgets on the day Apple or Google releases them, because Flutter’s widget libraries need to be updated first. Consider alternatives if a few extra megabytes of binary size are unacceptable, if your team will not adopt Dart in place of TypeScript or C#, or if you need first-party over-the-air code push.
How We Approach Flutter Projects
We structure Flutter apps around strict separation of UI and data layers, compile-time code generation, and release-mode profiling. These are the practices behind our custom mobile development services.
MVVM and Generated Code
Following Flutter’s architecture guide, we split code into a UI layer of Views and ViewModels and a data layer of repositories and services, so rebuilds stay in small subtrees. Data models, JSON serialization, and native bindings are generated at compile time in CI.
Main-Thread Discipline
Dart runs on the platform’s main thread, so long synchronous work stalls both Flutter rendering and native events. Heavy parsing, image processing, and encryption go to Isolates through Isolate.run(), and every dynamic list uses a lazy builder.
Release Benchmarks and Pinned Toolchains
Performance sign-off happens only on physical devices with --profile or --release builds. We pin exact SDK versions on every machine and CI runner, enable --obfuscate with --split-debug-info, and keep secrets on the backend.
Sound like the right partner?
Frequently Asked Questions
Direct answers to common architectural and operational questions when evaluating Flutter.
Does Flutter use native OS widgets?
No. Flutter draws its own widget sets, including Material Design 3 and Cupertino controls, directly to a canvas with its own rendering engine. Apps therefore look and behave the same across OS versions. When a specific native control is required, developers embed it in the Flutter tree with Platform Views (AndroidView and UiKitView).
Why did Flutter choose Dart instead of JavaScript?
Dart supports both JIT compilation in the Dart VM during development and AOT compilation for releases. JIT powers sub-second stateful hot reload, while AOT produces native ARM or x64 machine code, or WebAssembly on the web. Disabling runtime reflection also lets the compiler remove unused code aggressively.
What is the Impeller rendering engine in Flutter?
Impeller is Flutter’s graphics engine, built to remove the frame drops that runtime shader compilation caused with Skia. It is the default on mobile and desktop, as described above, while Flutter Web still uses Skia.
Why is a minimal Flutter app larger than a native build?
A Flutter release binary bundles the Flutter engine and framework with your code and assets, so its baseline is a few megabytes larger. Native iOS and Android apps link against UI frameworks already installed on the device. Always measure size on a --release build, since debug builds include VM and hot-reload overhead.
Does Flutter support over-the-air code push?
Not in the official SDK. Release builds compile Dart ahead of time into native machine code, so updating logic outside store releases needs binary patching. Teams that require over-the-air updates integrate third-party services such as Shorebird.
Can we embed Flutter into an existing native Android or iOS app?
Yes. Flutter modules can be embedded into existing apps with Flutter’s embedders and interop layers, communicating with Kotlin, Java, Swift, or Objective-C through Platform Channels or generated jnigen and ffigen bindings. Because Flutter has no ABI compatibility across compiler releases, the host app’s Flutter modules and all plugins must be built with the same SDK version. Read more about cross-platform mobile development.