FAQ

Flutter is Google’s portable UI toolkit for crafting beautiful,
natively compiled applications for mobile, web, and desktop
from a single codebase. Flutter works with existing code,
is used by developers and organizations around the world,
and is free and open source.

What does Flutter do?

For users, Flutter makes beautiful app UIs come to life.

For developers, Flutter lowers the bar to entry
for building apps. It speeds up development of
apps and reduces the cost and complexity
of app production across platforms.

For designers, Flutter helps deliver the original
design vision, without loss of fidelity or compromises.
It also acts as a productive prototyping tool.

Who is Flutter for?

Flutter is for developers that want a faster
way to build beautiful apps, or
a way to reach more users with a single investment.

Flutter is also for engineering managers that lead
development teams. Flutter allows eng managers
to create a single mobile, web, and desktop app dev team,
unifying their development investments to ship more features faster,
ship the same feature set to multiple platforms at the same
time, and lower maintenance costs.

Flutter is also for designers
that want their original design visions delivered
consistently, with high fidelity, to all users.
In fact, now supports Flutter.

Fundamentally, Flutter is for users that want beautiful apps,
with delightful motion and animation, and UIs with character
and an identity all their own.

How experienced of a programmer/developer do I have to be to use Flutter?

Flutter is approachable to programmers familiar with object-oriented
concepts (classes, methods, variables, etc) and imperative programming
concepts (loops, conditionals, etc).

No prior experience is required in order to learn and use Flutter.

We have seen people with very little programming experience learn
and use Flutter for prototyping and app development.

What kinds of apps can I build with Flutter?

Flutter is optimized for 2D mobile apps that want to run on
both Android and iOS. Flutter is also great for interactive
apps that you want to run on your web pages or on the desktop.
(Note that web support is in beta, and desktop support is in alpha.)

Apps that need to deliver brand-first designs are particularly
well suited for Flutter. However, apps that need to look like
stock platform apps can also be built with Flutter.

You can build full-featured apps with Flutter, including
camera, geolocation, network, storage, 3rd-party SDKs, and more.

Who makes Flutter?

Flutter is an open source project, with contributions from Google
and the community.

Who uses Flutter?

Developers inside and outside of Google use Flutter to build
beautiful natively-compiled apps for iOS and Android.
To learn about some of these apps, visit the .

What makes Flutter unique?

Flutter is different than most other options for building
mobile apps because Flutter uses neither WebView nor the
OEM widgets that shipped with the device. Instead,
Flutter uses its own high-performance rendering engine
to draw widgets.

In addition, Flutter is different because it only has a
thin layer of C/C++ code. Flutter implements most of its
system (compositing, gestures, animation, framework,
widgets, etc) in Dart (a modern, concise,
object-oriented language) that developers can
easily approach read, change, replace, or remove.
This gives developers tremendous control over the
system, as well as significantly lowers the bar
to approachability for the majority of the system.

Should I build my next production app with Flutter?

Flutter 1.0 was launched on Dec 4th, 2018. Thousands of apps
have shipped with Flutter to hundreds of millions of devices.
See some sample apps in the .

For more information on the launch and subsequent releases,
see .

• Heavily optimized, mobile-first 2D rendering engine with
  excellent support for text
• Modern react-style framework
• Rich set of widgets implementing Material Design and iOS-style.
• APIs for unit and integration tests
• Interop and plugin APIs to connect to the system and 3rd-party SDKs
• Headless test runner for running tests on Windows, Linux, and Mac
• 
  for testing, debugging, and profiling your app
• Command-line tools for creating, building, testing,
  and compiling your apps

Does Flutter work with any editors or IDEs?

We support plugins for ,
, and .

See for setup details,
and and
for tips on how to use the plugins.

Alternatively, you can use a combination of the
flutter command in a terminal and one of the
many editors that support .

Does Flutter come with a framework?

Yes! Flutter ships with a modern framework,
inspired by React. Flutter’s framework is designed
to be layered and customizable (and optional).
Developers can choose to use only parts of the
framework, or a different framework.

Yes! Flutter ships with a set of
high quality Material Design and Cupertino
(iOS-style) widgets, layouts, and themes.
Of course, these widgets are only a starting point.
Flutter is designed to make it easy to create
your own widgets, or customize the existing widgets.

Does Flutter support Material Theming?

Yes! The Flutter and Material teams collaborate closely,
and Material Theming is fully supported. A number of
examples of this are shown in the
codelab.

Does Flutter come with a testing framework?

Yes, Flutter provides APIs for writing unit and
integration tests. Learn more about
.

We use our own testing capabilities to test our SDK.
We measure our on every commit.

Does Flutter come with a dependency injection framework or solution?

Not at this time. Share your ideas at
.

What technology is Flutter built with?

Flutter is built with C, C++, Dart, and Skia
(a 2D rendering engine). See this
for a better
picture of the main components.

How does Flutter run my code on Android?

The engine’s C and C++ code are compiled with Android’s NDK.
The Dart code (both the SDK’s and yours) are ahead-of-time
(AOT) compiled into native, ARM, and x86 libraries.
Those libraries are included in a “runner” Android
project, and the whole thing is built into an APK.
When launched, the app loads the Flutter library.
Any rendering, input, or event handling, and so on,
is delegated to the compiled Flutter and app code.
This is similar to the way many game engines work.

Debug mode builds use a virtual machine (VM) to run
Dart code (hence the “debug” banner they show to remind
people that they’re slightly slower) in order to enable
Stateful Hot Reload.

How does Flutter run my code on iOS?

The engine’s C and C++ code are compiled with LLVM.
The Dart code (both the SDK’s and yours) are ahead-of-time
(AOT) compiled into a native, ARM library.
That library is included in a “runner” iOS project,
and the whole thing is built into an .ipa.
When launched, the app loads the Flutter library.
Any rendering, input or event handling, and so on,
are delegated to the compiled Flutter and app code.
This is similar to the way many game engines work.

Debug mode builds use a virtual machine (VM) to run
Dart code (hence the “debug” banner they show to
remind people that they’re slightly slower)
in order to enable Stateful Hot Reload.

No. Instead, Flutter provides a set of widgets
(including Material Design and Cupertino (iOS-styled) widgets),
managed and rendered by Flutter’s framework and engine.
You can browse a .

We hope that the end-result is higher quality apps.
If we reused the OEM widgets, the quality and performance
of Flutter apps would be limited by the quality of those widgets.

In Android, for example, there’s a hard-coded set of gestures and fixed
rules for disambiguating them. In Flutter, you can write your
own gesture recognizer that is a first-class participant in the
. Moreover, two widgets authored by different
people can coordinate to disambiguate gestures.

Modern app design trends point towards designers and users
wanting more motion-rich UIs and brand-first designs.
In order to achieve that level of customized, beautiful design,
Flutter is architectured to drive pixels instead of the OEM widgets.

By using the same renderer, framework, and set of widgets,
it’s easier to publish for both iOS and Android concurrently,
without having to do careful and costly planning to align two
separate codebases and feature sets.

By using a single language, a single framework,
and a single set of libraries for all of your UI
(regardless if your UI is different for each
platform or largely consistent), we also aim to
help lower app development and maintenance costs.

The Flutter team watches the adoption and demand for new mobile
widgets from iOS and Android, and aims to work with the community
to build support for new widgets. This work might come in the form
of lower-level framework features, new composable widgets, or new
widget implementations.

Flutter’s layered architecture is designed to support numerous
widget libraries, and we encourage and support the community in
building and maintaining widget libraries.

Flutter’s interop and plugin system is designed to allow
developers to access new mobile OS features and capabilities
immediately. Developers don’t have to wait for the Flutter team
to expose the new mobile OS capability.

What operating systems can I use to build a Flutter app?

Flutter supports development on Linux, Mac, and, Windows.

What language is Flutter written in?

We looked at a lot of languages and runtimes, and ultimately
adopted Dart for the framework and widgets. The underlying
graphics framework and the Dart virtual machine are
implemented in C/C++.

Why did Flutter choose to use Dart?

Flutter used four primary dimensions for evaluation,
and considered the needs of framework authors, developers,
and end users. We found some languages met some requirements,
but Dart scored highly on all of our evaluation dimensions
and met all our requirements and criteria.

Dart runtimes and compilers support the combination of two
critical features for Flutter: a JIT-based fast development
cycle that allows for shape changing and stateful hot reloads
in a language with types, plus an Ahead-of-Time compiler that
emits efficient ARM code for fast startup and predictable
performance of production deployments.

In addition, we have the opportunity to work closely with the Dart
community, which is actively investing resources in improving Dart
for use in Flutter. For example, when we adopted Dart, the language
didn’t have an ahead-of-time toolchain for producing native binaries,
which is instrumental in achieving predictable, high performance,
but now the language does because the Dart team built it for Flutter.
Similarly, the Dart VM has previously been optimized for throughput
but the team is now optimizing the VM for latency, which is more
important for Flutter’s workload.

Dart scores highly for us on the following primary criteria:

• Developer productivity. One of Flutter’s main value
  propositions is that it saves engineering resources by
  letting developers create apps for both iOS and Android
  with the same codebase. Using a highly productive language
  accelerates developers further and makes Flutter more attractive.
  This was very important to both our framework team as well
  as our developers. The majority of Flutter is built in the
  same language we give to our users, so we need to stay
  productive at 100k’s lines of code, without sacrificing
  approachability or readability of the framework and widgets
  for our developers.

• Object-orientation. For Flutter, we want a language that’s suited to
  Flutter’s problem domain: creating visual user experiences. The industry has
  multiple decades of experience building user interface frameworks in
  object-oriented languages. While we could use a non-object-oriented language,
  this would mean reinventing the wheel to solve several hard problems.
  Plus, the vast majority of developers have experience with object-oriented
  development, making it easier to learn how to develop with Flutter.

• Predictable, high performance. With Flutter, we want to empower developers
  to create fast, fluid user experiences. In order to achieve that, we need to
  be able to run a significant amount of end-developer code during every
  animation frame. That means we need a language that both delivers high
  performance and delivers predictable performance, without periodic
  pauses that would cause dropped frames.

• Fast allocation. The Flutter framework uses a functional-style
  flow that depends heavily on the underlying memory
  allocator efficiently handling small, short-lived allocations.
  This style was developed in languages with this property and
  doesn’t work efficiently in languages that lack this facility.

Can Flutter run any Dart code?

Flutter should be able to run most Dart code that doesn’t import
(transitively, or directly) dart:mirrors or dart:html.

How big is the Flutter engine?

In July 2019, we measured the download size of a
(no Material Components,
just a single Center widget, built with
flutter build apk --split-per-abi),
bundled and compressed as a release APK,
to be approximately 4.3 MB for ARM,
and 4.6 MB for ARM 64.

In ARM, the core engine is approximately 3.2 MB (compressed),
the framework + app code is approximately 920.6 KB (compressed),
the LICENSE file is 54.3 KB (compressed), necessary Java code
(classes.dex) is 113.6 KB (compressed).

In ARM64, the core engine is approximately 3.5 MB (compressed),
the framework + app code is approximately 872 KB (compressed),
the LICENSE file is 54.3 KB (compressed), necessary Java code
(classes.dex) is 113.6 KB (compressed).

These numbers were measured using ,
which is also .

On iOS, a release IPA of the same app has a download size of
10.9 MB on an iPhone X, as reported by Apple’s App Store Connect.
The IPA is larger than the APK mainly because Apple encrypts
binaries within the IPA, making the compression less efficient
(see the
section of Apple’s ).

The release engine binary includes LLVM IR (bitcode).
Xcode uses this bitcode to produce a final binary for the App Store
containing the latest compiler optimizations and features.
The profile and debug frameworks contain only a bitcode marker,
and are more representative of the engine’s actual binary size.
Whether you ship with bitcode or not, the increased size of the release
framework is stripped out during the final steps of the build.
These steps happen after archiving your app and shipping it to the store.

Of course, we recommend that you measure your own app.
To do that, see .

What kind of app performance can I expect?

You can expect excellent performance. Flutter is
designed to help developers easily achieve a constant 60fps.
Flutter apps run via natively compiled code—no
interpreters are involved. This means Flutter apps start quickly.

What kind of developer cycles can I expect? How long between edit and refresh?

Flutter implements a hot reload developer cycle. You can expect
sub-second reload times, on a device or an emulator/simulator.

Flutter’s hot reload is stateful, which means the app state
is retained after a reload. This means you can quickly iterate
on a screen deeply nested in your app, without starting
from the home screen after every reload.

How is hot reload different from hot restart?

Hot reload works by injecting updated source code files
into the running Dart VM (Virtual Machine). This doesn’t
only add new classes, but also adds methods and fields
to existing classes, and changes existing functions.
Hot restart resets the state to the app’s initial state.

For more information, see .

Where can I deploy my Flutter app?

You can compile and deploy your Flutter app to iOS, Android,
(in beta), and (macOS is in alpha,
Linux and Windows are in development). While some folks
are already deploying Flutter web apps,
you might want to wait for web and desktop support to
migrate to the stable channel.

What devices and OS versions does Flutter run on?

• Mobile operating systems: Android Jelly Bean, v16,
  4.1.x or newer, and iOS 8 or newer.

• Mobile hardware: iOS devices (iPhone 4S or newer)
  and ARM Android devices.

• Flutter supports building ahead-of-time (AOT) compiled libraries
  for x86_64, armeabi-v7a, and arm64-v8a.

• Apps built for ARMv7 or ARM64 run fine (using ARM emulation)
  on many x86 Android devices.

• We support developing Flutter apps with Android and iOS devices,
  as well as with Android emulators and the iOS simulator.

• We test on a variety of low-end to high-end phones and tablets,
  but we don’t yet have an official device compatibility guarantee.

Does Flutter run on the web?

Flutter web is currently in .
You can repackage existing Flutter code to
work on the web, but there are some caveats
while web support is still under development.
For more details, check out the .

Can I use Flutter to build desktop apps?

Yes, desktop support is in alpha, with macOS being
the furthest along. We’re working on making this a
first class experience. The current progress is
documented on the page.

Yes, one fullscreen Flutter instance can be integrated per
app on Android and iOS.

See the integration documentation in the
section of our website.

Can I access platform services and APIs like sensors and local storage?

Yes. Flutter gives developers out-of-the-box access to some
platform-specific services and APIs from the operating system.
However, we want to avoid the “lowest common denominator” problem
with most cross-platform APIs, so we don’t intend to build
cross-platform APIs for all native services and APIs.

A number of platform services and APIs have
available on pub.dev.
Using an existing package .

Finally, we encourage developers to use Flutter’s
asynchronous message passing system to create your
own integrations with .
Developers can expose as much or as little of the
platform APIs as they need, and build layers of
abstractions that are a best fit for their project.

Absolutely.
Flutter’s widget system was designed to be easily customizable.

Rather than having each widget provide a large number of parameters,
Flutter embraces composition. Widgets are built out of smaller
widgets that you can reuse and combine in novel ways to make
custom widgets. For example, rather than subclassing a generic
button widget, RaisedButton combines a Material widget with a
GestureDetector widget. The Material widget provides the visual
design and the GestureDetector widget provides the interaction design.

To create a button with a custom visual design, you can combine
widgets that implement your visual design with a GestureDetector,
which provides the interaction design. For example,
CupertinoButton follows this approach and combines a
GestureDetector with several other widgets that implement its
visual design.

Composition gives you maximum control over the visual and
interaction design of your widgets while also allowing a
large amount of code reuse. In the framework, we’ve decomposed
complex widgets to pieces that separately implement
the visual, interaction, and motion design. You can remix
these widgets however you like to make your own custom
widgets that have full range of expression.

You can choose to implement different app layouts for iOS and Android.
Developers are free to check the mobile OS at runtime
and render different layouts, though we find this practice to be rare.

More and more, we see mobile app layouts and designs evolving
to be more brand-driven and unified across platforms. This implies
a strong motivation to share layout and UI code across iOS and
Android.

The brand identity and customization of the app’s aesthetic design is now
becoming more important than strictly adhering to traditional platform
aesthetics. For example, app designs often require custom fonts, colors,
shapes, motion, and more in order to clearly convey their brand identity.

We also see common layout patterns deployed across iOS and Android.
For example, the “bottom nav bar” pattern can now be naturally found
across iOS and Android. There seems to be a convergence of design ideas
across mobile platforms.

Can I interop with my mobile platform’s default programming language?

Yes, Flutter supports calling into the platform, including integrating with
Java or Kotlin code on Android, and ObjectiveC or Swift code on iOS.
This is enabled via a flexible message passing style where a Flutter app
might send and receive messages to the mobile platform using a
.

Learn more about accessing platform and third-party services
in Flutter with .

Here is an that shows how to use a
platform channel to access battery state information on
iOS and Android.

Does Flutter come with a reflection/mirrors system?

Not at this time. Because Flutter apps are pre-compiled for production,
and binary size is always a concern with mobile apps, we disabled
dart:mirrors. We are curious what you might need reflection/mirrors
for—let us know at .

How do I do international­ization (i18n), localization (l10n), and accessibility (a11y) in Flutter?

Learn more about i18n and l10n in the
.

Learn more about a11y in the
.

How do I write parallel and/or concurrent apps for Flutter?

Flutter supports isolates. Isolates are separate heaps in
Flutter’s VM, and they are able to run in parallel
(usually implemented as separate threads). Isolates
communicate by sending and receiving asynchronous messages.

Check out an .

Can I run Dart code in the background of an Flutter app?

Yes, you can run Dart code in a background process on both
iOS and Android For more information, see the Medium article
.

Can I use JSON/XML/protobuffers, etc. with Flutter?

Absolutely. There are libraries on
for JSON, XML, protobufs,
and many other utilities and formats.

For a detailed writeup on using JSON with Flutter,
check out the .

Can I build 3D (OpenGL) apps with Flutter?

Today we don’t support for 3D via OpenGL ES or similar.
We have long-term plans to expose an optimized 3D API,
but right now we’re focused on 2D.

Why is my APK or IPA so big?

Usually, assets including images, sound files, fonts, etc,
are the bulk of an APK or IPA. Various tools in the
Android and iOS ecosystems can help you understand
what’s inside of your APK or IPA.

Also, be sure to create a release build
of your APK or IPA with the Flutter tools.
A release build is usually much smaller
than a debug build.

Learn more about creating a
,
and creating a .
Also, check out .

Do Flutter apps run on Chromebooks?

We have seen Flutter apps run on some Chromebooks.
We are tracking issues related to running Flutter on
Chromebooks.

Putting a Widget build(BuildContext context) method on State
rather putting a Widget build(BuildContext context, State state)
method on StatefulWidget gives developers more flexibility when
subclassing StatefulWidget. You can read a more
.

Where is Flutter’s markup language? Why doesn’t Flutter have a markup syntax?

Flutter UIs are built with an imperative, object-oriented
language (Dart, the same language used to build Flutter’s
framework). Flutter doesn’t ship with a declarative markup.

We found that UIs dynamically built with code allow for
more flexibility. For example, we have found it difficult
for a rigid markup system to express and produce
customized widgets with bespoke behaviors.

We have also found that our “code-first” better allows
for features like hot reload and dynamic environment adaptations.

It’s possible to create a custom language that is then
converted to widgets on the fly. Because build methods are “just code”,
they can do anything, including interpreting markup and turning it
into widgets.

My app has a Debug banner/ribbon in the upper right. Why am I seeing that?

By default flutter run command uses the debug build configuration.

The debug configuration runs your Dart code in a VM (Virtual Machine)
enabling a fast development cycle with
(release builds are compiled using the standard
and toolchains).

The debug configuration also checks all asserts, which helps
you catch errors early during development, but imposes a
runtime cost. The “Debug” banner indicates that these checks
are enabled. You can run your app without these checks by
using either the --profile or --release flag to flutter run.

If you are using the Flutter plugin for IntelliJ,
you can launch the app in profile or release mode using the
menu entries Run > Flutter Run in Profile Mode or
Release Mode.

What programming paradigm does Flutter’s framework use?

Flutter is a multi-paradigm programming environment.
Many programming techniques developed over the past few decades
are used in Flutter. We use each one where we believe the strengths
of the technique make it particularly well-suited.
In no particular order:

Where can I get support?

If you think you’ve encountered a bug, file it in our
. You might also use
for “HOWTO” type questions.
For discussions, join our mailing list at
or seek us out on .

For more information, see our page.

How do I get involved?

Flutter is open source, and we encourage you to contribute.
You can start by simply filing issues for feature requests
and bugs in our .

We recommend that you join our mailing list at
and let us
know how you’re using Flutter and what you’d like to do with it.

If you’re interested in contributing code, you can start
by reading our and check out our
list of .

Finally, you can connect with helpful Flutter communities.
For more information, see our page.

Is Flutter open source?

Yes, Flutter is open source technology.
You can find the project on .

Which software license(s) apply to Flutter and its dependencies?

Flutter includes two components: an engine that ships as a
dynamically linked binary, and the Dart framework as a separate
binary that the engine loads. The engine uses multiple software
components with many dependencies; view the complete list
in its .

The framework is entirely self-contained and requires
.

In addition, any Dart packages you use might have their own license
requirements.

How can I determine the licenses my Flutter application needs to show?

There’s an API to find the list of licenses you need to show:

Who works on Flutter?

Flutter is an open source project. Currently, the bulk of the
development is done by engineers at Google. If you’re excited
about Flutter, we encourage you to join the community and
contribute to Flutter!

What are Flutter’s guiding principles?

We believe the following:

• In order to reach every potential user,
  developers need to target multiple mobile platforms.
• HTML and WebViews as they exist today make it challenging to
  consistently hit high frame rates and deliver high-fidelity experiences,
  due to automatic behavior (scrolling, layout) and legacy support.
• Today, it’s too costly to build the same app multiple times: it
  requires different teams, different code bases, different workflows,
  different tools, etc.
• Developers want an easier, better way to use a single codebase to
  build mobile apps for multiple target platforms, and they don’t want
  to sacrifice quality, control, or performance.

We are focused on three things:

Will Apple reject my Flutter app?

We can’t speak for Apple, but Apple’s policies have changed over the
years, and their App Store contains many apps built with technologies
like Unity and Flutter.
Apple has even featured Flutter apps such as
.

Of course, Apple is ultimately in charge of their ecosystem,
but our goal is to continue doing everything we can to ensure
that Flutter apps can be deployed to Apple’s App Store.