What’s new in Flutter 3.5, Dart 3.14, and Google’s on-device AI stack
Flutter and Dart just shipped one of their biggest updates yet. Flutter 3.5 and Dart 3.14 focus on three big themes: a smoother developer experience, deeper platform and desktop support, and a powerful on-device AI stack that runs the same tech Google uses in its own apps.
Dart 3.14: faster tooling and easier migrations
Dart 3.14 is all about making your day-to-day workflow faster and less painful, especially on larger codebases and package ecosystems.
Dart migrate: upgrading packages with less friction
Dart migrate is a new tool that helps you modernize your packages and apps with fewer manual edits.
It can:
- Automatically bump your SDK constraints in
pubspec.yaml - Apply consistent code style migrations
- Run cleanup fixes so your codebase matches current Dart best practices
This is especially helpful if you maintain multiple packages and want to keep them aligned with the latest Dart and Flutter releases without hand-editing every project.
Analyzer and IDE performance improvements
The Dart analyzer gets notable performance wins in this release:
- Faster file discovery and project startup
- Quicker “find references” and symbol lookups
- Better support for features like document color previews
The result: large Flutter and Dart projects feel snappier in your IDE and for any AI coding assistant hooked into the analyzer.
New client-side DartPad with pub support
A new client-side DartPad is rolling out as a preview. The compiler and analyzer now run entirely in your browser via WebAssembly, so every run doesn’t need a round trip to a server.
Key upgrade: DartPad now has pub package support, making it much easier to experiment with Flutter and Dart packages right in the browser.
Flutter 3.5: stable native interop and a cleaner framework
Flutter 3.5 continues to push Flutter beyond mobile, with stable native interop, a refactored design system story, and better tooling for desktop, iOS, Android, and the web.
Native interop is now stable
Dart native interop is officially stable. You can now call platform APIs directly with full type safety, without waiting for third-party plugins to catch up.
Highlights:
- Production-ready toolchain for talking to native APIs via FFI
- Tree-shaking of unused native bindings using the
record_usepackage, shrinking binary sizes - Deep dives available for tools like Pigeon,
ffigen, andjni
Pigeon + JNI/ObjC: high-performance plugins
A new backend for Pigeon lets you generate direct JNI/Objective‑C bindings instead of going through method channels for every call.
What this gives you:
- Compile-time type safety from a single Dart contract
- Native-speed calls with less serialization overhead
- Cleaner, more maintainable plugin code
The example shown is an Android permissions plugin built with Pigeon’s JNI backend: from Dart it looks like a normal method call, but under the hood it’s jumping straight into Android APIs.
Material and Cupertino decoupled into standalone packages
Flutter is officially deprecating the bundled Material and Cupertino libraries in favor of standalone packages:
material_uicupertino_ui
This decoupling means UI libraries can ship updates independently of the core framework. Upgrading should be mostly automatic:
- Run
dart fixto add the new packages - Imports are rewritten for you
This also sets the stage for teams building their own design systems, instead of being locked to Google’s or Apple’s look and feel.
Building custom design systems with raw widgets and Myx
With Material and Cupertino moved out, Flutter is strengthening its base widget layer to better support fully custom UI libraries.
Raw widgets: behavior without styling
The core widgets layer now exposes more “raw” widgets like RawMenuAnchor. These provide all the behavior and accessibility you need, but leave styling up to you.
Think of them as primed but unpainted components: ready for your design system to skin.
Myx and Remix: styling and reusable components
Myx is a composable styling system for Flutter that moves styling into a separate layer instead of mixing it into every widget tree. It lets you:
- Define reusable styles once and apply them across widgets
- Respond to context (dark mode, hover, etc.) directly in styles
- Animate style changes smoothly for hover and press effects
Remix builds on Myx and Flutter’s raw widgets to create fully accessible, behavior-rich components (like buttons and menus) that you can skin to match your brand.
Widgetbook: visual catalog and AI-friendly testing
Widgetbook turns your widget catalog into a separate, interactive Flutter app where every component and state is browsable.
Key capabilities:
- Generate “stories” from widget constructors and tweak props live via form fields
- Run widgets across matrices of themes, locales, devices, and text scales
- Catch layout and accessibility issues early (e.g., small phones at 200% text scale)
- Use Widgetbook Cloud to run visual diffs and accessibility checks on every PR
Widgetbook also pairs well with AI agents: they can use deterministic visual and accessibility feedback to fix UI regressions autonomously.
New experimental desktop windowing APIs
Desktop support gets a big upgrade with experimental multi-window APIs, designed in partnership with Canonical (Ubuntu).
Five cross-platform window types
The new API abstracts common desktop window patterns into five types:
- Regular: standard resizable window with title bar
- Dialog: modal or modeless windows that require a user decision
- Popup: anchored UI like context menus or autocomplete lists
- Tooltip: non-focusable informational overlays
- Satellite: auxiliary windows (toolboxes, color pickers) that track a parent
These are supported across Linux, macOS, and Windows with consistent behavior.
Window controllers, delegates, and shared state
To create and control windows, you use a window controller:
- Each window type has its own controller class
- Controllers can set initial size, title, and parent-child relationships
- A window delegate lets you respond to lifecycle events (close, destroy, etc.)
Rendering is handled by a Window widget that takes a controller and a child. All windows live in a single widget tree, so state management tools like Riverpod or BLoC work across multiple windows without special plumbing.
Most developers won’t touch the windowing API directly: Material and other design systems will integrate it under the hood so dialogs, menus, and tooltips become “real” windows on desktop automatically.
Platform updates: iOS 17, Android, and engine improvements
iOS 17 and Xcode 17 support
Flutter 3.5 is the first stable release aligned with Xcode 17 and iOS 17 (the transcript says “27”, but context clearly aligns with current OS cycles). It brings:
- Improved debugging and compliance with new Apple requirements
- Support for new iOS UI features, including foldable-style layouts on the latest devices
- Working
flutter screenshoton iOS again
Flutter is also strongly encouraging a move to Swift Package Manager. CocoaPods will go read-only in December 2026, and Flutter will start warning loudly if you have SPM disabled.
Intel Mac users now get CLI warnings; future Flutter releases will drop Intel support in favor of Apple Silicon only.
Android: safer defaults and better composition
On Android, Flutter 3.5 introduces:
- Release builds that ignore certain route entry points and cached engines when passed via external intents, making apps safer by default
- Hybrid composition enabled by default on the beta channel, eliminating scroll tearing and improving text input by letting the OS handle compositing
- Requirements for Android 14 / API 34 and Impeller on Vulkan for hybrid composition, with automatic fallback if not supported
- A future-breaking change: manually applying the Kotlin Gradle plugin will soon fail builds, so migrate to the built-in Kotlin support now
Engine and Impeller upgrades
The Flutter engine continues to evolve:
- Support for Vulkan external textures in custom embedders
- Better memory management: embedders can signal low-memory conditions so Impeller can purge off-screen caches
- Flutter GPU adds 2D texture arrays and clearer Dart errors for invalid pipelines
- Signed distance field (SDF) rendering now supports lines, thin rectangles, and gradients for crisper vector graphics
On-device AI with Gemma, MediaPipe, and Google AI Edge
One of the most exciting storylines in this release is Flutter’s on-device AI stack, powered by Google AI Edge, Gemma, and MediaPipe. The same tech stack used by Google’s internal apps is now available to Flutter developers.
Case study: Google AI Edge “Eloquent” and Foresight
Google AI Eloquent is an AI-powered dictation app that removes disfluencies (“ums”, “uhs”) and cleans up spoken text. Its key traits:
- On-device first: models run locally, no internet required
- Privacy-friendly: user audio and text stay on the device
- Optimized for long sessions: users record up to an hour or more
The team built Eloquent and its sibling app Foresight (an AI-enhanced meeting notes companion) with Flutter and LiteRTM (Google’s on-device LLM inference engine). They use Flutter as a single bridge to the native C API for LiteRTM, then share a Dart library across mobile and desktop.
Because of this architecture, they were able to:
- Port from mobile to desktop quickly
- Reuse UI components like diff animations across apps
- Share ~60% of infrastructure and ~80% of middle-tier code between Eloquent and Foresight
LiteRTM + Flutter Edge AI: one engine, one model, everywhere
LiteRTM is described as “the Flutter of on-device AI”: a cross-platform inference engine tuned for Android, iOS, web, desktop, and IoT, with support for GPU/NPU acceleration where available.
To use it in Flutter, you can:
- Add the official LiteRTM Flutter plugin from pub.dev (maintained by Google’s AI Edge team)
- Optionally layer flutter_edge_ai on top for features like chat history management and tool calling
The typical flow:
- Construct a LiteRTM engine and pass it to your AI wrapper (e.g., Flutter Edge AI)
- Download a model (once) and cache it locally, checking for Wi‑Fi to avoid blowing through mobile data
- Create chat sessions that share model weights but keep separate context windows
- Send messages (text, images, audio) and stream tokens back in real time
Gemma 4: lightweight, open-weight LLMs
Gemma is Google’s family of lightweight, open-weight models built on the same research as Gemini but tuned for local execution.
Key points:
- Lightweight: fewer parameters and optimized for constrained hardware while preserving strong reasoning abilities
- Open weight: you can download, inspect, and fine-tune the model under an Apache 2.0 license, including commercial use
- Edge-optimized variants like Gemma 4‑e‑2B and 4‑e‑4B run on phones, browsers, and low-power devices
- Larger variants (e.g., 12B, 26B, 31B) target high-end laptops, desktops, or single-GPU servers
Gemma models can run entirely on-device in Flutter apps via LiteRTM, powering use cases like:
- Local photo organizers that never upload images
- Offline game commentary and NPC logic
- Domain-specific assistants that call tools inside your app
Tool calling and agents on-device
Gemma can call tools that you define, allowing it to trigger actions in your app. The flow:
- You define tools (e.g., “createFolder”, “moveImage”) and expose them to the model
- Gemma returns tool calls as part of its response when it needs to act
- Your app executes the tool and sends results back to the model
This pattern underpins agentic behaviors like reorganizing local photo folders or controlling game characters, all without a network connection.
For more on how Google is evolving its AI stack, you can also check out this roundup of recent AI updates from Google and other major players.
MediaPipe pub package: 20 ready-made AI tasks
The Google AI Edge team also launched a new MediaPipe package on pub.dev with 20+ out-of-the-box tasks across:
- Vision
- Audio
- Text
- Decision making
- Retrieval
You can import these tasks directly into your Flutter app and start experimenting with on-device perception and multimodal features without building models from scratch.
Genkit 1.0 and AtUI 1.0: agentic apps and generative UI
Beyond on-device inference, Google is investing in tools for building full-stack, agentic applications in Dart.
Genkit 1.0: full-stack agentic apps in Dart
Genkit 1.0 is now stable, giving Dart developers a framework for building full-stack, multimodal, agentic apps. You can find it at genkit.dev.
Genkit focuses on:
- Orchestrating tools and skills for agents
- Handling multimodal inputs and outputs
- Running agents across client and server boundaries
AtUI 1.0: generative UI with guardrails
AtUI 1.0 (the evolution of Flutter Gen UI / GenY) is a protocol and Flutter package for agent-driven interfaces. Instead of returning just text, an agent can return structured UI components that your app renders.
Key upgrades in 1.0:
- Allowed parents / allowed children: schema-level guardrails that restrict how components can be nested, preventing bizarre layouts (like a data table inside a button)
- Express inference format: a more compact wire format that speeds up UI generation (e.g., halving UI generation time in a healthcare dashboard demo)
- Multi-catalog surfaces: surfaces can now pull components from multiple catalogs, letting teams compose domain-specific libraries on top of a shared design system
- Agent functions: UI components can call back into the agent to recompute data without starting a new LLM turn, ideal for things like order tickets and finance flows
- Extensibility metadata: attach structured metadata (like correlation IDs or routing hints) to surfaces, components, and actions for observability and advanced styling
The combination of AtUI, Gemma, and Flutter lets agents not only reason over data but also build and refine the exact UI users need in the moment.
Flutter on LG webOS TVs and pluggable platforms
Flutter’s “any screen” story continues to expand, with LG embracing Flutter for its TV platform and contributing back to the ecosystem.
LG webOS Flutter SDK
LG uses Flutter internally for system apps across its TV and monitor lineup and has released a webOS Flutter SDK so any developer can target LG TVs.
Why LG chose Flutter:
- Fast: performs well even on memory-constrained TV hardware
- Free and extensible: open source and customizable to platform needs
- Flourishing ecosystem: large, active community
The SDK includes:
- A webOS embedder that wires Flutter Engine to TV platform services
- A cross-compilation toolchain that produces an
.ipkpackage installable on TVs - 25+ plugins at launch, including Firebase integration
Development experience:
- Use a dev container (or WSL2 on Windows) to install the webOS CLI and SDK
- Register your TV as a custom device via the Developer Mode app
- Run
flutter runin debug/profile/release modes and use hot reload directly on the TV
Pluggable platforms: making new targets easier
Today, platform teams like LG often maintain their own embedders and sometimes their own forks of Flutter tooling. The pluggable platforms initiative aims to change that.
Goals:
- Let platforms ship their own embedders as plugins that work alongside the main Flutter SDK
- Bundle platform-specific tools (e.g., TV simulators) with those plugins
- Reduce maintenance burden and keep platforms closer to mainline Flutter
For app developers, this means taking an existing Flutter app to a new platform (TVs, fridges, cars, kiosks) should require far less custom setup.
Flutter Web + WebAssembly: faster, smoother, and easier to deploy
Flutter Web is leaning heavily into WebAssembly (Wasm) with Dart’s new Wasm GC support, bringing near-native performance across major browsers.
Wasm GC across Chrome, Safari, and Firefox
Dart’s WebAssembly backend now targets Wasm GC, letting garbage-collected languages like Dart run efficiently in Wasm.
In Flutter 3.5:
flutter build web --wasmcompiles both Wasm and JavaScript bundles- The bootstrap script checks browser support and loads Wasm when possible, falling back to JS otherwise
- Chrome uses Wasm by default; Safari and Firefox can be opted in now and will become defaults later
On heavy benchmarks, Wasm delivers over 2× smoother frame rates compared to JS across Chrome, Safari, and Firefox.
100% client-side DartPad via WebAssembly
The new DartPad preview at preview.dev compiles the Dart compiler and analyzer themselves to WebAssembly and runs them in a background Web Worker.
Benefits:
- No server round trips for compilation
- Multiple file tabs and richer project structures
- Consistent performance across modern browsers
If you’re interested in how Google is evolving its AI and dev tooling stack more broadly, also see this guide to the latest Google AI Studio voice features.
SIMD acceleration and text shaping improvements
WebAssembly SIMD is now wired up throughout the Dart SDK, thanks to major community contributions. This boosts performance for math-heavy workloads like physics, audio, and graphics.
Flutter is also experimenting with the browser’s Text Metrics API to:
- Offload font shaping to the browser instead of bundling C++ text engines
- Eliminate extra network requests for fallback fonts
- Get native color emoji and better script coverage on canvas
Content hashing and service worker-friendly builds
To avoid the classic “half-old, half-new” cache issues on the web, Flutter now supports content hashing out of the box.
Using --web-content-hash:
- All compiled assets (Wasm, JS, images) get content-based hashed filenames
index.htmland the bootstrap script are served withno-cache- Hashed assets can be served with long-lived, immutable cache headers
Flutter also emits a precache manifest to make it easier to write custom service workers that know exactly which files to cache.
Dart to Wasm outside the browser
Dart’s WebAssembly story isn’t limited to browsers. Using the wasm_tools package and runtimes like Wasmtime, you can compile Dart to a pure WebAssembly component and run it as:
- A serverless edge worker
- A CLI tool
- A secure plugin module embedded in another host (Rust, Go, Python, etc.)
This uses the WebAssembly System Interface (WASI) and the component model to handle HTTP, clocks, randomness, and other system APIs without needing Node.js or a JS engine.
AI-assisted developer experience and evals
Finally, the Dart and Flutter teams are rethinking developer tooling in an era where many developers work alongside AI agents.
Vision: agents as first-class tool users
The goal isn’t to replace core tools with AI, but to make agents effective users of those tools. The same deterministic tools humans rely on (analyzers, debuggers, DevTools) are being exposed to agents through:
- MCP servers (Model Context Protocol) that give agents safe access to commands like
flutter analyze, hot reload, VM service, and pub - Skills: “recipes” that encode best practices for common tasks (adding localization, routing, tests, refactors)
- Rules and custom agents: specialized configurations, like an accessibility-focused agent for Flutter apps
Eval strategy: measuring outcomes, quality, and DX
Because agents are non-deterministic, the team is investing heavily in evals to validate that tools and skills actually help.
They evaluate across three axes:
- Outcome: did the agent complete the task (fix the bug, add localization, etc.)?
- Quality: is the code idiomatic Dart/Flutter, maintainable, and correct?
- Developer experience: did the process avoid long error loops and confusing behavior?
Grading mixes deterministic checks (Dart analyze, Dart Code Metrics, Flutter build) with LLM-as-a-judge graders that drive the app and inspect behavior. Evals are kept private to avoid models “training on the test” and inflating scores.
Anti-Gravity agent plugin and accessibility agent
The team provides an agent plugin (currently well-integrated with the Anti-Gravity environment) that bundles:
- MCP servers for Dart/Flutter tools
- Skills for common workflows
- A custom Flutter accessibility agent that audits and helps fix accessibility issues
Developers are encouraged to experiment with custom agents tailored to their workflows (e.g., a “test agent” that only writes and maintains tests, or a “layout agent” focused on UI fixes).
Community milestones and what’s next
Alongside the technical updates, the Flutter team highlighted a few big ecosystem milestones:
- Over 1 million Flutter apps are now live on the Google Play Store
- 147 contributors landed commits in this release alone
- A new enterprise whitepaper on Flutter’s business value is available at
flutter.dev - AdMob’s new banner recycling delivered a 23% performance boost on iOS in benchmarks
Flutter 3.5 and Dart 3.14 are less about a single flashy feature and more about setting the stage for the next generation of app development: multi-window desktop, on-device AI, agent-driven UIs, and WebAssembly-powered web apps, all from a single codebase.
If you’re building with Flutter today, now is a good time to flutter upgrade, try out the new tooling, and start experimenting with on-device AI and generative UI in your own apps.
Comments
No comments yet. Be the first to share your thoughts!