What’s new in Flutter 3.5, Dart 3.14, and Google’s on-device AI stack

12 Nov 2026 04:41 7,331 views
Flutter 3.5 and Dart 3.14 ship a huge wave of updates: stable native interop, new desktop windowing APIs, decoupled design systems, WebAssembly for the web, and a full on-device AI stack powered by Gemma, MediaPipe, and Google AI Edge. Here’s what’s new and how it all fits together.

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_use package, shrinking binary sizes
  • Deep dives available for tools like Pigeon, ffigen, and jni

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_ui
  • cupertino_ui

This decoupling means UI libraries can ship updates independently of the core framework. Upgrading should be mostly automatic:

  • Run dart fix to 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 screenshot on 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:

  1. Construct a LiteRTM engine and pass it to your AI wrapper (e.g., Flutter Edge AI)
  2. Download a model (once) and cache it locally, checking for Wi‑Fi to avoid blowing through mobile data
  3. Create chat sessions that share model weights but keep separate context windows
  4. 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 .ipk package 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 run in 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 --wasm compiles 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.html and the bootstrap script are served with no-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.

Share:

Comments

No comments yet. Be the first to share your thoughts!

More in Product Launches