From 2d77ad52d8e4af75d576d8b5267a38005f004e64 Mon Sep 17 00:00:00 2001 From: "Shams Zakhour (ignore Sfshaza)" Date: Tue, 18 Aug 2026 15:48:25 -0700 Subject: [PATCH 1/2] An update of the FAQ - a first draft --- sites/docs/src/content/resources/faq.md | 1241 ++++++++--------------- 1 file changed, 401 insertions(+), 840 deletions(-) diff --git a/sites/docs/src/content/resources/faq.md b/sites/docs/src/content/resources/faq.md index caa1f263e3..8066ee637c 100644 --- a/sites/docs/src/content/resources/faq.md +++ b/sites/docs/src/content/resources/faq.md @@ -6,167 +6,133 @@ showBreadcrumbs: false ## Introduction -This page collects some common questions asked about -Flutter. You might also check out the following -specialized FAQs: +This page collects common questions about Flutter. +You can also check out the following specialized FAQs: * [Web FAQ][] * [Performance FAQ][] -[Web FAQ]: /platform-integration/web/faq [Performance FAQ]: /perf/faq +[Web FAQ]: /platform-integration/web/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 is Google's open source framework +for crafting beautiful, natively compiled applications +for mobile (iOS, Android), web, desktop (macOS, Windows, Linux), +and embedded devices from a single codebase. Flutter works with existing code, -is used by developers and organizations around -the world, and is free and open source. +is used by developers and organizations worldwide, +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 developers, Flutter accelerates app development +and reduces the cost and complexity of building 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 drag-and-drop tools like [FlutterFlow][] -and web-based IDEs like [Zapp!][]. +For designers, Flutter provides a flexible canvas +for high-end user experiences. +It turns concepts into production code +without the compromises imposed by traditional cross-platform frameworks. For engineering managers and businesses, -Flutter 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. - -[FlutterFlow]: https://flutterflow.io/ -[Zapp!]: https://zapp.run/ -[one of the top design ideas of the decade]: https://www.fastcompany.com/90442092/the-14-most-important-design-ideas-of-the-decade-according-to-the-experts +Flutter enables the unification of app developers into a single team, +building branded apps for multiple platforms from a single codebase. +Flutter speeds feature development and synchronizes release schedules +across your customer base. ### 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. +Flutter is approachable to programmers familiar with object-oriented +and imperative or declarative programming concepts. +Experience with languages such as Java, Kotlin, Swift, TypeScript, +or C# helps you learn Dart and Flutter quickly. ### 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. +Flutter supports building mobile apps on Android and iOS, +web applications, desktop apps on macOS, Windows, and Linux, +and embedded device interfaces. -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. +Apps that require custom, branded designs are well suited for Flutter. +You can also create pixel-perfect experiences that match +Android's Material Design and iOS's Cupertino design languages. -Flutter's [package ecosystem][] supports a wide -variety of hardware (such as camera, GPS, network, -and storage) and services (such as payments, cloud -storage, authentication, and [ads][]). +Flutter's [package ecosystem][] on pub.dev supports a wide variety of hardware +(such as camera, GPS, Bluetooth, network, and local storage) +and cloud services (such as authentication, notifications, payments, and storage). -[ads]: {{site.main-url}}/monetization [package ecosystem]: {{site.pub}}/flutter ### Who makes Flutter? -Flutter is an open source project, -with contributions from Google and other -companies and individuals. +Flutter is an open source project managed by Google, +with contributions from a global community of developers, +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][]. +Developers and organizations worldwide use Flutter to build +natively compiled applications. +To explore apps built with Flutter, visit the [showcase][]. [showcase]: {{site.main-url}}/showcase ### 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. +Flutter differs from most cross-platform alternatives +because it does not rely on web browser views +or system-provided platform widgets. +Instead, Flutter renders its UI using its own high-performance +rendering engine ([Impeller][]). + +In addition, Flutter implements most of its framework +(including compositing, gestures, animation, and widgets) in [Dart][]. +This architecture gives you deep control over the UI, +high predictability, and the ability to inspect or modify +the framework at any level. [Dart]: {{site.dart-site}}/ +[Impeller]: /perf/impeller ### Should I build my next production app with Flutter? -[Flutter 1][] was launched on Dec 4th, 2018, -[Flutter 2][] on March 3rd, 2021, and -[Flutter 3][] on May 10th, 2023. -As of May 2023, over _one million_ apps have shipped using -Flutter to many hundreds of millions of devices. -Check out 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. +Yes. Thousands of organizations, from early-stage startups +to large enterprises, deploy production Flutter apps +to hundreds of millions of users. +Explore real-world examples in the [showcase][]. -[Flutter 1]: {{site.google-blog}}/2018/12/flutter-10-googles-portable-ui-toolkit.html -[Flutter 2]: {{site.google-blog}}/2021/03/announcing-flutter-2.html -[Flutter 3]: {{site.google-blog}}/flutter/introducing-flutter-3-5eb69151622f +Flutter releases updates on a regular cadence, +bringing performance improvements, new features, +and platform updates to the stable channel. ## What does Flutter provide? ### What is inside the Flutter SDK? -Flutter includes: +The Flutter SDK 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 -* Headless test runner for running tests on Windows, Linux, and Mac -* [Flutter DevTools][] (also called Dart DevTools) - for testing, debugging, and profiling your app -* Command-line tools for creating, building, testing, and - compiling your apps +* High-performance 2D rendering engine ([Impeller][]) +* Modern, reactive framework written in Dart +* Rich set of widgets implementing Material Design 3 and Cupertino (iOS-style) +* APIs for unit, widget, and integration tests +* Interop and plugin APIs to connect to system features and native SDKs +* Headless test runner for running tests on Windows, Linux, and macOS +* [Flutter DevTools][] for profiling, debugging, and inspecting your app +* Command-line tools for creating, building, testing, and compiling apps + +[Flutter DevTools]: /tools/devtools ### Does Flutter work with any editors or IDEs? -We provide plugins for [VS Code][], -[Antigravity][] (an AI-assisted IDE), -[Android Studio][], and [IntelliJ IDEA][]. +Flutter provides plugins and extensions for [VS Code][], +[Antigravity][] (an AI-assisted IDE), [Android Studio][], +and [IntelliJ IDEA][]. See [editor configuration][] for setup details, -and [VS Code][] and [Android Studio/IntelliJ][] -for 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][]. +and [VS Code][] and [Android Studio/IntelliJ][] for usage guidance. +You can also run the `flutter` command from a terminal +along with any editor that supports [editing Dart][]. [Android Studio]: {{site.android-dev}}/studio [Android Studio/IntelliJ]: /tools/android-studio @@ -178,640 +144,408 @@ of the many editors that support [editing Dart][]. ### 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. +Yes. Flutter includes a modern, reactive framework. +The framework is layered and customizable, +allowing you to use high-level widgets or interact directly +with lower layers of the rendering pipeline. ### Does Flutter come with widgets? -Yes! Flutter ships with a set of -[high-quality Material Design and Cupertino -(iOS-style) widgets][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. +Yes. Flutter ships with a collection of high-quality +[Material Design and Cupertino (iOS-style) widgets][widgets], +layouts, and themes. +You can use these widgets as provided, +customize them, or create custom widgets. [widgets]: /ui/widgets ### Does Flutter support Material Design? -Yes! The Flutter and Material teams collaborate closely, -and Material is fully supported. For more information, -check out the Material 2 and Material 3 widgets -in the [widget catalog][]. +Yes. Flutter provides full support for [Material Design 3][widget catalog], +Google's design system. [widget catalog]: /ui/widgets/material ### 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. +Yes. Flutter provides built-in support for unit, widget, +and integration testing. +To learn more, see [Testing overview][]. -[test coverage]: https://coveralls.io/github/flutter/flutter?branch=master -[testing with Flutter]: /testing/overview +[Testing overview]: /testing/overview ### 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. +Yes. Flutter includes [Flutter DevTools][]. +For more information, see [Debugging Flutter apps][] +and the [Flutter DevTools][] documentation. -[Debugging with Flutter]: /testing/debugging -[Flutter DevTools]: /tools/devtools +[Debugging Flutter apps]: /testing/debugging ### 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][]. - +Flutter does not require an opinionated dependency injection framework. +The Flutter ecosystem offers several packages for dependency injection +and service location, such as [Riverpod][], [get_it][], +[Provider][], and [injectable][]. [get_it]: {{site.pub}}/packages/get_it [injectable]: {{site.pub}}/packages/injectable -[kiwi]: {{site.pub}}/packages/kiwi -[riverpod]: {{site.pub}}/packages/riverpod +[Provider]: {{site.pub}}/packages/provider +[Riverpod]: {{site.pub}}/packages/riverpod ## Technology ### What technology is Flutter built with? -Flutter is built with C, C++, Dart, -Skia (a 2D rendering engine), -and [Impeller][] (the default rendering engine on iOS). -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][]. +Flutter is built with C, C++, and Dart. +It uses [Impeller][] as its default rendering engine, +taking advantage of modern graphics APIs such as Metal on iOS and macOS, +and Vulkan on Android. +For a detailed description of Flutter's layered architecture, +read the [architectural overview][]. [architectural overview]: /resources/architectural-overview -[architecture diagram]: https://docs.google.com/presentation/d/1cw7A4HbvM_Abv320rVgPVGiUP2msVs7tfGbkgdrTy0I/edit#slide=id.gbb3c3233b_0_162 -[Impeller]: /perf/impeller ### How does Flutter run my code on Android? {:#run-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-64 -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. - -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. +The engine's C and C++ code is compiled using Android's NDK. +The Dart code (both the framework and your application code) +is ahead-of-time (AOT) compiled into native ARM and x86-64 machine code. +These libraries are packaged into a runner Android project +and built into an APK or Android App Bundle (AAB). +When launched, the app loads the Flutter engine, +which executes the compiled code and renders the UI. + +During debug mode, Flutter runs inside the Dart VM +to enable stateful [hot reload][], +allowing you to make changes to your running code without recompiling. +A "debug" banner in the top right corner indicates +that the app is running in debug mode. ### How does Flutter run my code on iOS? {:#run-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. - -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. +The engine's C and C++ code is compiled with LLVM. +The Dart code (both the framework and your application code) +is ahead-of-time (AOT) compiled into native ARM machine code. +The compiled code is packaged into a runner iOS project +and built into an `.ipa` bundle. +When launched, the app loads the Flutter engine, +which executes the compiled code and renders the UI using Impeller. + +During debug mode, Flutter runs inside the Dart VM +to enable stateful [hot reload][]. +A "debug" banner in the top right corner indicates +that the app is running in debug mode. ### 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. - -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. - -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. +No. Instead, Flutter renders widgets directly using its own engine, +providing implementations of Material Design and Cupertino (iOS-style) widgets. +You can explore the available widgets in the [widget catalog][catalog of Flutter's widgets]. + +By rendering pixels directly, Flutter avoids the performance constraints +and behavioral differences of platform widget abstractions. +This approach delivers consistent performance and appearance across platforms. + +For cases where you need a platform-native component +(such as Google Maps or a web view), +Flutter supports embedding [platform views][] directly into the widget tree. [catalog of Flutter's widgets]: /ui/widgets -[gesture system]: /ui/interactivity/gestures +[platform views]: /platform-integration/platform-views ### 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. +The Flutter team and community track new design guidelines +and platform widgets from Apple and Google, +updating Flutter's widget libraries accordingly. +Because Flutter widgets are written in Dart, +you can also build or adapt widgets immediately +without waiting for an OS or SDK update. ### 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. +Flutter's plugin architecture, [platform channels][], +and native interop tools (such as Dart FFI, `ffigen`, and `jnigen`) +allow you to access new OS APIs immediately. +You do not need to wait for a Flutter SDK release to integrate new platform capabilities. + +[platform channels]: /platform-integration/platform-channels ### Does Flutter support code push? -Code push, or the ability to push app updates directly to a -user's device, isn't directly supported by Flutter. -However, we are aware of a third party solution, -called [Shorebird][]. -Note that this is not an official endorsement or recommendation. +Flutter does not provide built-in code push functionality. +Third-party solutions, such as [Shorebird][], +provide code push support for Flutter applications. [Shorebird]: https://shorebird.dev/ ### What operating systems can I use to build a Flutter app? -Flutter supports development using Linux, macOS, ChromeOS, -and Windows. +Flutter supports development on macOS, Windows, Linux, and ChromeOS. +For details on system requirements, see the [install guide][install]. + +[install]: /install ### 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++. +The Flutter framework is written in [Dart][]. +The underlying engine and graphics pipeline are implemented in C and C++. ### 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. - -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: +During initial development, the Flutter team evaluated multiple languages +and runtimes before selecting Dart for the framework and widgets. +Dart scored highest across several key evaluation criteria: _Developer productivity_ -: 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 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? +: Dart supports both JIT (Just-in-Time) compilation for fast development + with stateful hot reload, and AOT (Ahead-of-Time) compilation + for efficient native machine code in production. + Because the framework is written in Dart, + developers can inspect, debug, and modify the entire stack. -Flutter can run Dart code that doesn't directly or -transitively import `dart:mirrors` or `dart:html`. +_Object orientation and UI composition_ +: Dart's object-oriented structure matches the requirements + of building composable user interfaces without requiring a separate markup language. -### Can Flutter compile Dart to JavaScript? - -Flutter compiles Dart to JavaScript with the -[`js.dart`][] package. +_Predictable, high performance_ +: Dart compiles directly to native machine code without an interpreter or bridge, + delivering consistent frame rates without unpredictable runtime pauses. -[`js.dart`]: {{site.dart-site}}/tools/dart-compile#js +_Fast memory allocation_ +: Flutter's reactive framework creates many short-lived objects. + Dart's generational garbage collector is optimized + for fast allocation and cleanup of ephemeral objects. -### How big is the Flutter engine? +### Can Flutter run any Dart code? -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. +Flutter can run any Dart code that does not depend on libraries +unavailable on the target platform. +For example, mobile and desktop apps cannot import web-specific libraries, +and web apps cannot use `dart:io`. -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). +### How does Flutter compile for the web? -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). +Flutter compiles Dart for the web to both JavaScript and WebAssembly (Wasm). +WebAssembly compilation (WasmGC) delivers high-performance rendering +comparable to native desktop and mobile apps. +For details, see the [Flutter web documentation][web]. -These numbers were measured using [apkanalyzer][], -which is also [built into Android Studio][]. +[web]: /platform-integration/web -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][]). +### How big is the Flutter engine? {:#how-big-is-the-flutter-engine} -Of course, we recommend that you measure your own app. -To do that, see [Measuring your app's size][]. +A minimal release Flutter application includes the Flutter engine, +the framework, and your application code. +The engine adds a small baseline footprint (a few megabytes compressed), +which varies by target platform and architecture. +App size is largely determined by bundled assets, fonts, +and third-party packages. +To analyze and minimize the size of your application, +see [Measuring your app's size][]. -[apkanalyzer]: {{site.android-dev}}/studio/command-line/apkanalyzer -[built into Android Studio]: {{site.android-dev}}/studio/build/apk-analyzer -[iOS App Store Specific Considerations]: {{site.apple-dev}}/library/archive/qa/qa1795/_index.html#//apple_ref/doc/uid/DTS40014195-CH1-APP_STORE_CONSIDERATIONS [Measuring your app's size]: /perf/app-size -[minimal Flutter app]: {{site.repo.flutter}}/tree/75228a59dacc24f617272f7759677e242bbf74ec/examples/hello_world -[QA1795]: {{site.apple-dev}}/library/archive/qa/qa1795/_index.html ### How does Flutter define a pixel? Flutter uses logical pixels, -and often refers to them merely as "pixels". -Flutter's [`devicePixelRatio`][] expresses the ratio -between physical pixels and logical CSS pixels. +which correspond roughly to physical pixels on a standard-density display. +Flutter automatically maps logical pixels to physical device pixels +based on the view's [`devicePixelRatio`][]. -[`devicePixelRatio`]: {{site.api}}/flutter/dart-html/Window/devicePixelRatio.html +[`devicePixelRatio`]: {{site.api}}/flutter/dart-ui/FlutterView/devicePixelRatio.html ## Capabilities ### What kind of app performance can I expect? -In general, you can expect excellent performance. Flutter is designed to help -developers easily achieve a constant 60fps. Flutter apps run using natively -compiled code, so no interpreters are involved. This means that Flutter apps -start quickly. - -Flutter's performance when using native code depends on your -[app's architecture][]. For optimal performance, familiarize yourself with Flutter's -[platform channels][]. These channels provide an asynchronous message-passing -system for communicating with native code. - -To learn more about performance and Flutter, see the [Performance FAQ][]. - -[platform channels]: /platform-integration/platform-channels -[app's architecture]: /app-architecture -[Performance FAQ]: /perf/faq +Flutter is designed to deliver smooth 60fps and 120fps animations. +Flutter apps compile directly to native machine code or WebAssembly, +eliminating interpreter overhead. +To learn more about performance optimization, see the [Performance FAQ][]. ### What kind of developer cycles can I expect? How long between edit and refresh? {:#hot-reload} -Flutter implements a _hot reload_ developer cycle. You can expect -sub-second reload times, on a device or an emulator/simulator. +Flutter implements a stateful _hot reload_ developer cycle. +You can expect sub-second reload times on physical devices, +emulators, and simulators. -Flutter's hot reload is _stateful_ so 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. +Hot reload preserves your application state, +allowing you to iterate rapidly without navigating back +to the current screen after every code change. -### How is _hot reload_ different from _hot restart_? +### 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. +Hot reload injects updated source code files into the running Dart VM +without clearing the application state. +Hot restart resets the application state and re-executes `main()`, +which takes slightly longer than hot reload but remains faster +than a full recompile. For more information, see [Hot reload][]. - [Hot reload]: /tools/hot-reload ### Where can I deploy my Flutter app? -You can compile and deploy your Flutter app to iOS, Android, -[web][], and [desktop][]. - +You can compile and deploy Flutter apps to iOS, Android, +[web][], [desktop][] (macOS, Windows, Linux), and embedded devices. [desktop]: /platform-integration/desktop -[web]: /platform-integration/web - -### 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][]. +### What devices and OS versions does Flutter run on? {:#what-devices-and-os-versions-does-flutter-run-on} -* Flutter supports building ahead-of-time (AOT) compiled libraries - for `x86-64`, `armeabi-v7a`, and `arm64-v8a`. +Flutter supports a broad range of operating systems and hardware platforms: -* Apps built for ARMv7 or ARM64 run fine (using ARM emulation) - on many x86-64 Android devices. +* Mobile: Android (ARM32, ARM64, x86_64) and iOS (ARM64). +* Desktop: macOS (x86_64, ARM64), Windows (x86_64, ARM64), and Linux (x86_64, ARM64). +* Web: Modern browsers supporting WebAssembly or JavaScript. -* We support developing Flutter apps on a range of platforms. - See the system requirements listed under each - [development operating system][install]. +For the complete list of supported OS versions, +see [Supported platforms][]. - -[install]: /install -[supported platforms]: /reference/supported-platforms +[Supported platforms]: /reference/supported-platforms ### Does Flutter run on the web? -Yes, web support is available in the stable channel. -For more details, check out the [web instructions][]. - -[web instructions]: /platform-integration/web/building +Yes. Flutter web support is available on the stable channel +and supports compilation to both WebAssembly (Wasm) and JavaScript. +For more details, see [Web support for Flutter][web]. ### Can I use Flutter to build desktop apps? -Yes, desktop support is in stable for Windows, -macOS, and Linux. +Yes. Desktop support is available on the stable channel +for macOS, Windows, and Linux. +For details, see [Desktop support for Flutter][desktop]. ### Can I use Flutter inside of my existing native app? -Yes, learn more in the [add-to-app][] section of our website. +Yes. You can integrate Flutter into existing Android and iOS applications +using [Add-to-App][add-to-app]. [add-to-app]: /add-to-app ### 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. +Yes. Flutter provides access to platform-specific APIs and hardware +through plugins available on [pub.dev][ready-made packages]. +You can also create custom integrations using [platform channels][] +or native interop (Dart FFI). -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. - - -[is easy]: /packages-and-plugins/using-packages -[platform and third-party APIs]: /platform-integration/platform-channels [ready-made packages]: {{site.pub}}/flutter/ ### Can I extend and customize the bundled widgets? -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. - -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. +Yes. Flutter's widget system is built around composition. +Instead of subclassing complex widgets, +you compose smaller, single-purpose widgets to create custom designs. +This architecture provides control over layout, painting, +and gesture handling. ### 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. - -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. +Sharing layout and UI code reduces engineering effort, +keeps feature releases synchronized, +and ensures a consistent brand experience across platforms. +When you want platform-specific behavior or styling, +you can adapt the UI using platform checks or responsive layouts. ### 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 Swift or Objective-C code on iOS. -This is enabled by 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][]. - -Here is an [example project][] that shows how to use a -platform channel to access battery state information on -iOS and Android. +Yes. Flutter supports calling native code on all supported platforms: +* On Android: Kotlin and Java via [platform channels][] and [JNI interop][] (`jnigen`). +* On iOS and macOS: Swift and Objective-C via [platform channels][] and [Objective-C/Swift interop][] (`ffigen`). +* On desktop and mobile: C and C++ via Dart FFI ([`dart:ffi`][]). -[`BasicMessageChannel`]: {{site.api}}/flutter/services/BasicMessageChannel-class.html -[example project]: {{site.repo.flutter}}/tree/main/examples/platform_channel -[platform channels]: /platform-integration/platform-channels +[JNI interop]: {{site.dart-site}}/interop/java-interop +[Objective-C/Swift interop]: {{site.dart-site}}/interop/objective-c-interop +[`dart:ffi`]: {{site.dart-site}}/interop/c-interop ### 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. - -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. +No. Dart disables `dart:mirrors` in Flutter to enable aggressive +ahead-of-time (AOT) compilation and dead-code elimination (tree shaking). +This keeps binary sizes small and startup times fast. +For metadata inspection and serialization, +Flutter applications use compile-time code generation. ### Are internationalization and localization supported? -Yes, Flutter supports internationalization (i18n) and localization (l10n) so -that your apps are adaptable to different languages and cultures. You can -learn more in the [internationalization documentation][]. +Yes. Flutter provides built-in internationalization (i18n) +and localization (l10n) support, +including pluralization, bidirectional text, and date formatting. +To learn more, see [Internationalizing Flutter apps][internationalization documentation]. [internationalization documentation]: /ui/internationalization ### What accessibility is supported? -Flutter supports strict accessibility requirements (a11y). For example, -screen readers, large text, color contrast, and hardware switch control are -all supported. To learn more, see the [accessibility documentation][]. +Flutter supports standard accessibility features (a11y), +including screen readers (TalkBack, VoiceOver), large text scaling, +high-contrast themes, and hardware switch access. +For details, see [Accessibility][accessibility documentation]. [accessibility documentation]: /ui/accessibility ### 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][]. +Dart uses an event loop for asynchronous operations (`Future` and `Stream`). +For CPU-intensive tasks, Flutter supports isolates—isolated execution +threads with independent memory heaps that communicate through message passing. +You can use [`Isolate.run()`][] or the [`compute()`][] function +to run heavy computations in the background. -[example of using isolates with Flutter]: {{site.repo.flutter}}/blob/main/examples/layers/services/isolate.dart +[`Isolate.run()`]: {{site.api}}/flutter/dart-isolate/Isolate/run.html +[`compute()`]: {{site.api}}/flutter/foundation/compute-constant.html ### Can I run Dart code in the background of a Flutter app? -Yes, you can run Dart code in a background process on both -iOS and Android. For more information, see the Flutter blog post -[Executing Dart in the Background with Flutter Plugins and Geofencing][backgnd]. - -[backgnd]: {{site.flutter-blog}}/executing-dart-in-the-background-with-flutter-plugins-and-geofencing-2b3e40a1a124 +Yes. You can execute Dart code in background processes on Android and iOS +using background execution packages and platform service integrations. -### Can I use JSON/XML/Protobufs (and so on) with Flutter? +### Can I use JSON, XML, or Protocol Buffers 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][]. +Yes. The Dart ecosystem provides packages on [pub.dev][] +for JSON serialization, XML parsing, Protocol Buffers, +and other data formats. +For details on working with JSON, see [JSON and serialization][JSON tutorial]. [JSON tutorial]: /data-and-backend/serialization/json [pub.dev]: {{site.pub}} -### Can I build 3D (OpenGL) apps with Flutter? +### Can I build 3D apps with Flutter? -Today we don't support 3D using OpenGL ES or similar. -We have long-term plans to expose an optimized 3D API, -but right now we're focused on 2D. +Yes. Flutter supports 3D graphics through Flutter GPU +and packages such as `flutter_scene`, +which use the Impeller rendering backend to draw 3D scenes. +You can also embed third-party 3D views (such as Unity or native 3D engines) +using platform views. ### Why is my APK or IPA so big? -Usually, assets including images, sound files, fonts, and so on, -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 -[release build of your Android app][], -and creating a [release build of your iOS app][]. -Also, check out [Measuring your app's size][]. - - -[release build of your Android app]: /deployment/android -[release build of your iOS app]: /deployment/ios - -### 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][]. - -[issues related to running Flutter on Chromebooks]: {{site.repo.flutter}}/labels/platform-arc +App bundle size includes the Flutter engine, framework code, +application logic, and bundled assets (such as images, fonts, and audio). +Always create a release build (`flutter build apk` or `flutter build appbundle` +for Android, and `flutter build ipa` for iOS), +which removes debug symbols and enables compiler optimizations. +To analyze and reduce app size, see [Measuring your app's size][]. ### Is Flutter ABI compatible? -Flutter and Dart don't offer application binary interface (ABI) -compatibility. Offering ABI compatibility is not a current -goal for Flutter or Dart. +Flutter and Dart do not provide application binary interface (ABI) +compatibility across different compiler releases. +Always compile your application using matching SDK versions. ### How does Flutter handle scrolling? -A custom scrolling implementation is used for each app platform so that -scrolling matches that platform's native scrolling look and feel. To learn -more about scrolling with Flutter, see the [scrolling][] documentation. +Flutter provides platform-specific scroll physics +that match the native scrolling behavior of each platform +(such as momentum scrolling on iOS and overscroll stretch on Android). +For more details, see the [scrolling][] documentation. [scrolling]: /ui/layout/scrolling @@ -819,383 +553,210 @@ more about scrolling with Flutter, see the [scrolling][] documentation. ### Why is the build() method on State, rather than StatefulWidget? -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 -[detailed discussion on the API docs for `State.build`][]. +Placing the `Widget build(BuildContext context)` method on `State` +rather than `StatefulWidget` provides greater flexibility +when subclassing `StatefulWidget` and managing lifecycle state. +For a detailed explanation, see the [API documentation for `State.build`][]. -[detailed discussion on the API docs for `State.build`]: {{site.api}}/flutter/widgets/State/build.html +[API documentation for `State.build`]: {{site.api}}/flutter/widgets/State/build.html ### 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" approach 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? +Flutter UIs are defined in Dart code rather than a declarative markup language. +Defining UI in code enables: -By default, the `flutter run` command uses the -debug build configuration. +* Fast development with stateful hot reload. +* Full access to programming language features (loops, conditionals, functions). +* Strong type safety and compiler checks. +* Easy refactoring and code reuse across widgets. -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). +Because build methods are standard code, +you can also create widgets dynamically from data or external configurations. -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`. +### My app has a Debug banner in the upper right. Why am I seeing that? -If your IDE uses the Flutter plugin, -you can launch the app in profile or release mode. -For VS Code, use the **Run > Start debugging** -or **Run > Run without debugging** menu entries. -For IntelliJ, use the menu entries -**Run > Flutter Run in Profile Mode** or **Release Mode**. +By default, `flutter run` launches the app in debug mode. +The debug build configuration runs code inside the Dart VM +to enable stateful [hot reload][], +and enables runtime assertions to catch errors early. +The "Debug" banner indicates that these checks are active. +To run without assertions and with optimized performance, +run the app in release mode using `flutter run --release` +or build a release binary. -[Android]: #run-android -[hot reload]: #hot-reload -[iOS]: #run-ios +### What programming paradigm does Flutter's framework use? {:#what-programming-paradigm-does-flutters-framework-use} -### 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: +Flutter uses a combination of programming paradigms, +applying each where it is most effective: **Composition** -: 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 +: The primary paradigm in Flutter is composing small, + single-purpose widgets into complex user interfaces. + For example, the Material [`TextButton`][] widget is composed of an [`IconTheme`][], an [`InkWell`][], a [`Padding`][], a [`Center`][], a [`Material`][], an [`AnimatedDefaultTextStyle`][], and a [`ConstrainedBox`][]. - 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. **Functional programming** -: Entire applications can be built with only - [`StatelessWidget`][]s, 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. +: Applications can define UI using [`StatelessWidget`][] instances, + which act as functions mapping configuration inputs to child widgets. + Flutter uses immutable data structures across its widget hierarchy, + including [`Widget`][], [`TextStyle`][], and [`Rect`][]. **Event-driven programming** : User interactions are represented by event objects - 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. + dispatched to callbacks registered on widgets. + Classes like [`Listenable`][] formalize event subscription models. **Class-based object-oriented programming** -: 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 framework APIs use inheritance to specialize behavior. + For example, [`RenderBox`][] extends [`RenderObject`][] + to establish a Cartesian coordinate system for 2D layout. **Prototype-based object-oriented programming** : The [`ScrollPhysics`][] class chains instances to compose - 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. + scrolling physics dynamically at runtime. **Imperative programming** -: 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. +: Imperative code manages encapsulated state and test execution, + where step-by-step logic is clearest. **Reactive programming** -: 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 - using 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). +: Constructor parameters propagate changes down the widget tree, + and user interactions trigger updates back up the tree through callbacks. + State changes schedule rebuilds of affected subtrees. **Declarative programming** -: 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. +: Widget `build` methods describe the desired UI state declaratively, + leaving layout and rendering updates to the framework. **Generic programming** -: 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 [`List`][]s, [`Map`][]s, - and [`Set`][]s are all parameterized so that mismatched - elements can be caught early either during analysis or at - runtime during debugging. +: Generic types enforce type safety across the framework, + such as parameterizing [`State`][] with its widget type + and [`GlobalKey`][] with its state type. **Concurrent programming** -: Flutter makes heavy use of [`Future`][]s 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. +: Flutter uses [`Future`][] and [`Stream`][] for asynchronous operations, + and isolates for parallel background computation. **Constraint programming** -: 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. - +: The layout system uses box constraints (minimum and maximum width and height) + passed down from parent to child to compute geometry in a single pass. [`AnimatedDefaultTextStyle`]: {{site.api}}/flutter/widgets/AnimatedDefaultTextStyle-class.html -[`AnimatedPhysicalModel`]: {{site.api}}/flutter/widgets/AnimatedPhysicalModel-class.html [`Center`]: {{site.api}}/flutter/widgets/Center-class.html -[`Chip`]: {{site.api}}/flutter/material/Chip-class.html -[`color`]: {{site.api}}/flutter/widgets/Icon/color.html [`ConstrainedBox`]: {{site.api}}/flutter/widgets/ConstrainedBox-class.html -[`Divider`]: {{site.api}}/flutter/material/Divider-class.html [`Future`]: {{site.api}}/flutter/dart-async/Future-class.html -[`GestureDetector`]: {{site.api}}/flutter/widgets/GestureDetector-class.html -[`GlobalKey`]: {{site.api}}/flutter/widgets/GlobalKey-class.html -[`icon`]: {{site.api}}/flutter/widgets/Icon/icon.html -[`Icon`]: {{site.api}}/flutter/widgets/Icon-class.html +[`GlobalKey`]: {{site.api}}/flutter/widgets/GlobalKey-class.html [`IconTheme`]: {{site.api}}/flutter/widgets/IconTheme-class.html [`InkWell`]: {{site.api}}/flutter/material/InkWell-class.html -[`Iterable`]: {{site.api}}/flutter/dart-core/Iterable-class.html -[`List`]: {{site.api}}/flutter/dart-core/List-class.html [`Listenable`]: {{site.api}}/flutter/foundation/Listenable-class.html -[`Map`]: {{site.api}}/flutter/dart-core/Map-class.html [`Material`]: {{site.api}}/flutter/material/Material-class.html -[`NotificationListener`]: {{site.api}}/flutter/widgets/NotificationListener-class.html [`Padding`]: {{site.api}}/flutter/widgets/Padding-class.html -[popped]: {{site.api}}/flutter/widgets/Navigator/pop.html [`Rect`]: {{site.api}}/flutter/dart-ui/Rect-class.html [`RenderBox`]: {{site.api}}/flutter/rendering/RenderBox-class.html [`RenderObject`]: {{site.api}}/flutter/rendering/RenderObject-class.html -[`Route`]: {{site.api}}/flutter/widgets/Route-class.html [`ScrollPhysics`]: {{site.api}}/flutter/widgets/ScrollPhysics-class.html -[`Set`]: {{site.api}}/flutter/dart-core/Set-class.html -[`size`]: {{site.api}}/flutter/widgets/Icon/size.html -[`State`]: {{site.api}}/flutter/widgets/State-class.html +[`State`]: {{site.api}}/flutter/widgets/State-class.html [`StatelessWidget`]: {{site.api}}/flutter/widgets/StatelessWidget-class.html +[`Stream`]: {{site.api}}/flutter/dart-async/Stream-class.html [`TextButton`]: {{site.api}}/flutter/material/TextButton-class.html [`TextStyle`]: {{site.api}}/flutter/painting/TextStyle-class.html -[`UserAccountsDrawerHeader`]: {{site.api}}/flutter/material/UserAccountsDrawerHeader-class.html [`Widget`]: {{site.api}}/flutter/widgets/Widget-class.html ## 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 -[flutter-dev@googlegroups.com][] or seek us out on [Discord][]. +To report bugs or request features, file an issue in the +[Flutter issue tracker][issue tracker]. -For more information, see our [Community][] page. +For community discussion, troubleshooting, and advice: +* Join the [Flutter Discord][Discord]. +* Ask questions on [Stack Overflow][] using the `flutter` tag. +* Participate in discussions on [Reddit r/FlutterDev][Reddit]. +* Visit the [Community][] page for additional resources. [Community]: {{site.main-url}}/community [Discord]: https://discord.com/invite/rflutterdev [issue tracker]: {{site.repo.flutter}}/issues -[flutter-dev@googlegroups.com]: mailto:flutter-dev@googlegroups.com +[Reddit]: https://www.reddit.com/r/FlutterDev/ [Stack Overflow]: {{site.so}}/tags/flutter ### 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 -[flutter-dev@googlegroups.com][] 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 the [Community][] page. +Flutter is open source, and contributions are welcome. +You can help by: -You can also engage with other developers on the Flutter -[Discord][]. +* Reporting bugs and feature requests on the [issue tracker][]. +* Contributing code and documentation by following the [Contributing guide][]. +* Triaging issues or helping other developers on [Discord][] and [Stack Overflow][]. [Contributing guide]: {{site.repo.flutter}}/blob/main/CONTRIBUTING.md -[easy starter issues]: {{site.repo.flutter}}/issues?q=is%3Aopen+is%3Aissue+label%3A%22easy+fix%22 ### Is Flutter open source? -Yes, Flutter is open source technology. -You can find the project on [GitHub][]. +Yes. Flutter is open source and available under the +BSD 3-Clause License on [GitHub][]. [GitHub]: {{site.repo.flutter}} ### 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][]. +Flutter includes two main components: +the engine (compiled binary with dependencies) +and the framework (Dart source code). -The framework is entirely self-contained and requires -[only one license][]. - -In addition, any Dart packages you use might have their -own license requirements. +* The framework is licensed under the [BSD 3-Clause License][only one license]. +* The engine uses open source dependencies listed in its [license file][]. +* Dart packages on pub.dev specify their own individual licenses. [license file]: {{site.repo.flutter}}/blob/main/engine/src/flutter/sky/packages/sky_engine/LICENSE [only one license]: {{site.repo.flutter}}/blob/main/LICENSE ### 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`][]. +Flutter provides built-in APIs to display open source licenses: -* If your application doesn't have a Drawer but does use the - Material Components library, call either [`showAboutDialog`][] +* If your application uses a `Drawer`, add an [`AboutListTile`][]. +* If your application uses Material Design, call [`showAboutDialog`][] or [`showLicensePage`][]. - -* For a more custom approach, you can get the raw licenses from the - [`LicenseRegistry`][]. - +* For custom presentations, access the raw licenses from the [`LicenseRegistry`][]. [`AboutListTile`]: {{site.api}}/flutter/material/AboutListTile-class.html -[`Drawer`]: {{site.api}}/flutter/material/Drawer-class.html [`LicenseRegistry`]: {{site.api}}/flutter/foundation/LicenseRegistry-class.html [`showAboutDialog`]: {{site.api}}/flutter/material/showAboutDialog.html [`showLicensePage`]: {{site.api}}/flutter/material/showLicensePage.html ### 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][]! +Flutter is developed by engineers at Google along with +hundreds of open source contributors worldwide. +To join the community, see [contribute to Flutter][]. -[contribute to Flutter]: {{site.repo.flutter}}/blob/master/CONTRIBUTING.md +[contribute to Flutter]: {{site.repo.flutter}}/blob/main/CONTRIBUTING.md ### 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: +Flutter is built around three core principles: _Control_ -: Developers deserve access to, and control over, - all layers of the system. Which leads to: +: Developers have full access to and control over every layer of the system. _Performance_ -: Users deserve perfectly fluid, responsive, - jank-free apps. Which leads to: - -_Fidelity_: -: 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. +: Applications deliver smooth, responsive, jank-free experiences. -Apple has frequently featured well-designed apps -that are built with Flutter, -including [Hamilton][Hamilton for iOS] and [Reflectly][]. +_Fidelity_ +: Applications achieve pixel-perfect, beautiful user experiences on every platform. -As with any app submitted to the Apple store, -apps built with Flutter should follow Apple's -[guidelines][] for App Store submission. +### Will Apple or Google reject my Flutter app? +No. Thousands of Flutter apps are published, approved, and featured +in the Apple App Store and Google Play Store. +As with any application, ensure your app complies with +Apple's [App Store Review Guidelines][guidelines] +and Google Play's Developer Program Policies. [guidelines]: {{site.apple-dev}}/app-store/review/guidelines/ -[Hamilton for iOS]: https://itunes.apple.com/us/app/hamilton-the-official-app/id1255231054?mt=8 -[Reflectly]: https://apps.apple.com/us/app/reflectly-journal-ai-diary/id1241229134 From e98f9e764b9618258f288f1800e33b44ee4f78ed Mon Sep 17 00:00:00 2001 From: "Shams Zakhour (ignore Sfshaza)" Date: Tue, 18 Aug 2026 16:06:05 -0700 Subject: [PATCH 2/2] Applied more bot suggestions --- sites/docs/src/content/resources/faq.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sites/docs/src/content/resources/faq.md b/sites/docs/src/content/resources/faq.md index 8066ee637c..d66b23b48e 100644 --- a/sites/docs/src/content/resources/faq.md +++ b/sites/docs/src/content/resources/faq.md @@ -633,8 +633,8 @@ applying each where it is most effective: **Generic programming** : Generic types enforce type safety across the framework, - such as parameterizing [`State`][] with its widget type - and [`GlobalKey`][] with its state type. + such as parameterizing [`State`][]`` with its widget type + and [`GlobalKey`][]`` with its state type. **Concurrent programming** : Flutter uses [`Future`][] and [`Stream`][] for asynchronous operations, @@ -648,7 +648,7 @@ applying each where it is most effective: [`Center`]: {{site.api}}/flutter/widgets/Center-class.html [`ConstrainedBox`]: {{site.api}}/flutter/widgets/ConstrainedBox-class.html [`Future`]: {{site.api}}/flutter/dart-async/Future-class.html -[`GlobalKey`]: {{site.api}}/flutter/widgets/GlobalKey-class.html +[`GlobalKey`]: {{site.api}}/flutter/widgets/GlobalKey-class.html [`IconTheme`]: {{site.api}}/flutter/widgets/IconTheme-class.html [`InkWell`]: {{site.api}}/flutter/material/InkWell-class.html [`Listenable`]: {{site.api}}/flutter/foundation/Listenable-class.html @@ -658,7 +658,7 @@ applying each where it is most effective: [`RenderBox`]: {{site.api}}/flutter/rendering/RenderBox-class.html [`RenderObject`]: {{site.api}}/flutter/rendering/RenderObject-class.html [`ScrollPhysics`]: {{site.api}}/flutter/widgets/ScrollPhysics-class.html -[`State`]: {{site.api}}/flutter/widgets/State-class.html +[`State`]: {{site.api}}/flutter/widgets/State-class.html [`StatelessWidget`]: {{site.api}}/flutter/widgets/StatelessWidget-class.html [`Stream`]: {{site.api}}/flutter/dart-async/Stream-class.html [`TextButton`]: {{site.api}}/flutter/material/TextButton-class.html