Flutter 3.50 and Dart 3.14 Ship Faster iOS Touch, Stable Native Interop, and Wasm on Safari and Firefox
Flutter 3.50 & Dart 3.14 are fresh off the press.
The official blog gave this version the subtitle "Investing in Flutter's next decade," which is quite ambitious. But after going through the updates, my feeling is closer to a big cleanup: a lot of baggage is being thrown off.
- The SDK's Material and Cupertino libraries are officially deprecated, and the standalone packages
material_uiandcupertino_uiare finally firmly on the throne. - iOS brings a number of optimizations, such as touch response optimization that is a full frame faster (16 ms faster on 60 Hz iOS devices, 8 ms faster on devices with 120 Hz ProMotion displays). Android release builds now block the high-risk vulnerability of external Intent startup parameter injection. Platform Views support for Hybrid Composition++ is extended, and optional support for the new Android Gradle Plugin 9 DSL is added.
material_ui and cupertino_ui take the throne
In 3.47, material_ui and cupertino_ui reached 1.0, which meant they were bound to take the throne sooner or later. 3.50 delivers: package:flutter/material.dart and package:flutter/cupertino.dart, along with the corresponding delegates in flutter_localizations, are all marked as deprecated. Now new projects created with flutter create import package:material_ui by default.
Migrating an existing project takes one command:
dart fix --apply --code=migrate_design_widgets
It adds dependencies to pubspec.yaml, changes the old import paths, and updates localization-related configuration as well.
Deprecation is not deletion. The old syntax can still compile today; you don't need to change it right away. But third-party libraries will gradually switch over, and the longer you wait, the uglier it gets with a mix of old and new in your project. It's easier to run it once on an afternoon when you're not chasing a release.
One thing to note: Flutter on HarmonyOS hasn't adapted to
material_uiyet. If your project needs to run on HarmonyOS, don't migrate yet.
iOS: Change nothing, touch is one frame faster
This is the most practical change in this version, in my opinion.
The engine rearranged the timing for producing frames after touch events. Touch events are now handed to the framework immediately, and the frame is rendered within the same refresh cycle, without waiting for the next vsync. That works out to 16ms faster on 60Hz devices and 8ms faster on 120Hz ProMotion displays. The official testing went all the way back to the iPhone 6s from 2015.
Why did it have to wait a frame before? Early iOS touch events were dispatched on the platform thread, and the CADisplayLink driving rendering was on another thread. To smooth out cross-thread jitter, the engine interposed several layers of buffering. Later, the threads were merged, and those buffers became pure historical baggage. This time, community contributor Matej Knopp cleaned them all out. The official announcement says they'll continue to reduce input latency on iOS.
3.50 is also the first stable release after Xcode 27 and iOS 27, and several annoying problems are fixed together:
- Newly paired or freshly upgraded iPhones no longer require opening Xcode once before they can run; the old white-screen hang is gone.
- The occasional startup crash of
flutter runon iOS 27 devices is fixed. - With Xcode 27 builds,
flutter screenshotworks on real devices again; that feature has been broken since iOS 17.
There are also two timing notes. CocoaPods trunk becomes read-only in December this year. Starting with 3.50, as long as you have Swift Package Manager turned off, you'll get a warning every time you run a Flutter command. Those who turned off SPM to work around build issues can try turning it back on. Also, Flutter no longer runs tests on Intel Macs; building on an Intel Mac will show a warning, and full removal of support is only a matter of time.
Android: One security patch, one unavoidable migration
First, security. Previously, Flutter-built Android packages would accept runtime configuration from any app on the device via Intent extras. The release build in 3.50 blocks that path: route, dart_entrypoint, and cached_engine_id from external Intents are all ignored, and engine parameters like --dart-flags are rejected outright. Normal deep links are unaffected. If your business happens to rely on specifying an entry point or route from an external Intent, be sure to test before upgrading.
Hybrid Composition++ (HCPP) continues to be polished in this version. It hands off the composition of native views to the Android system itself, targeting the tearing when maps and WebViews are embedded in scrolling lists, and various input field glitches. Currently it's enabled by default in the beta channel, but on stable you still need to enable it manually:
flutter config --enable-hcpp
It requires Android 14+ and Impeller running on Vulkan. Devices that don't meet the requirements automatically fall back to the old scheme, so enabling it carries no risk.
Plugin authors should note Built-in Kotlin. Plugins that still manually apply the Kotlin Gradle Plugin will lose points on pub.dev, and will fail to compile outright starting with AGP 10. The official team has already migrated all first-party plugins in flutter/packages. Once all plugins in your project support it, you can switch to the new DSL in AGP 9.
The default template values for new projects have also risen: AGP 9.3.1, Gradle 9.5.0, KGP 2.4.20, Java minimum 17, compileSdk and targetSdk 36, minSdk 24.
Native interop becomes stable
The pie-in-the-sky promise from last year — calling native APIs directly without going through the platform channel — reaches stable in this version: Objective-C via FFIgen, Java and Kotlin via JNIgen.
The benefits are concrete. No serialization, no string-based method names, synchronous calls, and calls from background isolates. When the system ships new APIs, you generate a binding and use it, without waiting for a plugin to update.
Pigeon also has a new native interop mode, which is based on these two generators under the hood. However, the official wording is "preview," so whether to use it in production is your call.
Web: Safari and Firefox can run Wasm too
Previously only Chrome and Edge ran WebAssembly by default. In 3.50, Safari 26.2+ (including iOS) and Firefox 147+ also support it. The official data says that in widget-heavy scenarios, frame rates are more than twice those of JS. For now it still requires manually adding to the allowlist in web/flutter_bootstrap.js:
{{flutter_js}}
{{flutter_build_config}}
_flutter.loader.load({
config: {
wasmAllowList: { blink: true, webkit: true, gecko: true },
},
});
Then run flutter build web --wasm, and older browsers will automatically fall back to JS.
Anyone who has done Flutter Web releases knows the pain of "users running old JS after you ship a new version." Now there's an official solution: add --web-content-hash at build time, and the filenames of JS, Wasm, and assets will all carry a content hash. Those files can be safely cached for a year; only index.html and flutter_bootstrap.js need to stay no-cache.
There's also an experimental WebParagraph, done with the Chrome team, that lets the browser handle text layout itself. CanvasKit no longer needs to bundle a full font parser, reducing its size from about 5.46 MB to 3.75 MB, and it no longer needs to download fallback fonts over the network. Those tofu blocks that flash on Chinese pages may finally disappear.
By the way, dart:html, dart:js, dart:js_util, and package:js are all deprecated. To find out if your project still has dependencies using them, add --no-deprecated-js-interop when building; it will fail if there are any.
A few handy things in the Framework
Many of these come from community contributions, and none are big, but they're all places you'd curse halfway through writing code.
SliverClipRect and SliverClipRRect. Previously, to add rounded corners to a section of content in a CustomScrollView, ClipRRect couldn't wrap a sliver at all. Now there are dedicated components, and you can control how content is clipped when it scrolls under a pinned header via clipOverlap:
SliverClipRRect(
borderRadius: BorderRadius.circular(16),
clipOverlap: ClipOverlapBehavior.preserveShape,
sliver: SliverList.builder(
itemCount: 20,
itemBuilder: (context, i) => ListTile(title: Text('Item $i')),
),
)
The others:
ListView.separatedsupportsitemExtentBuilder, so long lists with dividers can also compute heights on demand.ScrollPhysics.shouldUpdatehas changed parameters; custom scroll physics no longer need to rebuild the whole list by switching keys.showDialoghas a newbarrierBuilderfor frosted-glass masks without hand-rolling a route.TextInputType.numberWithOptionshas apasswordoption, so PIN entry on Android can bring up a secure numeric keyboard.- Android now supports
AutofillHints.emailOTPCodefor auto-filling email verification codes. DecorationImagesupportsplaceholder, so the container background isn't blank while loading.MediaQueryData.reduceMotioncan read the system's "reduce motion" setting.
Some old bugs are also wrapped up: ensureVisible no longer rolls the target under a pinned header, and dragging to select text in a PageView no longer accidentally flips pages.
Routing and dialogs
Two routing changes deserve separate mention.
One is showDialog gaining barrierBuilder. Previously the mask could only change barrierColor; for a frosted glass background you had to write your own RawDialogRoute or PageRouteBuilder. Now a single callback suffices:
dart
showDialog<void>(
context: context,
barrierBuilder: (context, animation, secondaryAnimation, child) {
return FadeTransition(
opacity: animation,
child: BackdropFilter(
filter: ImageFilter.blur(sigmaX: 8, sigmaY: 8),
child: child,
),
);
},
builder: (context) => const AlertDialog(title: Text('提示')),
);
The child in the callback is the default mask, and the tap-to-close behavior is still there; you just wrap it.
The other is Navigator.popUntilWithResult. A common need in multi-step flows: push from A all the way to D, then when D finishes, return directly to A while carrying a result back. popUntil can't return a value. This issue was filed back in 2019, and over the years people have worked around it with global variables, EventBus, or manually popping in a loop. Now you can write:
// A page
final result = await Navigator.pushNamed<OrderResult>(context, '/step1');
// D page
Navigator.popUntilWithResult<OrderResult>(
context,
ModalRoute.withName('/cart'),
OrderResult(success: true),
);
The official blog emphasizes: even if the target route has its own local history, the result is delivered correctly.
There are also several keyboard and accessibility changes related to navigation:
- Pressing Esc first closes an open
Tooltip, and focus doesn't wander, matching Web accessibility standards. FocusableActionDetectorhas a newskipTraversal, so custom interactive components can opt out of Tab traversal.- On Web, VoiceOver and
WidgetsApp.routerfocus issues are fixed; focus in overlays no longer resets unexpectedly. MediaQueryData.reduceMotioncan read the system's "reduce motion" setting, so page transitions can switch from sliding to fading accordingly.- Custom sliders can use
SemanticsRole.slider, and screen readers will correctly announce values.
Rendering and desktop
Impeller's SDF renderer on desktop now takes over lines, thin borders, rounded corners, and gradients, computing these shapes directly on the GPU. Cards and shadow-heavy pages benefit the most.
On Android, the fixes target specific device issues: crashes when loading textures on some Mali GPUs are fixed, and PowerVR B-series automatically falls back from Vulkan to OpenGL. If you have crash logs from such devices, it's worth upgrading and looking at the data.
Windows has one change very friendly to developers in China: paths with non-ASCII characters can now load resources correctly. Users with Chinese usernames will finally be able to open applications that wouldn't start before. Additionally, Windows now requests OpenGL ES 3 by default, and text contrast has been adjusted for better clarity.
The multi-window API remains experimental, with ongoing collaboration with Canonical. On Linux, you can draw your own title bar and make transparent windows. The API has also been renamed: RegularWindow becomes Window, and sizedToContent becomes shrinkWrap.
Desktop: a lot of changes in this version
Desktop has always been a weak presence in Flutter, and 3.50 brings more than usual. Let's go platform by platform.
Windows
The most useful change for domestic developers: paths with non-ASCII characters can now load resources and files correctly. The old problem of users with Chinese usernames unable to launch apps after installation ends here.
There are three rendering changes. The engine now requests OpenGL ES 3 by default, with old machines automatically falling back to ES 2, so compatibility isn't a concern. One full-screen copy is saved per frame, reducing GPU usage. Text contrast is improved; the previous issue of blurry, thin text after switching to the new rendering pipeline is better.
macOS
Windows and dialogs can now calculate their size based on content before being shown. The old flicker where a tool window or settings dialog would pop up at the default size and then jump is gone.
Impeller on macOS is also faster for gradients and repeated text shadows.
Additionally, Xcode 27 no longer requires macOS apps to include an Intel architecture. If you want to build only for Apple Silicon, you can now:
bash
flutter config --enable-macos-arm64-only
The official announcement says future versions will make this the default.
Linux
WindowControllerLinux opens up a set of low-level capabilities: turning off the system title bar and borders, making the window background transparent, and handing dragging and resizing back to the window manager. This means custom title bars and irregular transparent windows no longer require third-party plugins.
Common to all three platforms
Impeller's SDF renderer now takes over lines, thin borders, rounded corners, and gradients, computing these shapes directly on the GPU instead of generating geometry on the CPU. Interfaces with lots of cards, borders, and shadows benefit the most. Aliasing on overlapping UI and custom shapes on Windows and Linux is also improved.
The multi-window API is still experimental, pushed forward with Canonical. There are three changes, and anyone who's used it needs to change code:
RegularWindowis renamed toWindowsizedToContentis renamed toshrinkWrap, aligning with the naming in Flutter layoutWindowManageris moved aboveWidgetsApp, so secondary windows can have their own UI and navigation state, independent from the main window's tree
A small detail: RawScrollbar.mouseCursor now only changes the cursor when the mouse is over the thumb and track, rather than anywhere near the scrollbar.
Toolchain
Dart 3.14 brings a new command dart migrate to handle breaking changes during upgrades; you can preview what will change with --dry-run.
The Analysis Server's cold-start rename in multi-package workspaces is faster. The official team tested with the DevTools repository, dropping from 2.0 seconds to 0.9 seconds.
On the AI front, the official agent plugin now has a rule: after changing code under lib/, it will automatically trigger hot reload via MCP. Package authors can also put agent skills in the package's skills/ directory and ship them with the package; users can install them with dart run skills@ get.
Should you upgrade
My opinion is that it's worth upgrading, especially for projects with a high proportion of iOS users — that one frame of touch latency is free.
Before upgrading, check these items:
- Does Android depend on external Intents for passing route or entry point parameters?
IgnorePointerandAbsorbPointer'signoringSemanticshas been removed; if you still use it, it won't compile.- Text with soft hyphens now displays hyphens at line breaks.
- On mobile browsers with
viewport-fit=cover,SafeAreabehavior changes. - If the iOS project has SPM disabled, try enabling it to see if it passes.
The material_ui migration doesn't have to be done together with the upgrade. Upgrade the SDK first, run it stable, then migrate.
New versions definitely have bugs; waiting for one or two hotfixes before going to production isn't shameful.
References
- Flutter official blog: What's new in Flutter 3.50 (flutter.dev/blog/whats-new-in-flutter-3-50)