-
### Integrate with the web {:#web}
diff --git a/sites/docs/src/content/platform-integration/ios/ios-latest.md b/sites/docs/src/content/platform-integration/ios/ios-latest.md
deleted file mode 100644
index 94a9f9cd00..0000000000
--- a/sites/docs/src/content/platform-integration/ios/ios-latest.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Flutter on latest iOS
-description: >-
- Learn about Flutter's support for and compatibility with
- the latest releases of iOS.
----
-
-Flutter supports iOS 26.
-
-For information on the status of specific iOS features
-that Flutter hasn't yet fully implemented,
-visit the following issues in the flutter/flutter repo.
-
-* Flutter support for liquid glass: [Issue 170310][]
-* Eye tracking of a Flutter app: [Issue 153573][]
-* Hover typing feature: [Issue 152715][]
-* iOS formatting menu: [Issue 150068][]
-* iOS-style zoom page transition: [Issue 150588][]
-* iPad-style tab bar: [Issue 150590][]
-* iPhone mirroring when viewing a Flutter app: [Issue 152711][]
-* Large content viewer: [Issue 152715][]
-* Add "Translate" button to the context edit menu: [Issue 150392][]
-* Virtual trackpad feature: [Issue 152715][]
-* Writing tools text input feature: [Issue 150965][], [Issue 150452][]
-
-[Issue 150068]: {{site.repo.flutter}}/issues/150068
-[Issue 150392]: {{site.repo.flutter}}/issues/150392
-[Issue 150452]: {{site.repo.flutter}}/issues/150452
-[Issue 150588]: {{site.repo.flutter}}/issues/150588
-[Issue 150590]: {{site.repo.flutter}}/issues/150590
-[Issue 150965]: {{site.repo.flutter}}/issues/150965
-[Issue 152711]: {{site.repo.flutter}}/issues/152711
-[Issue 152715]: {{site.repo.flutter}}/issues/152715
-[Issue 153573]: {{site.repo.flutter}}/issues/153573
-[Issue 170310]: {{site.repo.flutter}}/issues/170310
diff --git a/sites/docs/src/content/platform-integration/ios/setup.md b/sites/docs/src/content/platform-integration/ios/setup.md
index 1fdd490116..211024297b 100644
--- a/sites/docs/src/content/platform-integration/ios/setup.md
+++ b/sites/docs/src/content/platform-integration/ios/setup.md
@@ -95,23 +95,19 @@ an iOS physical device or on the iOS Simulator.
## Set up an iOS device {: #set-up-devices}
-We recommend starting with the iOS Simulator as
-it's easier to get set up than a physical iOS device.
-However, you should also test your app on an actual
-physical device.
+It's easiest to first set up the simulator,
+but be sure to also test your app on a physical device.
-To start the simulator, run the command for your Xcode version.
-
-If you're using Xcode 27 or later, start the Device Hub app:
+Start the simulator (renamed to Device Hub on Xcode 27):
```console
$ open -a DeviceHub
```
-If you're using Xcode 26 or earlier, start the Simulator app:
+On Xcode 26 or earlier, start the Simulator app:
```console
$ open -a Simulator
@@ -126,8 +122,6 @@ on the Apple Developer site.
-[Flutter on latest iOS]: /platform-integration/ios/ios-latest
-
Set up each iOS device on which you want to test.
1.
Configure your physical iOS device
diff --git a/sites/docs/src/content/platform-integration/macos/building.md b/sites/docs/src/content/platform-integration/macos/building.md
index 385c16c997..2b5d1b764c 100644
--- a/sites/docs/src/content/platform-integration/macos/building.md
+++ b/sites/docs/src/content/platform-integration/macos/building.md
@@ -33,6 +33,15 @@ pop-up buttons, and modal dialogs.
## Building macOS apps
+:::warning macOS Intel (x64) deprecation
+As Apple phases out Intel-based Macs,
+Flutter is phasing out support for Intel (x64) hardware.
+For details on the timeline and impact,
+refer to the [macOS Intel deprecation strategy][].
+
+[macOS Intel deprecation strategy]: {{site.main-url}}/go/macos-intel-deprecation
+:::
+
To distribute your macOS application, you can either
[distribute it through the macOS App Store][],
or you can distribute the `.app` itself,
diff --git a/sites/docs/src/content/reference/supported-platforms.md b/sites/docs/src/content/reference/supported-platforms.md
index f9d1e3c3c9..1198191e33 100644
--- a/sites/docs/src/content/reference/supported-platforms.md
+++ b/sites/docs/src/content/reference/supported-platforms.md
@@ -35,7 +35,7 @@ Flutter supports deploying to the following platforms.
name="iOS"
icon="mobile"
arch="Arm64"
- supported="15 to 26"
+ supported="15 to 27"
ci-tested="18 and 26"
unsupported="14 and earlier"
deploy-to-link="/deployment/ios"
@@ -48,14 +48,9 @@ Flutter supports deploying to the following platforms.
As Apple phases out Intel-based Macs,
Flutter is phasing out support for Intel (x64) hardware.
For details on the timeline and impact,
-check out the [macOS Intel deprecation strategy][].
-
-If you can't migrate to an [Apple Silicon Mac][],
-you can continue using older Flutter releases from the [SDK archive][].
+refer to the [macOS Intel deprecation strategy][].
[macOS Intel deprecation strategy]: {{site.main-url}}/go/macos-intel-deprecation
-[Apple Silicon Mac]: https://support.apple.com/en-us/116943
-[SDK archive]: /install/archive
:::
@@ -72,7 +67,7 @@ you can continue using older Flutter releases from the [SDK archive][].
name="macOS"
icon="laptop_mac"
arch="x64, Arm64"
- supported="Monterey (12) to Tahoe (26)"
+ supported="Monterey (12) to Golden Gate (27)"
ci-tested="Sequoia (15)"
unsupported="Big Sur (11) and earlier"
deploy-to-link="/deployment/macos"
diff --git a/sites/docs/src/content/release/breaking-changes/uiscenedelegate.md b/sites/docs/src/content/release/breaking-changes/uiscenedelegate.md
index e57ef86a33..d4c99a9bb3 100644
--- a/sites/docs/src/content/release/breaking-changes/uiscenedelegate.md
+++ b/sites/docs/src/content/release/breaking-changes/uiscenedelegate.md
@@ -13,6 +13,17 @@ As of the Flutter 3.41 release,
eligible apps are migrated automatically.
:::
+:::version-note
+Beginning with Xcode 27 (iOS 27 SDK), Apple mandates the `UIScene`
+lifecycle for UIKit apps. Flutter apps built with Xcode 27 that
+do not adopt `UIScene` fail to launch on startup.
+
+In Flutter 3.41 and later, if your project uses an unmodified `AppDelegate`,
+Flutter migrates it automatically. If your project uses a custom `AppDelegate`
+or a Flutter version earlier than 3.41, complete the following manual
+migration steps.
+:::
+
## Summary
Apple now requires iOS developers to adopt the `UIScene` lifecycle.
@@ -1088,10 +1099,8 @@ When you're ready to re-enable `UIScene` support, remove the underscore.
Landed in version: 3.38.0-0.1.pre
In stable release: 3.38
-Apple hasn't yet announced when it will enforce the `UIScene` requirement.
-Once Apple changes its warning to an assertion,
-Flutter apps that haven't adopted the `UIScene` lifecycle will
-crash on startup when built with the latest SDK.
+Flutter apps that haven't adopted the `UIScene` lifecycle
+will crash on startup when built with Xcode 27 (iOS 27 SDK).
## References
diff --git a/sites/docs/src/content/resources/faq.md b/sites/docs/src/content/resources/faq.md
index 4b66150dc2..2aa5aac04e 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 doesn't rely on web browser views
+or system-provided platform widgets.
+Instead, Flutter renders its UI using its own high-performance
+rendering engine ([Impeller][]).
+
+In addition, Flutter implements most of its framework
+(including compositing, gestures, animation, and widgets) in [Dart][].
+This architecture gives you deep control over the UI,
+high predictability, and the ability to inspect or modify
+the framework at any level.
[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 doesn't require an opinionated dependency injection framework.
+The Flutter ecosystem offers several packages for dependency injection
+and service location, such as [Riverpod][], [get_it][],
+[Provider][], and [injectable][].
[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 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 don't 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 doesn't 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 doesn't depend on libraries
+unavailable on the target platform.
+For example, mobile and desktop apps can't import web-specific libraries,
+and web apps can't use `dart:io`.
-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.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 don't 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
diff --git a/sites/docs/src/data/sidenav/default.yml b/sites/docs/src/data/sidenav/default.yml
index 31cec95cd1..ad5decd077 100644
--- a/sites/docs/src/data/sidenav/default.yml
+++ b/sites/docs/src/data/sidenav/default.yml
@@ -401,8 +401,6 @@
children:
- title: Set up iOS development
permalink: /platform-integration/ios/setup
- - title: Flutter on latest iOS
- permalink: /platform-integration/ios/ios-latest
- title: Leverage Apple's system libraries
permalink: /platform-integration/ios/apple-frameworks
- title: Add a launch screen