id
stringlengths 14
17
| text
stringlengths 23
1.11k
| source
stringlengths 35
114
|
|---|---|---|
970f8af440f4-45 | The web version of the architectural layer diagram is as follows:
Perhaps the most notable difference compared to other platforms on which Flutter
runs is that there is no need for Flutter to provide a Dart runtime. Instead,
the Flutter framework (along with any code you write) is compiled to JavaScript.
It’s also worthy to note that Dart has very few language semantic differences
across all its modes (JIT versus AOT, native versus web compilation), and most
developers will never write a line of code that runs into such a difference. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-46 | During development time, Flutter web uses
dartdevc, a compiler that supports
incremental compilation and therefore allows hot restart (although not currently
hot reload) for apps. Conversely, when you are ready to create a production app
for the web, dart2js, Dart’s
highly-optimized production JavaScript compiler is used, packaging the Flutter
core and framework along with your application into a minified source file that
can be deployed to any web server. Code can be offered in a single file or split
into multiple files through deferred imports.
Further information
For those interested in more information about the internals of Flutter, the
Inside Flutter whitepaper
provides a useful guide to the framework’s design philosophy.
Footnotes:
1 While the build function returns a fresh tree,
you only need to return something different if there’s some new
configuration to incorporate. If the configuration is in fact the same, you can
just return the same widget. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-47 | 2 This is a slight simplification for ease of
reading. In practice, the tree might be more complex.
3 While work is underway on Linux and Windows,
examples for those platforms can be found in the Flutter desktop embedding
repository.
As development on those platforms reaches maturity, this content will be
gradually migrated into the main Flutter repository.
4 There are some limitations with this approach, for
example, transparency doesn’t composite the same way for a platform view as it
would for other Flutter widgets.
5 One example is shadows, which have to be
approximated with DOM-equivalent primitives at the cost of some fidelity. | https://docs.flutter.dev/resources/architectural-overview/index.html |
3181f4a68813-0 | Books about Flutter
Here’s a collection of books about Flutter, in alphabetical order.
If you find another one that we should add,
file an issue and (optionally)
submit a PR (sample) to add it yourself.
Beginning App Development with Flutter
Beginning Flutter: A Hands On Guide to App Development
Flutter Apprentice
Flutter Complete Reference
Flutter: Développez vos applications mobiles multiplateformes avec Dart
Flutter for Beginners
Flutter in Action
Flutter Libraries We Love
Flutter Succinctly
Google Flutter Mobile Development Quick Start Guide
Learn Google Flutter Fast
Managing State in Flutter Pragmatically
Practical Flutter
Pragmatic Flutter
Programming Flutter | https://docs.flutter.dev/resources/books/index.html |
3181f4a68813-1 | Pragmatic Flutter
Programming Flutter
The following sections have more information about each book.
Beginning App Development with Flutter
by Rap Payne
Easy to understand starter book. Currently the best-selling and highest rated Flutter book on Amazon.
Beginning Flutter: A Hands On Guide to App Development
by Marco L. Napoli
Build your first app in Flutter - no experience necessary.
Flutter Apprentice
by Michael Katz, Kevin David Moore, Vincent Ngo, and Vincenzo Guzzi
Build for both iOS and Android With Flutter! With Flutter and Flutter Apprentice, you can achieve the dream of building fast applications, faster.
Flutter Complete Reference
by Alberto Miola | https://docs.flutter.dev/resources/books/index.html |
3181f4a68813-2 | Flutter Complete Reference
by Alberto Miola
Create beautiful, fast and native apps for any device. You’ll learn about the Dart programming language (version 2.10, with null safety support) and the Flutter framework (version 1.20).While reading the chapters, you’ll find a lot of good practices, tips and performance advices to build high quality products.
Flutter: Développez vos applications mobiles multiplateformes avec Dart
by Julien Trillard
Ce livre sur Flutter s’adresse aux développeurs, initiés comme plus aguerris, qui souhaitent disposer des connaissances nécessaires pour créer de A à Z des applications mobiles multiplateformes avec le framework de Google
Flutter for Beginners
by Thomas Bailey and Alessandro Biessek
An introductory guide to building cross-platform mobile applications with Flutter 2.5 and Dart. | https://docs.flutter.dev/resources/books/index.html |
3181f4a68813-3 | Flutter in Action
by Eric Windmill
Flutter in Action teaches you to build professional-quality mobile applications using the Flutter SDK and the Dart programming language.
Flutter Libraries We Love
by Codemagic
“Flutter libraries We Love” focuses on 11 different categories of Flutter libraries. Each category lists available libraries as well as a highlighted library that is covered in more detail – including pros and cons, developer’s perspective, and real-life code examples. The code snippets of all 11 highlighted libraries support Flutter 2 with sound null safety.
Flutter Succinctly
by Ed Freitas
App UI in Flutter-from Zero to Hero.
Google Flutter Mobile Development Quick Start Guide
by Prajyot Mainkar and Salvatore Girodano
A fast-paced guide to get you started with cross-platform mobile application development with Google Flutter | https://docs.flutter.dev/resources/books/index.html |
3181f4a68813-4 | Learn Google Flutter Fast
by Mark Clow
Learn Google Flutter by example. Over 65 example mini-apps.
Managing State in Flutter Pragmatically
by Waleed Arshad
Explore popular state management techniques in Flutter.
Practical Flutter
by Frank Zammetti
Improve your Mobile Development with Google’s latest open source SDK.
Pragmatic Flutter
by Priyanka Tyagi
Building Cross-Platform Mobile Apps for Android, iOS, Web & Desktop
Programming Flutter
by Carmine Zaccagnino
Native, Cross-Platform Apps the Easy Way. Doesn’t require previous Dart knowledge. | https://docs.flutter.dev/resources/books/index.html |
42d13baacc46-0 | Bootstrap into Dart
New to the Dart language?
We compiled our favorite resources to
help you quickly learn Dart.
Many people have reported that
Dart is easy and fun to learn.
We hope these resources make Dart easy for
you to learn, too.
Language tour
Your best introduction to the Dart language.
Learn about Dart’s features such as strong types,
closures, libraries, lexical scoping,
top-level functions, named parameters,
async / await, and lots more.
Library tour
A good overview of Dart’s powerful core libraries.
Learn about Dart’s support for collections, async,
math, numbers, strings, JSON, and more.
Learning Dart as a JavaScript developer
Use your JavaScript knowledge to get up and running quickly with Dart.
Learn about the key similarities and differences between the languages
as well as concepts and conventions not present in vanilla JavaScript. | https://docs.flutter.dev/resources/bootstrap-into-dart/index.html |
42d13baacc46-1 | Intro to Dart for Java Developers codelab
Use your Java knowledge to get up and running quickly with Dart.
Learn about classes, constructors, parameters,
and interfaces with examples from the Java Tutorial.
Effective Dart
Guides for style, authoring documentation, usage,
and more.
Asynchronous programming: futures, async, await codelab
Learn how to write asynchronous code using
futures and the async and await keywords.
Asynchronous programming: streams
Learn how to use streams to perform asynchronous
I/O and event handling.
Want to learn more and perhaps contribute?
Check out the Dart community. | https://docs.flutter.dev/resources/bootstrap-into-dart/index.html |
a880cf9d78df-0 | Creating useful bug reports
Create an issue on GitHub
Provide a minimal reproducible code sample
Provide some Flutter diagnostics
Run the command in verbose mode
Provide the most recent logs
Provide the crash report
The instructions in this document detail the current steps
required to provide the most actionable bug reports for
crashes and other bad behavior. Each step is optional but
will greatly improve how quickly issues are diagnosed and addressed.
We appreciate your effort in sending us as much feedback as possible.
Create an issue on GitHub
To report a Flutter crash or bug,
create an issue in the flutter/flutter project.
To report a problem with the website,
create an issue in the flutter/website project.
Provide a minimal reproducible code sample
Create a minimal Flutter app that shows the problem you are facing,
and paste it into the GitHub issue. | https://docs.flutter.dev/resources/bug-reports/index.html |
a880cf9d78df-1 | To create it you can use flutter create bug command and update
the main.dart file.
Alternatively, you can use DartPad, which is capable
of creating and running small Flutter apps.
If your problem goes out of what can be placed in a single file, for example
you have a problem with native channels, you can upload the full code of
the reproduction into a separate repository and link it.
Provide some Flutter diagnostics
Run flutter doctor -v in your project directory and paste
the results into the GitHub issue:
Run the command in verbose mode
Follow these steps only if your issue is related to the
flutter tool.
All Flutter commands accept the --verbose flag.
If attached to the issue, the output from this command
might aid in diagnosing the problem.
Attach the results of the command to the GitHub issue.
Provide the most recent logs
Logs for the currently connected device are accessed
using flutter logs. | https://docs.flutter.dev/resources/bug-reports/index.html |
a880cf9d78df-2 | Logs for the currently connected device are accessed
using flutter logs.
If the crash is reproducible, clear the logs
(⌘ + k on Mac), reproduce the crash and copy the
newly generated logs into a file attached to the bug report.
If you are getting exceptions thrown by the framework,
include all the output between and including the dashed
lines of the first such exception.
Provide the crash report
When the iOS simulator crashes,
a crash report is generated in ~/Library/Logs/DiagnosticReports/.
When an iOS device crashes,
a crash report is generated in ~/Library/Logs/CrashReporter/MobileDevice.
Find the report corresponding to the crash (usually the latest)
and attach it to the GitHub issue. | https://docs.flutter.dev/resources/bug-reports/index.html |
80f0a5ff0c6b-0 | Flutter compatibility policy
Announcements and migration guides
Deprecation policy
Dart and other libraries used by Flutter
The Flutter team tries to balance the need for API stability with the
need to keep evolving APIs to fix bugs, improve API ergonomics,
and provide new features in a coherent manner.
To this end, we have created a test registry where you can provide
unit tests for your own applications or libraries that we run
on every change to help us track changes that would break
existing applications. Our commitment is that we won’t make any
changes that break these tests without working with the developers of
those tests to (a) determine if the change is sufficiently valuable,
and (b) provide fixes for the code so that the tests continue to pass.
If you would like to provide tests as part of this program, please
submit a PR to the flutter/tests repository. The README.md file on
that repository describes the process in detail. | https://docs.flutter.dev/resources/compatibility/index.html |
80f0a5ff0c6b-1 | Announcements and migration guides
If we do make a breaking change (defined as a change that caused one
or more of these submitted tests to require changes), we will announce
the change on our flutter-announce
mailing list as well as in our release notes.
We provide a list of guides for migrating code affected by
breaking changes.
Deprecation policy
We will, on occasion, deprecate certain APIs rather than outright
break them overnight. This is independent of our compatibility policy
which is exclusively based on whether submitted tests fail, as
described above.
Deprecated APIs are removed after a migration grace period. This grace
period is one calendar year after being released on the stable channel,
or after 4 stable releases, whichever is longer.
When a deprecation does reach end of life, we follow the same procedures
listed above for making breaking changes in removing the deprecated API.
Dart and other libraries used by Flutter | https://docs.flutter.dev/resources/compatibility/index.html |
80f0a5ff0c6b-2 | Dart and other libraries used by Flutter
The Dart language itself has a separate breaking-change policy,
with announcements on Dart announce.
In general, the Flutter team does not currently have any commitment
regarding breaking changes for other dependencies. For example,
it’s possible that a new version of Flutter using a new version of Skia
(the graphics engine used by Flutter) or Harfbuzz (the font shaping
engine used by Flutter) would have changes that affect contributed
tests. Such changes would not necessarily be accompanied by a
migration guide. | https://docs.flutter.dev/resources/compatibility/index.html |
23476a2afaf2-0 | Flutter concurrency for Swift developers
Asynchronous Programming
Leveraging the main thread/isolate
Leveraging a background thread/isolate
Both Dart and Swift support concurrent programming.
This guide should help you understand how
concurrency works in Dart and how it compares to Swift.
With this understanding, you can create
high-performing iOS apps.
When developing in the Apple ecosystem,
some tasks might take a long time to complete.
These tasks include fetching or processing large amounts of data.
iOS developers typically use Grand Central Dispatch (GCD)
to schedule tasks using a shared thread pool.
With GCD, developers add tasks to dispatch queues
and GCD decides on which thread to execute them. | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-1 | But, GCD spins up threads to
handle remaining work items.
This means you can end up with a large number of threads
and the system can become over committed.
With Swift, the structured concurrency model reduced the number
of threads and context switches.
Now, each core has only one thread.
Dart has a single-threaded execution model,
with support for Isolates, an event loop, and asynchronous code.
An Isolate is Dart’s implementation of a lightweight thread.
Unless you spawn an Isolate, your Dart code runs in the
main UI thread driven by an event loop.
Flutter’s event loop is
equivalent to the iOS main loop—in other words,
the Looper attached to the main thread.
Dart’s single-threaded model doesn’t mean
you are required to run everything
as a blocking operation that causes the UI to freeze.
Instead, use the asynchronous
features that the Dart language provides,
such as async/await. | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-2 | Asynchronous Programming
Concurrency in Dart.
Leveraging the main thread/isolate
For Apple operating systems, the primary (also called the main)
thread is where the application begins running.
Rendering the user interface always happens on the main thread.
One difference between Swift and Dart is that
Swift might use different threads for different tasks,
and Swift doesn’t guarantee which thread is used.
So, when dispatching UI updates in Swift,
you might need to ensure that the work occurs on the main thread.
Say you want to write a function that fetches the
weather asynchronously and
displays the results.
In GCD, to manually dispatch a process to the main thread,
you might do something like the following.
First, define the Weather enum:
// 1 second delay is used in mocked API call.
extension
UInt64
static | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-3 | extension
UInt64
static
let
oneSecond
UInt64
1_000_000_000
enum
Weather
String
case
rainy
sunny
Next, define the view model and mark it as an ObservableObject
so that it can return a value of type Weather?.
Use GCD create to a DispatchQueue to
send the work to the pool of threads
class
ContentViewModel
ObservableObject
@Published
private(set)
var
result
Weather
private
let
queue
DispatchQueue
label | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-4 | queue
DispatchQueue
label
"weather_io_queue"
func
load
()
// Mimic 1 sec delay.
queue
asyncAfter
deadline
now
()
weak
self
in
DispatchQueue
main
async
self
result
sunny
Finally, display the results:
struct
ContentView
View
@StateObject
var
viewModel
ContentViewModel
()
var
body
some
View
Text | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-5 | body
some
View
Text
viewModel
result
rawValue
??
"Loading"
onAppear
viewModel
load
()
More recently, Swift introduced actors to support
synchronization for shared, mutable state.
To ensure that work is performed on the main thread,
define a view model class that is marked as a @MainActor,
with a load() function that internally calls an
asynchronous function using Task.
@MainActor
class
ContentViewModel
ObservableObject
@Published
private(set)
var
result
Weather
func
load
()
async
try | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-6 | load
()
async
try
await
Task
sleep
nanoseconds
oneSecond
self
result
sunny
Next, define the view model as a state object using @StateObject,
with a load() function that can be called by the view model:
struct
ContentView
View
@StateObject
var
viewModel
ContentViewModel
()
var
body
some
View
Text
viewModel
result
rawValue
??
"Loading..."
task
await
viewModel | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-7 | task
await
viewModel
load
()
In Dart, all work runs on the main isolate by default.
To implement the same example in Dart,
first, create the Weather enum:
Then, define a simple view model (similar to what was created in SwiftUI),
to fetch the weather. In Dart, a Future object represents a value to be
provided in the future. A Future is similar to Swift’s ObservableObject.
In this example, a function within the view model returns a Future<Weather> object:
The load() function in this example shares
similarities with the Swift code.
The Dart function is marked as async because
it uses the await keyword.
Additionally, a Dart function marked as async
automatically returns a Future.
In other words, you don’t have to create a
Future instance manually
inside functions marked as async. | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-8 | For the last step, display the weather value.
In Flutter, FutureBuilder and
StreamBuilder
widgets are used to display the results of a Future in the UI.
The following example uses a FutureBuilder:
For the complete example, check out the
async_weather file on GitHub.
Leveraging a background thread/isolate
Flutter apps can run on a variety of multi-core hardware,
including devices running macOS and iOS.
To improve the performance of these applications,
you must sometimes run tasks on different cores
concurrently. This is especially important
to avoid blocking UI rendering with long-running operations.
In Swift, you can leverage GCD to run tasks on global queues
with different quality of service class (qos) properties.
This indicates the task’s priority.
func
parse
string
String
completion
@escaping
([ | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-9 | completion
@escaping
([
String
Any
])
>
Void
// Mimic 1 sec delay.
DispatchQueue
label
"data_processing_queue"
qos
userInitiated
asyncAfter
deadline
now
()
let
result
String
Any
"foo"
123
completion
result | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-10 | 123
completion
result
In Dart, you can offload computation to a worker isolate,
often called a background worker.
A common scenario spawns a simple worker isolate and
returns the results in a message when the worker exits.
As of Dart 2.19, you can use Isolate.run() to
spawn an isolate and run computations:
void
main
()
async
// Read some data.
final
jsonData
await
Isolate
run
(()
jsonDecode
jsonString
as
Map
String
dynamic
>);
// Use that data.
print | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-11 | >);
// Use that data.
print
'Number of JSON keys:
${jsonData.length}
);
In Flutter, you can also use the compute function
to spin up an isolate to run a callback function:
final
jsonData
await
compute
getNumberOfKeys
jsonString
);
In this case, the callback function is a top-level
function as shown below:
Map
String
dynamic
getNumberOfKeys
String
jsonString
return
jsonDecode
jsonString
); | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
23476a2afaf2-12 | jsonDecode
jsonString
);
You can find more information on Dart at
Learning Dart as a Swift developer,
and more information on Flutter at
Flutter for SwiftUI developers or
Flutter for UIKit developers. | https://docs.flutter.dev/resources/dart-swift-concurrency/index.html |
85b7f9496d7a-0 | Flutter design documents
This is a collection of design documents
written by engineers working on Flutter.
New design documents can be added by following the instructions
in the design doc template. | https://docs.flutter.dev/resources/design-docs/index.html |
bda2c5928653-0 | FAQ
Introduction
What is Flutter?
Who is Flutter for?
How much development experience do I need to use Flutter?
What kinds of apps can I build with Flutter?
Who makes Flutter?
Who uses Flutter?
What makes Flutter unique?
Should I build my next production app with Flutter?
What does Flutter provide?
What is inside the Flutter SDK?
Does Flutter work with any editors or IDEs?
Does Flutter come with a framework?
Does Flutter come with widgets?
Does Flutter support Material Design?
Does Flutter come with a testing framework?
Does Flutter come with debugging tools?
Does Flutter come with a dependency injection framework?
Technology | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-1 | Technology
What technology is Flutter built with?
How does Flutter run my code on Android?
How does Flutter run my code on iOS?
Does Flutter use my operating system’s built-in platform widgets?
What happens when my mobile OS updates and introduces new widgets?
What happens when my mobile OS updates and introduces new platform capabilities?
What operating systems can I use to build a Flutter app?
What language is Flutter written in?
Why did Flutter choose to use Dart?
Can Flutter run any Dart code?
How big is the Flutter engine?
Capabilities | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-2 | What kind of app performance can I expect?
What kind of developer cycles can I expect? How long between edit and refresh?
How is hot reload different from hot restart?
Where can I deploy my Flutter app?
What devices and OS versions does Flutter run on?
Does Flutter run on the web?
Can I use Flutter to build desktop apps?
Can I use Flutter inside of my existing native app?
Can I access platform services and APIs like sensors and local storage?
Can I extend and customize the bundled widgets?
Why would I want to share layout code across iOS and Android?
Can I interop with my mobile platform’s default programming language?
Does Flutter come with a reflection / mirrors system?
How do I do internationalization (i18n), localization (l10n), and accessibility (a11y) in Flutter? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-3 | How do I write parallel and/or concurrent apps for Flutter?
Can I run Dart code in the background of an Flutter app?
Can I use JSON/XML/protobuffers, etc. with Flutter?
Can I build 3D (OpenGL) apps with Flutter?
Why is my APK or IPA so big?
Do Flutter apps run on Chromebooks?
Is Flutter ABI compatible? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-4 | Framework
Why is the build() method on State, rather than StatefulWidget?
Where is Flutter’s markup language? Why doesn’t Flutter have a markup syntax?
My app has a Debug banner/ribbon in the upper right. Why am I seeing that?
What programming paradigm does Flutter’s framework use?
Project
Where can I get support?
How do I get involved?
Is Flutter open source?
Which software license(s) apply to Flutter and its dependencies?
How can I determine the licenses my Flutter application needs to show?
Who works on Flutter?
What are Flutter’s guiding principles?
Will Apple reject my Flutter app?
Introduction
This page collects some common questions asked about
Flutter. You might also check out the following
specialized FAQs:
Web FAQ
Performance FAQ
What is Flutter? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-5 | Performance FAQ
What is Flutter?
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.
Who is Flutter for?
For users, Flutter makes beautiful apps come to life.
For developers, Flutter lowers the bar to entry for building apps.
It speeds app development and reduces the cost and complexity
of app production across platforms.
For designers, Flutter provides a canvas for
high-end user experiences. Fast Company described
Flutter as one of the top design ideas of the decade for
its ability to turn concepts into production code
without the compromises imposed by typical frameworks.
It also acts as a productive prototyping tool,
with CodePen support for sharing your ideas with others. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-6 | For engineering managers and businesses,
Flutter allows the unification of app
developers into a single mobile, web,
and desktop app team, building branded
apps for multiple platforms out of a single codebase.
Flutter speeds feature development and synchronizes
release schedules across the entire customer base.
How much development experience do I need to use Flutter?
Flutter is approachable to programmers familiar with
object-oriented concepts (classes, methods, variables,
etc) and imperative programming concepts (loops,
conditionals, etc).
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 designed to support mobile apps that run
on both Android and iOS, as well as interactive apps
that you want to run on your web pages or on the desktop. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-7 | Apps that need to deliver highly branded designs
are particularly well suited for Flutter.
However, you can also create pixel-perfect experiences
that match the Android and iOS design languages with Flutter.
Flutter’s package ecosystem supports a wide
variety of hardware (such as camera, GPS, network,
and storage) and services (such as payments, cloud
storage, authentication, and ads).
Who makes Flutter?
Flutter is an open source project,
with contributions from Google and other
companies and individuals.
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 showcase.
What makes Flutter unique? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-8 | What makes Flutter unique?
Flutter is different than most other options
for building mobile apps because it doesn’t rely
on web browser technology nor the set of widgets
that ship with each 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? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-9 | Should I build my next production app with Flutter?
Flutter 1.0 was launched on Dec 4th, 2018 and
Flutter 2 on March 3rd, 2021.
Since its launch, over 400,000 apps have shipped using
Flutter to many hundreds of millions of devices.
See some sample apps in the showcase.
Flutter ships updates on a roughly-quarterly
cadence that improve stability and performance
and address commonly-requested user features.
What does Flutter provide?
What is inside the Flutter SDK?
Flutter includes:
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 | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-10 | Interop and plugin APIs to connect to the system and 3rd-party SDKs
Headless test runner for running tests on Windows, Linux, and Mac
Dart DevTools 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?
Android Studio,
IntelliJ IDEA, and
VS Code. See
editor configuration for setup details,
and
Android Studio/IntelliJ and
VS Code
for tips on how to use the plugins.
Alternatively, you can use the flutter command
from a terminal, along with one
of the many editors that support editing Dart.
Does Flutter come with a framework? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-11 | Does Flutter come with a framework?
Yes! Flutter ships with a modern react-style framework.
Flutter’s framework is designed to be layered and
customizable (and optional). Developers can choose to
use only parts of the framework, or even replace
upper layers of the framework entirely.
Does Flutter come with widgets?
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 Design?
Yes! The Flutter and Material teams collaborate closely,
and Material is fully supported. A number of examples
of this are shown in the MDC-103 Flutter:
Material Theming codelab.
Does Flutter come with a testing framework? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-12 | Does Flutter come with a testing framework?
Yes, Flutter provides APIs for writing unit and
integration tests. Learn more about testing with Flutter.
We use our own testing capabilities to test our SDK,
and we measure our test coverage on every commit.
Does Flutter come with debugging tools?
Yes, Flutter comes with Flutter DevTools (also
called Dart DevTools). For more information, see
Debugging with Flutter and the Flutter DevTools docs.
Does Flutter come with a dependency injection framework?
We don’t ship with an opinionated solution,
but there are a variety of packages that offer
dependency injection and service location, such as injectable,
get_it, kiwi, and riverpod.
Technology
What technology is Flutter built with? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-13 | Technology
What technology is Flutter built with?
Flutter is built with C, C++, Dart, and Skia
(a 2D rendering engine). See this architecture diagram
for a better picture of the main components.
For a more detailed description of the layered architecture
of Flutter, read the architectural overview.
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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-14 | During debug mode, Flutter uses a virtual machine (VM)
to run its code in order to enable stateful hot reload,
a feature that lets you make changes to your running code
without recompilation. You’ll see a “debug” banner in
the top right-hand corner of your app when running in this mode,
to remind you that performance is not characteristic of
the finished release app.
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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-15 | During debug mode, Flutter uses a virtual machine (VM)
to run its code in order to enable stateful hot reload,
a feature that lets you make changes to your
running code without recompilation. You’ll see
a “debug” banner in the top right-hand corner of
your app when running in this mode, to remind you that
performance is not characteristic of the finished release app.
Does Flutter use my operating system’s built-in platform widgets?
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 catalog of Flutter’s widgets.
We believe that the end result is higher quality apps.
If we reused the built-in platform widgets,
the quality and performance of Flutter apps would be limited
by the flexibility and quality of those widgets. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-16 | 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 gesture system.
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 built-in widgets.
By using the same renderer, framework, and set of widgets,
it’s easier to publish for multiple platforms from the same
codebase, without having to do careful and costly planning
to align different feature sets and API characteristics. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-17 | By using a single language, a single framework,
and a single set of libraries for all of your code
(regardless if your UI is different for each platform or not),
we also aim to help lower app development and maintenance costs.
What happens when my mobile OS updates and introduces new widgets?
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.
What happens when my mobile OS updates and introduces new platform capabilities? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-18 | What happens when my mobile OS updates and introduces new platform capabilities?
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 using Linux, macOS, ChromeOS,
and Windows.
What language is Flutter written in?
Dart, a fast-growing modern language optimized
for client apps. The underlying graphics framework
and the Dart virtual machine are implemented in C/C++.
Why did Flutter choose to use Dart? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-19 | Why did Flutter choose to use Dart?
During the initial development phase,
the Flutter team looked at a lot of
languages and runtimes, and ultimately
adopted Dart for the framework and widgets.
Flutter used four primary dimensions for evaluation,
and considered the needs of framework authors,
developers, and end users. We found many 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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-20 | 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: | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-21 | Dart scores highly for us on the following primary criteria:
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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-22 | 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.
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 predictable
performance, without periodic pauses that would cause
dropped frames. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-23 | 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 can run Dart code that doesn’t directly or
transitively import dart:mirrors or dart:html.
How big is the Flutter engine?
In March 2021, we measured the download size of a
minimal Flutter app (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 ARM32, and 4.8 MB for ARM64. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-24 | On ARM32, the core engine is approximately 3.4 MB
(compressed), the framework + app code is approximately
765 KB (compressed), the LICENSE file is 58 KB
(compressed), and necessary Java code (classes.dex)
is 120 KB (compressed).
In ARM64, the core engine is approximately 4.0 MB
(compressed), the framework + app code is approximately
659 KB (compressed), the LICENSE file is 58 KB
(compressed), and necessary Java code (classes.dex)
is 120 KB (compressed).
These numbers were measured using apkanalyzer,
which is also built into Android Studio. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-25 | These numbers were measured using apkanalyzer,
which is also built into Android Studio.
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
iOS App Store Specific Considerations
section of Apple’s QA1795).
Note:
The release engine binary used to include LLVM IR (bitcode).
However, Apple deprecated bitcode in Xcode 14 and removed support,
so it has been removed from the Flutter 3.7 release.
Of course, we recommend that you measure your own app.
To do that, see Measuring your app’s size.
Capabilities
What kind of app performance can I expect? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-26 | Capabilities
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 that 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? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-27 | 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 Hot reload.
Where can I deploy my Flutter app?
You can compile and deploy your Flutter app to iOS, Android,
web, and desktop.
What devices and OS versions does Flutter run on?
We support and test running Flutter on a variety
of low-end to high-end platforms. For a detailed list
of the platforms on which we test, see
the list of supported platforms.
Flutter supports building ahead-of-time (AOT) compiled libraries
for x86_64, armeabi-v7a, and arm64-v8a. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-28 | Apps built for ARMv7 or ARM64 run fine (using ARM emulation)
on many x86 Android devices.
We support developing Flutter apps on a range of platforms.
See the system requirements listed under each
development operating system.
Does Flutter run on the web?
Yes, web support is available in the stable channel.
You can compile existing Flutter code to work on the web.
For more details, check out the web instructions.
Can I use Flutter to build desktop apps?
Yes, desktop support is in stable for Windows,
macOS, and Linux.
Can I use Flutter inside of my existing native app?
Yes, learn more in the add-to-app section of our website.
Can I access platform services and APIs like sensors and local storage? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-29 | 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
ready-made packages available on pub.dev.
Using an existing package is easy.
Finally, we encourage developers to use Flutter’s
asynchronous message passing system to create your
own integrations with platform and third-party APIs.
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.
Can I extend and customize the bundled widgets?
Absolutely. Flutter’s widget system was designed
to be easily customizable. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-30 | 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, ElevatedButton 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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-31 | 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.
Why would I want to share layout code across iOS and Android?
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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-32 | 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 BasicMessageChannel.
Learn more about accessing platform and third-party services
in Flutter with platform channels. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-33 | Learn more about accessing platform and third-party services
in Flutter with platform channels.
Here is an example project 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?
No. Dart includes dart:mirrors,
which provides type reflection. But since
Flutter apps are pre-compiled for production,
and binary size is always a concern with mobile apps,
this library is unavailable for Flutter apps. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-34 | Using static analysis we can strip out anything that isn’t
used (“tree shaking”). If you import a huge Dart library
but only use a self-contained two-line method,
then you only pay the cost of the two-line method,
even if that Dart library itself imports dozens and
dozens of other libraries. This guarantee is only secure
if Dart can identify the code path at compile time.
To date, we’ve found other approaches for specific needs
that offer a better trade-off, such as code generation.
How do I do internationalization (i18n), localization (l10n), and accessibility (a11y) in Flutter?
Learn more about i18n and l10n in the
internationalization tutorial.
Learn more about a11y in the
accessibility documentation.
How do I write parallel and/or concurrent apps for Flutter? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-35 | 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 example of using isolates with Flutter.
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 free Medium article
Executing Dart in the Background with Flutter Plugins and Geofencing.
Can I use JSON/XML/protobuffers, etc. with Flutter?
Absolutely. There are libraries on
pub.dev for JSON, XML, protobufs,
and many other utilities and formats.
For a detailed writeup on using JSON with Flutter,
check out the JSON tutorial. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-36 | For a detailed writeup on using JSON with Flutter,
check out the JSON tutorial.
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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-37 | Learn more about creating a
release build of your Android app,
and creating a release build of your iOS app.
Also, check out Measuring your app’s size.
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.
Is Flutter ABI compatible?
Flutter and Dart do not offer application binary interface (ABI)
compatibility. Offering ABI compatability is not a current
goal for Flutter or Dart.
Framework
Why is the build() method on State, rather than StatefulWidget?
detailed discussion on the API docs for State.build.
Where is Flutter’s markup language? Why doesn’t Flutter have a markup syntax? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-38 | 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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-39 | 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 hot reload
(release builds are compiled using the standard Android
and iOS 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 your IDE uses the Flutter plugin,
you can launch the app in profile or release mode.
For IntelliJ, use the menu entries
Run > Flutter Run in Profile Mode or Release Mode.
What programming paradigm does Flutter’s framework use? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-40 | 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:
The primary paradigm used by Flutter is that of using
small objects with narrow scopes of behavior, composed together to
obtain more complicated effects, sometimes called
aggressive composition. Most widgets in the Flutter widget
library are built in this way. For example, the Material
TextButton class is built using
an IconTheme, an InkWell, a Padding,
a Center, a Material,
an AnimatedDefaultTextStyle, and a ConstrainedBox.
The InkWell is built using a GestureDetector.
The Material is built using an
AnimatedDefaultTextStyle,
a NotificationListener, and an AnimatedPhysicalModel.
And so on. It’s widgets all the way down. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-41 | Entire applications can be built with only
StatelessWidgets, which are essentially functions that
describe how arguments map to other functions, bottoming out
in primitives that compute layouts or paint graphics.
(Such applications can’t easily have state,
so are typically non-interactive.) For example, the Icon
widget is essentially a function that maps its arguments
(color, icon, size) into layout primitives.
Additionally, heavy use is made of immutable data structures,
including the entire Widget class
hierarchy as well as numerous supporting classes such as
Rect and TextStyle. On a smaller scale, Dart’s
Iterable API, which makes heavy use of the functional
style (map, reduce, where, etc), is frequently used to process
lists of values in the framework.
User interactions are represented by event objects
that are dispatched to callbacks registered with event handlers.
Screen updates are triggered by a similar callback mechanism. The
Listenable class, which is used as the basis of the
animation system, formalizes a subscription model for events
with multiple listeners. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-42 | Most of the APIs of the framework are built using classes
with inheritance. We use an approach whereby we define
very high-level APIs in our base classes, then specialize
them iteratively in subclasses. For example,
our render objects have a base class (RenderObject)
that is agnostic regarding the coordinate system,
and then we have a subclass (RenderBox)
that introduces the opinion that the geometry should be based
on the Cartesian coordinate system (x/width and y/height).
The ScrollPhysics class chains instances to compose
the physics that apply to scrolling dynamically at runtime.
This lets the system compose, for example, paging physics
with platform-specific physics, without the platform having to be
selected at compile time. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-43 | Straightforward imperative programming, usually
paired with state encapsulated within an object,
is used where it provides the most intuitive solution.
For example, tests are written in an imperative style,
first describing the situation under test, then listing
the invariants that the test must match, then advancing
the clock or inserting events as necessary for the test. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-44 | The widget and element trees are sometimes described as
reactive, because new inputs provided in a widget’s
constructor are immediately propagated as changes to
lower-level widgets by the widget’s build method, and
changes made in the lower widgets (for example,
in response to user input) propagate back up the tree
via event handlers. Aspects of both functional-reactive and
imperative-reactive are present in the framework,
depending on the needs of the widgets. Widgets with build
methods that consist of just an expression describing how
the widget reacts to changes in its configuration are functional
reactive widgets (for example, the Material Divider class).
Widgets whose build methods construct a list of children
over several statements, describing how the widget reacts
to changes in its configuration, are imperative reactive
widgets (for example, the Chip class). | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-45 | The build methods of widgets are often a single
expression with multiple levels of nested constructors,
written using a strictly declarative subset of Dart.
Such nested expressions could be mechanically transformed
to or from any suitably expressive markup language.
For example, the UserAccountsDrawerHeader
widget has a long build method (20+ lines),
consisting of a single nested expression.
This can also be combined with the imperative style to build UIs
that would be harder to describe in a pure-declarative approach. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-46 | Types can be used to help developers catch programming
errors early. The Flutter framework uses generic programming to
help in this regard. For example, the State
class is parameterized in terms of the type of its
associated widget, so that the Dart analyzer can catch
mismatches of states and widgets. Similarly, the
GlobalKey class takes a type parameter so that it
can access a remote widget’s state in a type-safe manner
(using runtime checking), the Route interface is
parameterized with the type that it is expected to use when
popped, and collections such as Lists, Maps,
and Sets are all parameterized so that mismatched
elements can be caught early either during analysis or at
runtime during debugging.
Flutter makes heavy use of Futures and other
asynchronous APIs. For example, the animation system reports
when an animation is finished by completing a future.
The image loading system similarly uses futures to report
when a load is complete. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-47 | The layout system in Flutter uses a weak form of
constraint programming to determine the geometry of a scene.
Constraints (for example, for cartesian boxes, a minimum and
maximum width and a minimum and maximum height)
are passed from parent to child, and the child selects a resulting
geometry (for example, for cartesian boxes, a size,
specifically a width and a height) that fulfills those constraints.
By using this technique, Flutter can usually
lay out an entire scene with a single pass.
Project
Where can I get support?
If you think you’ve encountered a bug, file it in our
issue tracker. You might also use
Stack Overflow for “HOWTO” type questions.
For discussions, join our mailing list at
[email protected] or seek us out on Discord.
For more information, see our Community page.
How do I get involved? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-48 | 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 issue tracker.
We recommend that you join our mailing list at
[email protected] 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 Contributing Guide and check out our
list of easy starter issues.
Finally, you can connect with helpful Flutter communities.
For more information, see our Community page.
Is Flutter open source?
Yes, Flutter is open source technology.
You can find the project on GitHub.
Which software license(s) apply to Flutter and its dependencies? | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-49 | 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 license file.
The framework is entirely self-contained and requires
only one license.
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:
If your application has a Drawer, add an
AboutListTile.
If your application doesn’t have a Drawer but does use the
Material Components library, call either showAboutDialog
or showLicensePage.
For a more custom approach, you can get the raw licenses from the
LicenseRegistry. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-50 | Who works on Flutter?
We all do! 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. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-51 | 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:
Developers deserve access to, and control over,
all layers of the system. Which leads to:
Users deserve perfectly fluid, responsive,
jank-free apps. Which leads to:
Everyone deserves precise, beautiful, delightful
app experiences.
Will Apple reject my Flutter app?
We can’t speak for Apple, but their App Store contains
many apps built with framework technologies such as Flutter.
Indeed, Flutter uses the same fundamental architectural
model as Unity, the engine that powers many of the
most popular games on the Apple store.
Apple has frequently featured well-designed apps
that are built with Flutter,
including Hamilton and Reflectly. | https://docs.flutter.dev/resources/faq/index.html |
bda2c5928653-52 | As with any app submitted to the Apple store,
apps built with Flutter should follow Apple’s
guidelines for App Store submission. | https://docs.flutter.dev/resources/faq/index.html |
9b1f86813add-0 | Casual Games Toolkit
How Flutter can help
What’s included
Get started
Video games
Other resources
The Flutter Casual Games Toolkit, announced at Google I/O 2022,
pulls together new and existing resources that enable you to
speed up development of casual games on mobile.
This page outlines what resources are available and
where you can find them.
How Flutter can help
In the beginning, four engineers had a vision of
developing a framework for creating performant mobile apps
written as a single application.
What later became Flutter has grown in many ways,
but has always focused on writing apps.
Games fall into roughly two categories: video games
and app-like games. You are likely familiar with both
types of games, though you might not have thought
about them in quite this way. | https://docs.flutter.dev/resources/games-toolkit/index.html |
9b1f86813add-1 | Video games include arcade-style games: shooters,
racing games, and so on.
Video games are generally action-based and use a
continual input device, like a joystick.
App-like games include casual games such as board games,
card games, puzzles, and strategy games.
App-like games tend to respond to user input,
like tapping on a card or entering a number or letter.
Because these games are app-like, they are
especially well suited for Flutter.
When we say casual games, we are primarily
referring to app-like games in this context.
What’s included
The Casual Games Toolkit provides the following free resources:
A game template app, available in Flutter’s
samples repo, includes the following prebuilt features:
Main menu
Sound & music
Ads
In-app purchases
Achievements and leader boards
Crashlytics support | https://docs.flutter.dev/resources/games-toolkit/index.html |
9b1f86813add-2 | A video, Build your own game in Flutter,
explaining how to use the template
Source code for a finished tic tac toe game,
built using the game template,
and released on Android and iOS
A link to a Flutter Games Discord channel
(use the direct link if you already
have a Discord account)
And, yes, the game template assumes that you’ll
want to earn money for your mobile game,
so the ads and in-app purchase packages are already
integrated with the template and ready to be configured. | https://docs.flutter.dev/resources/games-toolkit/index.html |
9b1f86813add-3 | As explained on the Games page,
you can also take advantage of up to $900
in offers when you integrate Google services,
such as Cloud, Firebase, and Ads,
into your game.
(Terms and conditions apply: You must connect your
Firebase and GCP accounts to use credits for
Firebase services and verify your business
email during sign up to earn an additional $100
on top of the normal $300 credit. For the Ads offer,
check your region’s eligibility).
Get started
Are you ready? To get started:
Watch the Quick Start video
Clone the games template repo
Join the Flutter Games community on Discord
(use the direct link if you already
have a Discord account).
Set up accounts on AdMob, Firebase, and Cloud, as needed
Write your game!
Deploy to both the Google and Apple stores
Video games | https://docs.flutter.dev/resources/games-toolkit/index.html |
9b1f86813add-4 | Deploy to both the Google and Apple stores
Video games
Perhaps you want to write a video-style game?
The game template is still valuable for
the high-level structure of such games.
For video games, you might want to look into the
Flame package,
join the Flame community on Discord,
and play with the Flame demo app on DartPad.
You might also check out the Flutter + Flame codelab.
In fact, the people at Very Good Ventures wrote a
Pinball game for Google I/O 2022
using the Flame engine. For more information, check out
I/O Pinball Powered by Flutter and Firebase,
a free article on Medium and play the game.
Other resources
Once you feel ready to go beyond the games template,
you might want to investigate other resources
recommended by the community.
Bolded items in the following table are used in the games template:
Animations & sprites | https://docs.flutter.dev/resources/games-toolkit/index.html |
9b1f86813add-5 | Animations & sprites
Special effects recipes (including animations)
rive package
Spriter Pro tool
spriteWidget package
App review
app_review package
Audio
audioplayers package
Firebase
Flutter Firebase getting started guide NEWLY UPDATED
firebase_crashlytics
package (tracks crashes of your app)
Game engines
Flame engine
Bonfire engine
forge2d package
Games services
games_services package
Images and icons
CraftPix (free and purchasable assets)
Game Developer Studio (purchasable asset packs)
GIMP (a free image editor to create your own assets)
Persistence
shared_preferences package
sqflite package
Couchbase Lite, cbl_flutter package | https://docs.flutter.dev/resources/games-toolkit/index.html |
9b1f86813add-6 | Special effects
Paint API docs
Special effects recipes
Win 32
win32_gamepad
package (supports win32 gamepad) | https://docs.flutter.dev/resources/games-toolkit/index.html |
8b9a5f78a039-0 | Inside Flutter
Aggressive composability
Sublinear layout
Sublinear widget building
Linear reconciliation
Tree surgery
Constant-factor optimizations
Separation of the Element and RenderObject trees
Infinite scrolling
Viewport-aware layout
Building widgets on demand
API Ergonomics
Specializing APIs to match the developer’s mindset
Explicit arguments
Paving over pitfalls
Reporting error cases aggressively
Reactive paradigm
Interpolation
Conclusion | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-1 | Conclusion
This document describes the inner workings of the Flutter toolkit that make
Flutter’s API possible. Because Flutter widgets are built using aggressive
composition, user interfaces built with Flutter have a large number of
widgets. To support this workload, Flutter uses sublinear algorithms for
layout and building widgets as well as data structures that make tree
surgery efficient and that have a number of constant-factor optimizations.
With some additional details, this design also makes it easy for developers
to create infinite scrolling lists using callbacks that build exactly those
widgets that are visible to the user.
Aggressive composability
One of the most distinctive aspects of Flutter is its aggressive
composability. Widgets are built by composing other widgets,
which are themselves built out of progressively more basic widgets.
For example, Padding is a widget rather than a property of other widgets.
As a result, user interfaces built with Flutter consist of many,
many widgets. | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-2 | The widget building recursion bottoms out in RenderObjectWidgets,
which are widgets that create nodes in the underlying render tree.
The render tree is a data structure that stores the geometry of the user
interface, which is computed during layout and used during painting and
hit testing. Most Flutter developers do not author render objects directly
but instead manipulate the render tree using widgets.
In order to support aggressive composability at the widget layer,
Flutter uses a number of efficient algorithms and optimizations at
both the widget and render tree layers, which are described in the
following subsections.
Sublinear layout | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-3 | Sublinear layout
With a large number of widgets and render objects, the key to good
performance is efficient algorithms. Of paramount importance is the
performance of layout, which is the algorithm that determines the
geometry (for example, the size and position) of the render objects.
Some other toolkits use layout algorithms that are O(N²) or worse
(for example, fixed-point iteration in some constraint domain).
Flutter aims for linear performance for initial layout, and sublinear
layout performance in the common case of subsequently updating an
existing layout. Typically, the amount of time spent in layout should
scale more slowly than the number of render objects. | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-4 | Flutter performs one layout per frame, and the layout algorithm works
in a single pass. Constraints are passed down the tree by parent
objects calling the layout method on each of their children.
The children recursively perform their own layout and then return
geometry up the tree by returning from their layout method. Importantly,
once a render object has returned from its layout method, that render
object will not be visited again1
until the layout for the next frame. This approach combines what might
otherwise be separate measure and layout passes into a single pass and,
as a result, each render object is visited at most
twice2 during layout: once on the way
down the tree, and once on the way up the tree. | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-5 | Flutter has several specializations of this general protocol.
The most common specialization is RenderBox, which operates in
two-dimensional, cartesian coordinates. In box layout, the constraints
are a min and max width and a min and max height. During layout,
the child determines its geometry by choosing a size within these bounds.
After the child returns from layout, the parent decides the child’s
position in the parent’s coordinate system3.
Note that the child’s layout cannot depend on its position,
as the position is not determined until after the child
returns from the layout. As a result, the parent is free to reposition
the child without needing to recompute its layout.
More generally, during layout, the only information that flows from
parent to child are the constraints and the only information that
flows from child to parent is the geometry. These invariants can reduce
the amount of work required during layout: | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-6 | If the child has not marked its own layout as dirty, the child can
return immediately from layout, cutting off the walk, as long as the
parent gives the child the same constraints as the child received
during the previous layout.
Whenever a parent calls a child’s layout method, the parent indicates
whether it uses the size information returned from the child. If,
as often happens, the parent does not use the size information,
then the parent need not recompute its layout if the child selects
a new size because the parent is guaranteed that the new size will
conform to the existing constraints. | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-7 | Tight constraints are those that can be satisfied by exactly one
valid geometry. For example, if the min and max widths are equal to
each other and the min and max heights are equal to each other,
the only size that satisfies those constraints is one with that
width and height. If the parent provides tight constraints,
then the parent need not recompute its layout whenever the child
recomputes its layout, even if the parent uses the child’s size
in its layout, because the child cannot change size without new
constraints from its parent.
A render object can declare that it uses the constraints provided
by the parent only to determine its geometry. Such a declaration
informs the framework that the parent of that render object does
not need to recompute its layout when the child recomputes its layout
even if the constraints are not tight and even if the parent’s
layout depends on the child’s size, because the child cannot change
size without new constraints from its parent. | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-8 | As a result of these optimizations, when the render object tree contains
dirty nodes, only those nodes and a limited part of the subtree around
them are visited during layout.
Sublinear widget building
Similar to the layout algorithm, Flutter’s widget building algorithm
is sublinear. After being built, the widgets are held by the element
tree, which retains the logical structure of the user interface.
The element tree is necessary because the widgets themselves are
immutable, which means (among other things), they cannot remember their
parent or child relationships with other widgets. The element tree also
holds the state objects associated with stateful widgets. | https://docs.flutter.dev/resources/inside-flutter/index.html |
8b9a5f78a039-9 | In response to user input (or other stimuli), an element can become dirty,
for example if the developer calls setState() on the associated state
object. The framework keeps a list of dirty elements and jumps directly
to them during the build phase, skipping over clean elements. During
the build phase, information flows unidirectionally down the element
tree, which means each element is visited at most once during the build
phase. Once cleaned, an element cannot become dirty again because,
by induction, all its ancestor elements are also
clean4.
Because widgets are immutable, if an element has not marked itself as
dirty, the element can return immediately from build, cutting off the walk,
if the parent rebuilds the element with an identical widget. Moreover,
the element need only compare the object identity of the two widget
references in order to establish that the new widget is the same as
the old widget. Developers exploit this optimization to implement the
reprojection pattern, in which a widget includes a prebuilt child
widget stored as a member variable in its build. | https://docs.flutter.dev/resources/inside-flutter/index.html |
Subsets and Splits