Flutter 3.44 & Dart 3.12 —
Everything New at Google I/O 2026
A deep, comprehensive walkthrough of every major announcement from Google I/O 2026 — covering GenUI & the A2UI protocol, Agentic Hot Reload, Dart language updates, Impeller's full Android rollout, Swift Package Manager defaults, Material/Cupertino decoupling, platform expansions, Firebase full-stack Dart, DevTools improvements, and more.
- Ecosystem by the Numbers
- Release Theme
- GenUI & A2UI Protocol
- Agentic Hot Reload & MCP
- Impeller: Skia Removal
- Hybrid Composition++ (HCPP)
- Swift Package Manager Default
- Material & Cupertino Decoupling
- Platform Expansions (Toyota, LG, Desktop)
- Dart 3.12 Language Updates
- Genkit Dart Preview
- Full-Stack Dart & Firebase
- DevTools & Tooling
- Flutter Web Improvements
- Google Antigravity IDE
- Migration Checklist
- Feature Status Matrix
- Official Resources
Ecosystem by the Numbers
Google I/O 2026 opened the Flutter session with raw numbers that set the tone for everything that followed. These aren't vanity metrics — they explain why a release of this scale and ambition was possible.
1.3 Billion Downloads
pub.dev hit over 1.3 billion package downloads in the last 30 days alone — a staggering signal of ecosystem health.
1.5 Million Developers
Active monthly developer count rose 50% in a single year, making Flutter one of the fastest-growing dev ecosystems.
#2 Mobile SDK
Flutter is now the second most popular mobile development SDK on both the App Store and Google Play.
1,700 Contributors
The Flutter project has reached 1,700 total contributors. This release cycle: 178 contributors, 61 of them first-timers.
5,800+ Changes / Year
Over 5,800 changes landed in the Flutter repository in the past year — a velocity that demonstrates sustained team investment.
972 Commits This Cycle
The 3.44 release cycle delivered 972 commits from the community and the Flutter team combined.
For teams evaluating framework choices, these numbers represent long-term ecosystem signal — thriving package ecosystem, growing developer base, and sustainable community-driven development.
The 2026 Release Theme
The session was presented by Khanh Nguyen and Kate Lovett from the Flutter team, with a special appearance by Li-Te Cheng from Google DeepMind to present the GenUI and Gemini-based UI lessons from the Gemini App team.
Flutter 3.44 and Dart 3.12 are not incremental releases. They mark a genuine architectural shift in three dimensions: how Flutter apps are built (agentic workflows, GenUI), how they're rendered (Impeller-only on Android, HCPP), and how the framework itself is structured (Material/Cupertino decoupling).
Flutter GenUI & the A2UI Protocol
The most architecturally significant announcement at I/O 2026 is the Flutter GenUI SDK, built on top of the open A2UI (Agent-to-UI) protocol. This fundamentally changes what "building a Flutter app" means at runtime.
What Is GenUI?
Traditionally, Flutter apps ship a fixed widget tree. The data changes, the UI updates — but the layout and structure remain statically defined by the developer. GenUI breaks this constraint. An AI agent can now compose real Flutter widgets on the fly, generating fully interactive screens dynamically based on what the user is trying to accomplish — without a full app store update, without pre-defined layouts.
The Dart Interpreted Bytecode Exploration
Underpinning GenUI is something even deeper: the Dart team is actively exploring interpreted bytecode within the Dart runtime. Today, hot reload already delivers incredible DX during development, but production apps ship ahead-of-time compiled Dart. The bytecode exploration would unlock "ephemeral UI delivery" — loading specific, dynamic UI sections on demand at runtime without a full app update. Think of it as a hybrid: AOT compilation for stable parts of your app, interpreted dynamic sections for GenUI-driven flows.
Live Demos at I/O
Finnish it — A language-learning app by Flutter GDE Cagatay Ulusoy (Staff Engineer at Wolt) was the centrepiece demo. The UI wasn't pre-built and revealed; it was generated on the fly by a GenUI agent responding to the learner's interaction patterns. Using a real community member's production app as the flagship GenUI demo was a meaningful choice.
Hatcha — An event-planning app by gskinner team that showed the same dynamic UI generation in a different domain, demonstrating that GenUI isn't tied to a single use case but is a general-purpose capability.
Lessons from the Gemini App's Visual Layout Experiment
Li-Te Cheng from Google DeepMind shared practical takeaways from Google's own production experience building generative UIs in the Gemini App:
Opinionated Frameworks
Use opinionated component systems for consistency. Giving the model too much freedom leads to layout incoherence.
The "AI Critic" Loop
Use a second model call to critique the generated UI before rendering. This dramatically improves reliability in production.
Speed vs. Determinism
Template-based rendering is faster and more predictable. Full GenUI shines for personalised, high-variability interfaces.
Be Selective
The hardest question is where to apply GenUI. Deterministic screens shouldn't be GenUI'd for the sake of it.
Agentic Hot Reload & the Dart MCP Server
Agentic Hot Reload is the headline DX feature of Flutter 3.44 and Dart 3.12. It closes a feedback loop that has been frustrating since AI-assisted coding became mainstream: you ask your coding agent to tweak the UI, it generates changes, and then… you have to manually copy output, run commands, wait for a reload, and figure out why the agent's edits don't match your project's actual state.
How It Works
Through the Dart and Flutter MCP (Model Context Protocol) server, your coding agent can now:
Auto-Discover Your App
The Dart Tooling Daemon (DTD) exposes connection details via CLI. The MCP server finds your running app automatically — zero configuration required.
Instant Hot Reload
After the agent modifies code, it triggers a hot reload immediately. The feedback loop shrinks from minutes to seconds.
Live Runtime Diagnostics
The agent can fetch runtime state, widget tree snapshots, and diagnostic data from the running app — not just static code analysis.
SDK-Level Understanding
The agent connects to your local Dart SDK analyzer — understanding your specific widget tree, types, and dependencies, not generic Flutter patterns.
Dart and Flutter Agent Skills
Alongside Agentic Hot Reload, the team launched Agent Skills — task-oriented guidance modules hosted on GitHub (flutter/skills) that provide agents with step-by-step, Flutter-specific instructions for common tasks:
Dependency Search Hardening
The team also tightened the MCP server's dependency search capabilities — agents can now reliably search pub.dev, understand version constraints, and assess compatibility before suggesting a package. Combined with consolidated MCP tool definitions that reduce token overhead, agentic sessions on large codebases are now significantly cheaper and more reliable.
Compatible Agents
Agentic Hot Reload works with any MCP-compatible agent: Gemini CLI, Claude Code, Cursor, Windsurf, and GitHub Copilot Workspace. No vendor lock-in — the MCP server is part of the official Dart SDK toolchain.
Impeller: The Skia Backend Is Gone on Android
Flutter's rendering story on Android is finally complete. The Skia backend is being removed for Android 10 and above. Pure Impeller Vulkan rendering is now the default and only option on modern Android. This is the conclusion of a multi-year effort, and it matters enormously for app quality.
Why This Matters
No More Shader Jank
Skia compiled shaders at runtime on first draw — causing the infamous "jank on first launch." Impeller pre-compiles all shaders, eliminating this entirely.
Vulkan-First
Impeller is built from the ground up for Vulkan, giving it a lower-level, more efficient path to the GPU compared to Skia's OpenGL-era architecture.
Predictable Performance
Frame rendering is now deterministic. No background shader compilation means consistent 60/90/120fps without unexpected stutters.
Faster App Startup
Eliminating runtime shader compilation means faster startup-to-interaction times, especially on the first launch after install.
iOS: Impeller Has Been the Default Since Flutter 3.10
For those joining the story late — Impeller has already been the default renderer on iOS since Flutter 3.10 (May 2023). Android's transition has taken longer due to the fragmentation of Android device GPUs and the need to ensure Vulkan coverage was broad enough. With Android 10+ representing the vast majority of active devices today, the team made the call to complete the transition.
Hybrid Composition++ (HCPP) on Android
Hybrid Composition++ (HCPP) solves the longest-standing Platform Views problem on Android: the tradeoff between frame rate and fidelity when embedding native Android views (maps, web views, camera, etc.) inside Flutter.
The Old Problem
Flutter renders to a SurfaceTexture by default. When you embed a native Platform View, you have two options: Virtual Display (which causes input latency and has SurfaceView limitations) or the original Hybrid Composition (which causes performance drops due to extra GPU compositing passes). Neither was ideal for complex apps.
How HCPP Works
HCPP delegates compositing to the Android OS itself using Vulkan and SurfaceControl — Android's own compositor API. The result:
OS-Level Compositing
SurfaceControl lets Android OS do what it does best — compositing surfaces efficiently without Flutter needing to manage the GL/Vulkan context switch.
Correct Touch Input
Touch events are now routed correctly for both Flutter widgets and embedded native views — a long-standing source of hit-testing bugs.
SurfaceView Support
HCPP makes SurfaceView-based native views (camera, video, maps) fully reliable inside Flutter — previously the most problematic embed type.
Smoother Scrolling
Scrolling performance when a Platform View is on screen is dramatically improved — no more dropped frames when the native view appears.
Enabling HCPP
HCPP is opt-in in Flutter 3.44. You can enable it per-app via a CLI flag or via an Android manifest entry:
<!-- AndroidManifest.xml -->
<meta-data
android:name="io.flutter.embedding.android.EnableHcpp"
android:value="true" />Display Corner Radius in MediaQuery
Flutter 3.44 also adds a small but valuable Android feature: Flutter now reads the device's display corner radii from hardware and exposes them through MediaQuery. This lets you build widgets that naturally respect the physical rounded corners of modern Android screens — a subtle detail that polishes the feel of full-bleed designs.
AGP 9 Kotlin Warning
build.gradle, your build will silently break. The migration guide requires a minimum Flutter constraint of 3.44. Audit your plugin configuration before releasing a 3.44-compatible update.
Swift Package Manager: Now the Default for iOS & macOS
After years of being available as an opt-in feature, Swift Package Manager (SwiftPM) is now the default package manager for iOS and macOS Flutter projects in Flutter 3.44. CocoaPods has been a steady source of build pain — version conflicts, slow installs, the Podfile.lock dance — and the Flutter team has taken the decisive step of deprecating it as the default.
What Changes
When you run flutter create for a new iOS or macOS app, Swift Package Manager is used out of the box. For existing projects, the CLI migration tool handles the conversion:
# Migrate an existing project
flutter migrate swift-package-managerThe tool analyzes your existing Podfile dependencies and generates the equivalent Package.swift configuration. For plugins still on CocoaPods, Flutter 3.44 provides an automatic fallback with a warning — your app will still build, but you'll see a deprecation notice prompting you to file issues or update the dependency.
Benefits of SwiftPM
Faster Resolution
SwiftPM is significantly faster than CocoaPods for dependency resolution and fetching, especially in CI environments.
Apple-Native
First-party Apple tooling means better Xcode integration, better error messages, and guaranteed forward compatibility as Apple's toolchain evolves.
Reproducible Builds
SwiftPM's checksum-based verification gives you stronger build reproducibility guarantees than CocoaPods.
UIScene Lifecycle Migration
Alongside the SwiftPM change, the team flagged that Apple is moving toward requiring UIScene-based lifecycle management in future iOS app reviews. Flutter 3.44 includes updated template code that defaults to UIScene. If your app still uses the older AppDelegate-only lifecycle, this is the release to migrate — before Apple's enforcement catches you off guard.
Material & Cupertino Decoupling from Core Flutter
This is the structural announcement with the longest-reaching implications. Starting with Flutter 3.44, the Material and Cupertino design system libraries are frozen in the core Flutter framework. In a future release, they will be fully extracted into standalone, independently-versioned packages on pub.dev:
# Future pubspec.yaml
dependencies:
material_ui: ^1.0.0 # Currently: package:flutter/material.dart
cupertino_ui: ^1.0.0 # Currently: package:flutter/cupertino.dartWhy This Is Significant
Today, when Google wants to ship a Material 3 update — a new component, a behaviour fix, a colour token change — it requires a full Flutter SDK release. That means the design system update has to go through the Flutter release cycle (roughly every 3 months), go through your app's upgrade cycle, and wait for your team's capacity. For teams with custom design systems, those Material internals were also a source of friction when building against Flutter's core primitives.
What You Should Do Now
For Flutter 3.44 specifically, you don't need to change any imports — the libraries are frozen in core, not removed. But you should:
• Watch the decoupling tracking issue on GitHub to understand the migration timeline
• Start auditing which parts of your codebase have deep dependencies on package:flutter/material.dart internals
• If you're planning a Material 3 migration, complete it before the standalone package ships to avoid double-migrating
• If you maintain a Flutter plugin that wraps Material widgets, plan for the import path change
Independent Versioning = Faster Design Updates
Once extracted, material_ui can ship a new Material 3 component the same day Google's design team releases it. No waiting for the next Flutter SDK. Teams that keep their Material dependency up to date will automatically get the latest design tokens and component behaviour without a framework upgrade.
Platform Expansions: Toyota, LG webOS, Desktop
Flutter's "everywhere" theme was backed by real hardware demos at I/O 2026 that went far beyond the typical mobile showcase.
Toyota RAV4 2026
Flutter powers the multimedia infotainment system in the 2026 Toyota RAV4 — a production automotive deployment with millions of units.
LG webOS
LG's webOS Flutter SDK is coming soon with full hot reload, Riverpod, Firebase plugins, and big-screen layout support.
Canonical Desktop
Canonical is now the lead maintainer for Flutter Desktop across Linux, Windows, and macOS.
Multi-Window APIs
Experimental multi-window support on desktop: popup windows, tooltip windows on macOS, separate dialog windows — all on the main channel.
Toyota RAV4: Flutter in Production Automotive
Khanh Nguyen shared that she visited Toyota Connected's offices in Plano, TX and saw Flutter running on test units in the office — then noticed those same cars in driveways on the way home. Flutter now powers a multimedia system inside a car that families across North America are buying and driving. This isn't a concept car or a prototype. It's a production vehicle shipping at scale, built with Flutter by the Toyota team in a multi-year collaboration.
LG webOS SDK Details
The forthcoming LG webOS Flutter SDK brings the full Flutter development experience to smart TV targets: hot reload during development, Riverpod for state management, Firebase plugins for authentication and analytics, and layout primitives designed for 10-foot UI patterns. Between phone, tablet, car, desktop, and TV, Flutter's "run anywhere" promise is now demonstrably real across six distinct form factors.
Canonical's Desktop Commitment
Having Canonical — the company behind Ubuntu — take lead maintainership of Flutter Desktop signals serious long-term commitment to Linux as a first-class Flutter platform. The experimental multi-window APIs progressing on the main channel mean desktop features are no longer perpetually "coming soon" — they're in active development with a major industry backer.
Dart 3.12 Language Updates
Dart 3.12 focuses on reducing everyday boilerplate and making classes more concise — specifically around a pain point that every Dart developer has hit: constructors with private fields.
Private Named Parameters (Stable)
Before Dart 3.12, combining named constructor parameters with private class fields forced you to write repetitive, manual initializer lists just to drop an underscore:
// Before Dart 3.12 — tedious boilerplate
class Hummingbird {
final String _petName;
final int _wingbeatsPerSecond;
Hummingbird({required String petName, required int wingbeatsPerSecond})
: _petName = petName,
_wingbeatsPerSecond = wingbeatsPerSecond;
}Dart 3.12 allows private named initializing formals directly. The compiler handles the name mapping automatically:
// Dart 3.12 — clean and concise
class Hummingbird {
final String _petName;
final int _wingbeatsPerSecond;
// Private fields, public parameter names at call site
Hummingbird({required this._petName, required this._wingbeatsPerSecond});
}
// Call site uses public names (without underscore)
void main() {
print(Hummingbird(petName: 'Dash', wingbeatsPerSecond: 75));
}The initialized fields remain private to the class. The constructor parameters and argument names at the call site automatically use the corresponding public names (without the _ prefix). This ships as stable in Dart 3.12.
Primary Constructors (Experimental)
One of the most-requested Dart language features is now available as an experimental preview. Primary constructors allow you to declare a class and its constructor in a single line by placing parameters directly in the class header:
// Before: 4 lines, repetitive
class Point {
final int x;
final int y;
Point(this.x, this.y);
}
// Dart 3.12 primary constructor: 1 line
class Point(final int x, final int y);The feature also introduces shorter new and factory keywords for constructors inside the class body, and classes with empty bodies can end with a semicolon:
class Pet {
String name;
new() : name = 'Fluffy';
new withName(this.name);
}
class Dog extends Pet; // Semicolon = empty bodydart run --enable-experiment=primary-constructors bin/main.dart
File issues on the Dart SDK repository (cc @kallentu) — this is a foundational feature and real-world feedback before stabilisation is crucial.
Native Git LFS Support in pub
As of Dart 3.12, dart pub natively supports git dependencies with Git Large File Storage (LFS). Teams versioning large assets (media, ML model weights, binaries) directly in their git repos no longer need custom workarounds. As long as git lfs is installed, pub handles everything automatically — no extra pubspec.yaml configuration needed.
dependencies:
my_assets:
git: https://github.com/org/my-assets-repo.git
Genkit Dart Preview
Genkit Dart is the ecosystem headline of Dart 3.12 — an open-source framework for building full-stack, AI-powered agentic applications in Dart and Flutter. It brings the Firebase Genkit framework (already popular in Node.js and Go) to the Dart ecosystem, with a design that fits naturally into the Flutter development model.
What Genkit Dart Provides
Model-Agnostic API
Supports Google Gemini, Anthropic Claude, OpenAI, and any OpenAI-compatible model through a unified, consistent interface.
Type-Safe AI
Combines Dart's strong type system with the schematic package for strongly-typed structured output generation and agentic flows.
Run Anywhere
Write your AI logic once and run it in a backend service or directly inside your Flutter app on-device. Same code, your choice of deployment target.
Developer UI
A built-in local web UI for testing prompts, viewing traces, inspecting tool calls, and debugging multi-step agentic flows.
Core AI Primitives
Built-in support for structured output, tool calling (function calling), and multi-step flows — the building blocks of production AI features.
Tracing & Observability
Production-grade tracing built in from day one — see every step of an agentic flow with timing, token counts, and errors.
Code Example: Multi-Model in a Few Lines
import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:genkit_anthropic/genkit_anthropic.dart';
void main() async {
final ai = Genkit(plugins: [googleAI(), anthropic()]);
// Call Gemini
final geminiResponse = await ai.generate(
model: googleAI.gemini('gemini-flash-latest'),
prompt: 'Summarise this Flutter changelog',
);
// Call Claude
final claudeResponse = await ai.generate(
model: anthropic.model('claude-sonnet-4-6'),
prompt: 'Review this Dart code for style issues',
);
}Genkit Dart is currently in preview. The team is active on Discord and GitHub — now is the time to try it, especially if you're building AI-powered features in a Flutter + Dart app. The ability to run the same AI orchestration logic on-device or in a backend service is genuinely novel in the cross-platform ecosystem.
Full-Stack Dart & Firebase Functions
Building on the Dart support for Firebase Functions previewed at Google Cloud Next 2026, I/O 2026 formalized the vision of full-stack Dart as a production-grade reality.
Dart in Cloud Functions for Firebase (Experimental)
For years, extending a Flutter app to the cloud meant context-switching into JavaScript, Python, or Java — writing the same data models twice, duplicating validation logic, maintaining sync between frontend and backend types. That friction is now gone.
shared_models package imported by both your Flutter frontend and your Cloud Functions backend. One User model, one OrderStatus enum, one set of validation rules — serving both layers simultaneously. The "Double-Doc Tax" (writing everything twice) is eliminated.
Fast Cold Starts via AOT Compilation
Dart's Ahead-of-Time (AOT) compilation gives Cloud Functions a significant serverless advantage. AOT-compiled Dart functions start in milliseconds — comparable to Go and significantly faster than interpreted or JIT-compiled runtimes. There are no Dockerfiles to maintain, no container configuration to manage. The Dart toolchain produces a compact, self-contained binary that scales instantly.
Firebase Agent Skills for Flutter
Firebase also expanded its Agent Skills to cover Flutter, iOS, and Android environments explicitly. Instead of generic suggestions, the Firebase assistant now understands Flutter-specific architecture — FlutterFire initialisation patterns, Firestore stream subscriptions, Firebase Auth state handling, and Cloud Functions callables from Flutter. This context-aware assistance significantly reduces the gap between "Firebase documentation" and "working Flutter code."
DevTools, Tooling & Developer Experience
Flutter 3.44 and Dart 3.12 include a suite of tooling improvements that compound into meaningfully faster daily development.
DevTools on WASM (Default)
DevTools — Flutter's browser-based development and profiling suite — now ships with WebAssembly (WASM) as the default renderer. In practice: DevTools loads faster, scrolling through large widget trees is smoother, and the Timeline view handles high-frequency frame data without jank. If you've ever had DevTools itself become a performance bottleneck while profiling a slow app, this change is a genuine quality-of-life improvement.
Widget Previewer Improvements
Widget Previews let you test a widget against a matrix of screen sizes, themes, text scales, and locales without spinning up a full simulator. As of Flutter 3.44, Widget Previews now include full Flutter Inspector support. You can inspect the widget tree, examine render objects, and edit properties from within the Preview — the same experience you'd have debugging a running app, but sandboxed to a single widget. This also reduces IDE memory usage by up to 50% compared to running a simulator for widget iteration.
Faster Dart CLI Tools
By moving to AOT snapshots of the analysis server, Dart CLI tools are meaningfully faster:
dart format
Now feels almost instant — no more waiting multiple seconds for formatting to complete on large files or directories.
dart analyze
Roughly 50% faster on cold starts. Running analysis in CI pipelines is now significantly cheaper in compute time.
Custom Analyzer Plugins
Teams can now extend the analysis server to report their own custom diagnostics and offer quick fixes — enforcing project-specific style rules natively in the IDE.
pub cache gc
A new command that finds and prunes unused packages from your pub cache, automatically reclaiming disk space on development machines.
Analysis Server Performance Diagnostics
A new dart info record-performance command lets you capture execution traces and CPU profiling data from active Dart Analysis Server processes. If you experience slow analysis or unresponsive completion, you can capture a trace and include it when filing a GitHub issue — giving the Dart team real-world data to diagnose bottlenecks rather than synthetic benchmarks.
Flutter Web: HTML-in-Canvas & WebMCP
Two new Chrome APIs announced at I/O 2026 have direct, significant implications for Flutter Web's biggest long-standing limitations.
HTML-in-Canvas
Flutter Web's CanvasKit renderer draws everything into a single <canvas> element — which is why Flutter Web delivers pixel-perfect rendering but historically lacks native text selection, browser translation, and SEO-crawlable content. HTML-in-Canvas is a new Chrome API (currently in origin trial) that lets a Canvas-based renderer embed real HTML elements within the canvas with much lower performance cost than today's Platform View approach. Chrome engineers at the I/O floor confirmed that Flutter Web was one of the first use cases they had in mind. If this API standardises across browsers, it could resolve Flutter Web's core SEO and accessibility limitations fundamentally.
WebMCP
WebMCP is a proposed browser standard for exposing structured tools so that browser-based AI agents can interact with web apps reliably. For traditional web apps with a DOM, agents can already read and interact with page content. Flutter Web doesn't render a DOM — which means in-browser agents have historically had nothing to grab onto. WebMCP would let a Flutter web app explicitly declare its available actions and data in a structured way, so an agent can change inputs, submit forms, or navigate the app without needing to parse a visual layout. This is a long-term story, but it's the right foundation.
Built-in AI APIs in Chrome 149
Chrome 149 ships APIs for calling AI models built directly into the browser — no cloud round-trip, no API key, no token costs. For Flutter Web apps, this opens on-device inference for use cases that previously required a backend: spelling correction, content classification, summarisation. Combined with the Gemma 4 on-device improvements for mobile, on-device inference is becoming a credible production option across form factors.
Google Antigravity: The Agent-First Flutter IDE
Google Antigravity is Google's agent-first IDE — a VS Code fork powered by Gemini, purpose-built for agentic development workflows. It shipped version 2.0 at I/O 2026 with a full desktop app, 16 specialized agents across the development stack, and MCP connector support.
The Antigravity + Flutter Workflow
At I/O 2026, Google ran a live workshop titled "Vibe once, run anywhere with Google Antigravity and Flutter" that demonstrated the complete agentic development loop:
1. Stitch — Google's AI-generated design tool. Describe your app's UI in natural language, and Stitch generates a design mockup.
2. Antigravity — Imports the Stitch design and converts it to Flutter + Dart code through an agentic prompt workflow. The 16 specialized agents cover specific development tasks: Flutter widget generation, state management setup, routing, testing, and more.
3. MCP Hot Reload — Antigravity connects to your running Flutter app via the Dart MCP server and automatically hot reloads as the agent makes changes. The design-to-code-to-device loop runs continuously without manual intervention.
The Antigravity Coffee Demo
The standout floor experience at I/O 2026 was the Antigravity Coffee Co. demo: a Flutter app running simultaneously across phone, tablet, laptop, and TV. The app asked users a few questions, generated a personalised prompt, and Google's Nano Banana image generation model produced custom latte art based on the responses. A physical printer then applied the generated image to the foam of a real cappuccino. The demo illustrated that Flutter's multi-device rendering, combined with AI generation and physical hardware integration, is a production-grade capability — not a future aspiration.
Migration Checklist for Flutter 3.44
Before you run flutter upgrade on a production app, here's the ordered checklist of things to verify and test:
flutter upgrade and verify with flutter --version. Confirm you're on 3.44 and Dart 3.12.
If you use Cursor, Claude Code, or any MCP-compatible agent, install or update the Dart and Flutter MCP server. Start your app and prompt your agent to make a UI change — verify auto-reload works.
If your app uses Platform Views (maps, WebView, camera): test with HCPP enabled via the manifest flag. Check your Kotlin Gradle plugin configuration for AGP 9 compatibility. Plugin maintainers: set a minimum Flutter constraint of 3.44 in your update.
Run
flutter migrate swift-package-manager on your iOS project. Audit all CocoaPods dependencies for SwiftPM support. Plugins without SwiftPM support will trigger a fallback warning — file issues with those maintainers.
Watch the decoupling tracking issue on GitHub. If you're planning a Material 3 migration: do it now, before the standalone package ships. Search your codebase for any direct use of
package:flutter/material.dart private APIs.
Private named parameters are stable — adopt them in new code. Try primary constructors with the experiment flag in a non-production project and file feedback. Update your pub cache with
dart pub cache gc.
Feature Status Matrix
A quick reference of every major feature from this release cycle and its current stability status:
| Feature | Area | Status |
|---|---|---|
| Agentic Hot Reload (MCP) | Tooling / DX | Stable |
| Genkit Dart | AI / Backend | Preview |
| GenUI SDK & A2UI Protocol | AI / UI | Preview |
| Flutter Agent Skills | Tooling / DX | Stable |
| Impeller Vulkan (Android 10+) | Rendering | Stable (Default) |
| Hybrid Composition++ (HCPP) | Android / Rendering | Opt-in |
| Swift Package Manager Default | iOS / macOS | Stable (Default) |
| Material / Cupertino Decoupling | Framework | In Progress |
| Multi-Window Desktop APIs | Desktop | Experimental |
| DevTools WASM Default | Tooling | Stable (Default) |
| Widget Previewer + Inspector | Tooling | Stable |
| Private Named Parameters (Dart) | Language | Stable |
| Primary Constructors (Dart) | Language | Experimental |
| Dart in Firebase Functions | Backend / Cloud | Experimental |
| Native Git LFS in pub | Tooling | Stable |
| Analysis Server AOT Snapshots | Tooling | Stable |
| Custom Analyzer Plugins | Tooling | Stable |
| HTML-in-Canvas (Chrome) | Web | Origin Trial |
| WebMCP (Chrome) | Web | Proposed Standard |
| LG webOS SDK | Embedded | Coming Soon |
| Google Antigravity 2.0 | IDE | Public Preview |
Official Resources
Everything you need to go deeper on today's announcements:
0 Comments