Flutter 3.44 Released: A Complete Engineering Guide to What Changed

Flutter 3.44 has been released alongside Google I/O 2026. It is not a small maintenance update, and it is not just another “new widgets and bug fixes” release.

The important thing about Flutter 3.44 is that it changes the direction of Flutter in several areas at once:

• Flutter development is becoming more agent-aware through MCP, Agentic Hot Reload, and Dart/Flutter Agent Skills.
• iOS and macOS dependency management is moving away from CocoaPods toward Swift Package Manager.
• Android native view embedding gets a major new rendering path with Hybrid Composition++.
• Flutter Desktop gets a stronger governance signal through Canonical’s expanded role.
• Material and Cupertino begin their move out of the core framework into independently versioned packages.
• Impeller, Web, accessibility, Widget Previews, DevTools, and build tooling all receive practical improvements.
• Flutter’s embedded story gets more concrete through Toyota RAV4 and LG webOS announcements.

The key takeaway is this: Flutter is repositioning from a mobile-first cross-platform UI framework into a broader application platform for AI-assisted development, embedded devices, desktop apps, web apps, and native platform integration.

Release Context

Flutter 3.44 shipped around Google I/O 2026. The official Google I/O session “What’s new in Flutter” was scheduled for May 20, 2026, and the official Flutter blog framed this release under the theme:

Flutter is everywhere, everyday, built by everyone, for everyone.

The numbers in the official announcement are worth noting because those metrics explain why Google is presenting Flutter as a mature platform rather than a niche UI toolkit:

• pub.dev recorded more than 1.3 billion package downloads in the previous 30 days.
• Flutter is described as the second most popular mobile development SDK on both major app stores.
• Flutter has more than 1.5 million monthly developers, a 50% increase in one year.
• The Flutter ecosystem has 1,700+ contributors.
• The core repository received 5,800 changes in the past year.
• The 3.44 release cycle alone included 972 commits from 178 contributors, including 61 first-time contributors.

Those numbers matter because Flutter’s biggest strategic question over the last few years has not been whether the framework can render UI. It has been whether the ecosystem, tooling, governance, and platform support are durable enough for long-lived products. Flutter 3.44 is clearly designed to answer that question with platform breadth and workflow depth.

Executive Summary

Here is the release in one dense pass.

For everyday Flutter developers, the most visible changes are Agentic Hot Reload, Widget Preview improvements, faster DevTools, Rosetta-free Apple Silicon tooling, SwiftPM becoming the default for iOS/macOS, and quality-of-life improvements across Material, Cupertino, accessibility, text selection, and layout stability.

For mobile teams, the highest-impact changes are SwiftPM, UIScene migration pressure, iOS predictive text, Android Hybrid Composition++, Android 17 preparation, AGP 9/Kotlin build changes, Android display corner radii, and ABI filtering behavior.

For web teams, the important work is around accessibility, Safari autofill, scrolling, keyboard event synthesis, Skwasm/CanvasKit reliability, and flutter run --base-href.

For desktop teams, Canonical becoming lead maintainer and Strategic Steward for Flutter Desktop is more important than any single API. Experimental windowing support, tooltip windows, popup windows, dialog windows, Linux content-sized views, and Windows stylus support show where the desktop roadmap is going.

For framework architects, the freeze of Material and Cupertino inside the core framework is the major long-term change. These libraries are moving toward standalone packages named material_ui and cupertino_ui.

For graphics-heavy apps, Impeller Vulkan improvements, SDF circle rendering, perspective/shadow fixes, fragment shader uniform lookup by name, and better shader compiler diagnostics are the changes to test.

For product teams watching AI, Flutter 3.44 is full of signals: Agentic Hot Reload, Dart/Flutter Agent Skills, Firebase AI Logic, Server Prompt Templates, Firebase Agent Skills, Genkit Dart preview, LiteRT-LM plans for Flutter, GenUI, and A2UI.

1. Agentic Hot Reload: Flutter Adapts to Coding Agents

The most important developer-experience feature in Flutter 3.44 is Agentic Hot Reload.

Traditional Flutter Hot Reload is already one of Flutter’s strongest productivity features: Dart code changes can be reloaded into a running app without restarting the whole application. The new part is that coding agents can now participate in this loop more directly.

Flutter’s MCP server can automatically find and connect to running Dart and Flutter applications. A coding agent can modify UI code and then trigger hot reload automatically. The official announcement mentions tools such as Antigravity, Gemini CLI, Claude Code, and Cursor as examples of the agent ecosystem that Flutter is now designing around.

The practical difference is simple:

Before:
1. An agent receives a UI change request.
2. A patch is reviewed or applied.
3. The developer switches to a terminal or IDE.
4. Hot reload is triggered manually.
5. The result is inspected.
6. The loop repeats.

With Agentic Hot Reload:
1. An agent receives a UI change request.
2. The agent edits code.
3. The agent triggers hot reload.
4. The result is available immediately in the running app.

This is not just convenience. UI iteration is a feedback-loop problem. Reducing that loop from minutes to seconds changes how useful coding agents are for actual interface work.

Flutter 3.44 also improves agent workflows in two supporting ways:

• Hardened dependency search lets agents safely read and search files inside package dependencies without needing full access to the local pub cache.
• Consolidated MCP tool definitions reduce token cost for agent workflows.

The second point matters more than it sounds. Agent tooling can become expensive or unreliable when tool schemas are large, repetitive, or noisy. Reducing tool definition overhead makes Flutter agent workflows more practical in long sessions.

2. Dart and Flutter Agent Skills

Flutter 3.44 is not only exposing runtime tools to agents. It is also shipping task-oriented guidance through Dart and Flutter Agent Skills.

These skills give coding agents step-by-step domain instructions for common Flutter tasks. The official examples include work such as adding integration tests or setting up localization while following recommended practices.

This is a smart direction because generic coding agents often know Flutter syntax but miss project-level conventions:

• where integration tests belong,
• how localization should be wired,
• how platform folders should be changed,
• how generated files should be handled,
• how to avoid low-value rewrites.

Agent Skills try to make the agent’s behavior more predictable by giving it structured task knowledge instead of relying only on model memory.

For teams, the practical message is this: Flutter is starting to treat agent instructions as part of the development environment. In 2026, a serious Flutter setup may include SDK version, IDE plugins, CI, lint rules, and agent skills.

3. AI-Native Apps: Firebase AI Logic, Genkit Dart, Gemma, LiteRT-LM, and GenUI

Flutter 3.44 spends a large amount of attention on AI-native application development. This is not a single feature. It is an ecosystem direction.

Firebase AI Logic

Firebase AI Logic lets Flutter apps call Gemini APIs from the client side. The official announcement highlights MacroFactor as an example: a Flutter app that uses Firebase AI Logic to connect to a Gemini model and process multimodal input for meal tracking.

The important update is Server Prompt Templates. Instead of embedding prompts directly in application code, teams can keep prompts server-side. That matters for:

• prompt iteration without app releases,
• avoiding prompt duplication across clients,
• reducing sensitive prompt exposure in shipped binaries,
• keeping product logic easier to govern.

Firebase Agent Skills for Flutter are also available, giving agents step-by-step instructions for building full-stack Flutter and Firebase applications.

Genkit Dart Preview

Genkit Dart is now in preview. It is an open-source framework for full-stack AI and agentic apps.

The key characteristics are:

• model-agnostic API,
• support for providers such as Google, Anthropic, and OpenAI,
• type-safe structured output,
• tool calling,
• multi-turn conversations,
• built-in observability,
• server-side and client-side use from Dart/Flutter.

For Flutter teams, the interesting part is not just “call an LLM from Dart.” The interesting part is that Genkit brings agentic application patterns into the Dart ecosystem with production concerns like observability and structured output.

Gemma, LiteRT-LM, and On-Device AI

The Flutter team also highlighted Gemma-related work. Flutter apps won first and second place in the Gemma 3n Impact Challenge:

• Gemma Vision helps visually impaired users perceive the world.
• Vite Vere helps users with cognitive disabilities complete daily tasks.

Both used Flutter to build assistive AI experiences.

The announcement also points toward Gemma 4 and LiteRT-LM support for Flutter. LiteRT-LM is described as Google’s production-ready, high-performance, open-source inference framework. Flutter support is planned through the flutter_gemma package.

The strategic goal is clear: run on-device AI models across Flutter’s six stable platforms with GPU and NPU acceleration where available:

• Android,
• iOS,
• Web,
• Windows,
• Linux,
• macOS.

This is especially important for apps with privacy, latency, cost, or offline requirements. Cloud inference is not always acceptable. Flutter wants a credible path for local inference.

GenUI and A2UI

Flutter 3.44 also leans into Generative UI, or GenUI.

The idea is that AI should not always respond with plain text or Markdown. In some experiences, an agent should construct interactive UI dynamically. Flutter is working with the emerging A2UI protocol, an open-source protocol from Google that defines how an agent and client collaborate on UI composition and state.

The official examples include:

• Hatcha, a social event planning demo where conversational input generates themed invites and planning modules.
• The Gemini app’s Visual Layout experiment, where users explore dynamically generated information through interactive UI.
• Finnish it, an app that dynamically composes lesson UI for language learning.

The practical advice from the Visual Layout experiment is useful:

• use opinionated frameworks for AI consistency,
• use an AI critic loop to improve reliability,
• balance speed and control with templates.

That last point is important. Fully generated UI is exciting, but most production apps still need deterministic components, validation, auditability, and design consistency. The likely future is not “AI generates the whole app every time.” It is more likely “AI chooses, configures, and composes controlled UI primitives.”

4. DevTools and Analysis: Less Friction in Large Projects

Flutter 3.44 improves the development environment in ways that matter more as projects grow.

DevTools now uses WASM by default, which the Flutter team says makes it more responsive. The release also includes stability and performance improvements in DevTools and analysis workflows.

The release notes show tooling work such as migrating flutter analyze to LSP. That kind of change is not exciting on a feature slide, but it matters for large codebases. Analysis is part of the edit loop. When analysis gets slower or inconsistent, productivity suffers immediately.

There are also fixes around web launch errors, flutter.version.json regeneration on upgrade, flutter run -d all, and other command-line reliability details.

The pattern is clear: Flutter 3.44 invests in reducing daily tool friction, not only shipping visible runtime features.

5. Widget Previews: Better Detection, Filtering, and Memory Usage

Widget Previews remain experimental, but Flutter 3.44 makes them more useful.

The biggest change is that preview detection now uses the Dart Analysis Server. Flutter says this can reduce overall memory usage for IDE users by up to 50%.

That matters because preview tooling often fails in practice for boring reasons:

• it uses too much memory,
• it scans too much code,
• it becomes slow in large projects,
• relevant previews are hard to find.

Flutter 3.44 also adds filtering by:

• group,
• name,
• script URI,
• package URI.

The release notes also mention preview fixes such as handling @Preview annotations outside lib/, supporting collections and records in custom preview annotations, and adding search/filtering to the preview scaffold.

For design-system teams, this is one of the more important workflow areas to watch. If Widget Previews become stable and lightweight, Flutter can get closer to the component development ergonomics that web teams expect from Storybook-like workflows.

6. Apple Silicon: Rosetta Is No Longer Required

Flutter 3.44 removes a lingering setup problem for Mac developers: all macOS command-line tools, including iOS device communication binaries, now run natively on Apple Silicon.

That means Apple Silicon developers no longer need Rosetta just to run Flutter tooling.

This update is partly about convenience, but it is also about future-proofing. Apple has already been moving away from Rosetta as a long-term compatibility layer. Flutter’s official announcement also warns that a future Flutter release will end support for Intel x86 Macs entirely.

Teams still using Intel-based Mac hosts for development or CI should treat Flutter 3.44 as a clear migration planning point.

7. Android: Hybrid Composition++ Is a Major Platform View Upgrade

The biggest Android runtime feature in Flutter 3.44 is Hybrid Composition++, usually shortened to HCPP.

This feature targets a long-standing Flutter problem: embedding native Android views inside a Flutter app.

Examples include:

• WebViews,
• maps,
• video views,
• camera previews,
• ad views,
• payment SDK views,
• proprietary Android UI components.

Historically, platform views on Android forced tradeoffs. Older rendering strategies could suffer from:

• screen tearing during scrolling,
• broken or unreliable text input,
• high CPU overhead,
• awkward SurfaceView behavior,
• visual mismatch between Flutter layers and native Android views.

HCPP changes the composition model. Instead of relying on offscreen buffers or making Flutter process native view output itself, HCPP delegates layer compositing more directly to Android OS mechanisms. It uses Vulkan, hardware buffer swapchains, and SurfaceControl transactions to synchronize Flutter UI and native Android views.

The result should be:

• better scrolling performance,
• more accurate touch input,
• more reliable SurfaceView support,
• fewer composition artifacts.

HCPP is opt-in in Flutter 3.44. It can be tested with:

flutter run --enable-hcpp

It can also be enabled in AndroidManifest.xml:

<meta-data
  android:name="io.flutter.embedding.android.EnableHcpp"
  android:value="true" />

There are Android API and hardware requirements, so not every device can use HCPP even when the flag is enabled. Production teams should test it across real devices, especially when an app depends heavily on WebView, maps, ads, or video.

The official post also says HCPP can be tested before it becomes the default rendering mode in the future. That is the key migration signal: global rollout is not required immediately, but validation should start early.

8. Android 17, Googlebook, Display Corner Radii, AGP 9, and ABI Filtering

Flutter 3.44 also includes several Android platform and build-system updates.

Googlebook and Large-Screen Android

The official announcement says Flutter is already prepared for the new Googlebook laptop, powered by Gemini. The point is not a Flutter-specific API so much as a platform positioning claim: Flutter apps that follow Android large-screen guidance should handle trackpads, mouse hover, right-click menus, keyboard shortcuts, and desktop-like interaction more naturally.

This reinforces an important point: Android is no longer just phone UI. Flutter teams should think about Android tablets, foldables, laptop-like devices, and desktop-style input.

Android 17

The Flutter team is testing against Android 17 betas. The announcement specifically mentions work around:

• Local Network Protections,
• safe Dynamic Code Loading,
• general compatibility with upcoming Android changes.

Android app teams should use Flutter 3.44 as a good point to start Android 17 beta testing rather than waiting for the final platform release.

Display Corner Radii

Flutter can now query physical and logical display corner radii on Android and expose that information through MediaQuery.

This helps apps avoid placing important content under aggressively rounded hardware corners. It is a small API surface, but it matters for polished full-screen layouts, games, camera apps, media apps, kiosk apps, and custom shells.

Android Gradle Plugin 9 and Built-In Kotlin

AGP 9 changes Kotlin handling. Before AGP 9, Android apps and plugins often applied the Kotlin Gradle plugin manually. With AGP 9, the Android build system understands Kotlin natively, so manually applying the separate Kotlin Gradle plugin can conflict and break builds.

Flutter 3.44 includes temporary backwards compatibility, but the direction is clear:

• app developers should update Android build files and remove separate Kotlin Gradle plugin application where needed,
• plugin authors need similar Gradle changes,
• plugin authors should update the minimum Flutter constraint to 3.44 when adopting the new behavior,
• support for manually applying KGP will be removed in a future release.

This is one of the upgrade areas most likely to break real projects, especially when an app depends on older plugins.

ABI Filtering

Flutter previously applied ABI filters programmatically to every specific build type. In 3.44, it configures them once in the base defaultConfig block.

Because AGP 9 combines default configuration with build types and flavors rather than simply overriding it, apps with custom abiFilters in build types or product flavors may need:

-Pdisable-abi-filtering=true

This is a niche detail until it becomes a CI failure. Apps with product flavors, custom CPU architecture targets, or separate release/debug ABI behavior should test this carefully.

9. iOS and macOS: Swift Package Manager Becomes the Default

The biggest Apple-platform change in Flutter 3.44 is that Swift Package Manager is now the default dependency manager for iOS and macOS apps.

This is one of the most practically important changes in the release.

For years, Flutter’s iOS ecosystem has depended heavily on CocoaPods. CocoaPods works, but it brings Ruby environment management, local gem versions, CI image concerns, and occasional pod install instability into projects that otherwise may not use Ruby at all.

Starting with Flutter 3.44:

• the Flutter CLI automatically updates the Xcode project to use SwiftPM during build or run,
• teams no longer need to manage Ruby or CocoaPods for the normal path,
• add-to-app projects get a new flutter build swift-package command,
• Flutter modules can be packaged as Swift Packages for native iOS projects.

If an app depends on plugins that still require CocoaPods, the Flutter CLI prints a warning and temporarily falls back to CocoaPods for those dependencies. This fallback is important, but it is not a permanent strategy. The official announcement says CocoaPods support will eventually be removed entirely.

Plugin authors need to add SwiftPM support. Packages with SwiftPM support now receive extra pub.dev scoring points, which should push the ecosystem toward migration.

There is a temporary opt-out:

flutter:
  config:
    enable-swift-package-manager: false

The official blog describes this opt-out as temporary and asks developers to file bugs when SwiftPM breaks a project.

For production teams, the upgrade checklist is clear:

• inspect all iOS/macOS plugins for SwiftPM support,
• test clean checkout builds,
• test CI builds without relying on old CocoaPods setup assumptions,
• test add-to-app flows if applicable,
• keep an eye on plugins that force fallback to CocoaPods,
• report plugin issues upstream early.

10. UIScene and iOS Predictive Text

Flutter 3.44 does not introduce a brand-new UIScene API, but it repeats an important warning: Apple is moving toward requiring the UIScene lifecycle for apps built with the latest SDK.

The Flutter CLI can automatically migrate apps if AppDelegate has not been customized. Apps that customize lifecycle events, deep links, push notification handling, external display behavior, or scene/window behavior need manual migration using the full guide.

This is easy to ignore because it is not a new feature. But it can become a release-blocking App Store issue later.

Flutter 3.44 also adds experimental native iOS inline predictive text support for text input fields. It is off by default and can be enabled with:

TextField.enableInlinePrediction

The feature is still being polished visually. Treat it as something to test in real input-heavy flows, not something to blindly enable everywhere.

11. Web: Accessibility, Safari Autofill, Keyboard Events, Skwasm, and --base-href

Flutter Web does not receive a single giant headline in 3.44, but the release includes several improvements that matter for production web apps.

Accessibility

Flutter Web now has better parity with browser user preferences and accessibility behavior:

• prefers-reduced-motion can automatically disable animations,
• form validation errors can provide immediate screen reader feedback through aria-description,
• non-interactive leaf semantics nodes are handled more appropriately,
• accessibility feature handling is cleaned up internally.

These changes matter because Flutter Web is often criticized for not feeling like a normal web platform citizen. Better accessibility behavior is part of closing that gap.

Browser and Platform Behavior

The engine improves iOS 26 Safari autofill by reusing DOM forms across focus shifts. It also refines web scrolling and keyboard event synthesis.

The release notes include fixes for:

• key-up events being synthesized too eagerly,
• occasional failure to find a Chrome tab,
• Skwasm crashes with non-transferable texture sources,
• asynchronously disposed platform views,
• CanvasKit/Skwasm garbage collection unification,
• web rendering concurrency and stability.

Tooling

flutter run now supports --base-href for web. This makes local runs align better with production deployments where the app is served from a subpath.

The release notes also mention a fix for flutter build web ignoring --web-define.

For Flutter Web teams, the upgrade advice is direct: do not validate the upgrade by loading only the home page. Test:

• browser autofill,
• keyboard input,
• screen reader behavior,
• reduced-motion settings,
• deep links under production base paths,
• platform views,
• CanvasKit/Skwasm rendering paths,
• copy/paste and text selection.

12. Desktop: Canonical Takes a Larger Role

Flutter Desktop receives one of the biggest governance announcements in 3.44: Canonical is now the lead maintainer and Strategic Steward for Flutter Desktop.

Canonical will lead the Flutter Desktop roadmap and oversee maintenance of the Linux, Windows, and macOS embedders.

This matters because desktop support is not only about APIs. It requires long-term work on embedders, windowing, input, accessibility, packaging, platform conventions, and native integration. Having a named strategic steward makes the roadmap more credible.

Experimental Windowing APIs

Flutter’s experimental windowing APIs continue to move forward, but the official announcement is clear: these features are currently available only on the main channel and are not intended for production use yet.

New work includes:

• tooltip windows across Linux, macOS, and Windows,
• popup windows on macOS, with Linux and Windows expected later,
• showDialog creating a separate child dialog window on platforms that support windowing,
• content-sized views on Linux.

This is important for desktop apps because mature desktop UI cannot treat everything as a single full-window canvas. Real desktop apps need menus, popups, tooltips, child dialogs, floating panels, and native-feeling window behavior.

Windows Stylus Support

Flutter Windows now supports stylus input, including rotation and pressure sensitivity.

That matters for:

• drawing apps,
• note-taking apps,
• whiteboards,
• design tools,
• education software,
• signature capture,
• field workflows on Windows tablets.

It is also another sign that Flutter Desktop is moving beyond “the app launches on desktop” toward deeper platform input support.

13. Embedded: Toyota RAV4 and LG webOS

Flutter 3.44 makes Flutter’s embedded story more visible.

Toyota RAV4

The official announcement says the 2026 Toyota RAV4 uses Flutter to power its multimedia system. This is a significant public embedded reference because automotive systems have very different constraints from phone apps:

• long hardware lifecycles,
• strict performance expectations,
• safety-adjacent UX requirements,
• slow update cycles,
• manufacturer-specific integration,
• multiple screen sizes and input modes.

Flutter being used in a high-volume vehicle multimedia system is a strong signal for embedded credibility.

LG webOS

LG is preparing a webOS SDK that will let developers build Flutter apps for webOS devices. The SDK is expected to include plugin support for Firebase, video players, gamepads, and more, while preserving familiar Flutter features such as stateful hot reload and Riverpod-based state management.

This matters because TV and living-room devices are not just “large web screens.” They require remote input, media playback, focus handling, performance constraints, and platform-specific plugin support.

Together, Toyota and LG show Flutter expanding into device categories where native UI stacks are usually fragmented and expensive to maintain.

14. Graphics and Engine: Impeller, Vulkan, SDFs, and Fragment Shaders

Flutter 3.44 includes targeted rendering and performance work, especially around Impeller.

Vulkan Improvements

The release includes better cache memory management and more efficient GPU/CPU synchronization when frames are being dropped.

This matters for apps that stress rendering:

• maps,
• charts,
• games,
• animation-heavy interfaces,
• video-adjacent UI,
• custom painting,
• embedded displays.

Dropped frames are not only a visual issue. Poor synchronization can make recovery worse, causing jank to compound.

Cleaner Circles with Signed-Distance Functions

Flutter updated circle rendering math to use signed-distance functions for cleaner, anti-aliased circles. Previous cases where circles could appear aliased have been addressed.

This sounds small, but visual polish in UI frameworks is often built from exactly this kind of detail. Buttons, avatars, indicators, charts, masks, and decorative elements all depend on clean geometry.

Shadow and Perspective Fixes

Impeller also improves handling of perspective matrices, shadows, and perspective projection transforms.

Apps using transforms, 3D-like effects, shadow-heavy surfaces, or custom rendering should regression test this area.

FragmentShader Improvements

Fragment shader setup is easier because uniforms can now be bound by name instead of manual offsets:

void setUp(ui.FragmentShader shader) {
  shader.getUniformFloat('foobar').set(1.234);
}

This reduces one of the annoying sources of shader bugs: keeping Dart-side offset assumptions aligned with shader-side uniform declarations.

The shader compiler also warns when shaders are not compatible with Skia, which helps catch cross-platform rendering problems before shipping.

15. Framework: Material and Cupertino Are Being Decoupled

The biggest long-term framework change in Flutter 3.44 is the freeze of Material and Cupertino inside the core framework.

The official announcement says this release is the final set of updates to those libraries inside the core framework before the move to standalone packages:

• material_ui,
• cupertino_ui.

By the next stable release, the current in-framework versions are expected to be deprecated, and teams will be able to migrate to independently versioned packages.

This is strategically important.

Today, Flutter framework upgrades and design-system-library upgrades are tightly coupled. Once Material and Cupertino become independent packages, both libraries can evolve on independent release cadences. This can make Flutter core smaller, reduce coupling, and allow UI libraries to move without requiring every framework upgrade to carry those changes.

The migration risk is not immediate for most apps, but teams should start preparing:

• search for direct imports from package:flutter/material.dart and package:flutter/cupertino.dart,
• identify internal design-system wrappers,
• avoid deep coupling to implementation details,
• watch package migration guidance,
• test analyzer warnings early when deprecations appear.

Final In-Framework Updates

Even though Material and Cupertino are frozen for future core updates, 3.44 includes several important refinements:

• CupertinoMenuAnchor built on RawMenuAnchor,
• Material 3 animations for MenuAnchor,
• SubmenuButton.hoverOpenDelay,
• better CupertinoSheetRoute coordination between scrolling and dragging,
• scrollableBuilder for custom sheet scroll behavior,
• CarouselView infinite scrolling,
• CarouselView.onIndexChanged,
• leadingItem on the carousel controller,
• ShapedInputBorder,
• ThemeMode.isDark, ThemeMode.isLight, and ThemeMode.isSystem,
• NavigationRail.mainAxisAlignment,
• DropdownMenu.scrollPadding,
• better assertions and semantics fixes across Material widgets.

For app teams, these are mostly incremental API and polish improvements. For framework architecture, the package split is the bigger story.

16. Accessibility and Layout Resilience

Flutter 3.44 includes a meaningful set of accessibility and resilience improvements.

iOS Motion and Preference Features

Flutter exposes more iOS accessibility preferences through AccessibilityFeatures, including:

• reduced motion,
• cross-fade preference,
• disabling animated image auto-play,
• disabling video preview auto-play,
• preference for a non-blinking cursor.

These help apps respect user preferences instead of forcing motion or animation defaults.

Progress and Slider Semantics

Progress indicators can now use percentage strings such as "50%" as a SemanticsValue, allowing screen readers to announce progress more naturally.

Slider semantics have also been improved so the semantics node better reflects size and position, helping users who navigate by touch exploration or assistive devices.

Scroll and Invisible Semantics Fixes

Flutter fixes cases where invisible accessibility elements could be presented before scrollable content. That should make assistive navigation more predictable.

0x0 Widget Resilience

A large effort went into making core widgets resilient when rendered in zero-width or zero-height environments. Previously, some widgets could crash or throw layout errors when constrained to 0x0.

The release notes show broad work in this area, including widgets such as:

• EditableText,
• Container,
• Expansible,
• CupertinoTabScaffold,
• FlutterLogo,
• LongPressDraggable,
• DisplayFeatureSubScreen,
• DragTarget,
• FormField,
• Banner,
• ErrorWidget,
• FocusScope,
• Hero,
• Icon,
• AnimatedPadding,
• GridPaper.

This matters in complex layouts, transitions, tests, previews, adaptive UIs, and edge cases where widgets are temporarily constrained during measurement or animation.

SelectableRegion Fixes

SelectableRegion gets two important fixes:

• On web, it now passes layout constraints through to children without unexpected shrinking.
• Multiline copy preserves line breaks when selected text spans multiple lines.

Text selection is a basic interaction. Fixes like this are especially important for documentation apps, admin tools, editors, chat apps, and data-heavy interfaces.

17. Breaking Changes and Deprecations

Flutter 3.44 includes several changes that teams should treat as upgrade checklist items.

RawMenuAnchor Callback Order

Some RawMenuAnchor callback ordering has changed to make close behavior more flexible and predictable.

Apps with custom menu behavior, especially nested menus or analytics tied to open/close callbacks, should test this behavior.

CupertinoSheetRoute Deprecations

builder and pageBuilder parameters in showCupertinoSheet and CupertinoSheetRoute are deprecated in favor of scrollableBuilder.

The reason is better integration between scrollable content and sheet dragging.

ReorderableListView Callback Deprecation

ReorderableListView.onReorder is deprecated in favor of onReorderItem.

The new callback provides a more predictable newIndex because it accounts for the item being removed before reinsertion.

Apps that persist list order, sync order to a backend, or use reorder events for analytics should test this carefully.

Tooling Deprecations

The --web-hot-reload flag is deprecated because Flutter Web hot reload now uses newer mechanisms.

The plugin_ffi template is deprecated in favor of the more robust plugin template with FFI support.

SwiftPM and CocoaPods Transition

SwiftPM default behavior is not exactly a breaking change because Flutter includes fallback paths, but it is a practical migration event. Any app with native Apple plugins should treat it as a real upgrade area.

AGP 9 and Kotlin

The Android Gradle Plugin 9 built-in Kotlin behavior can break projects or plugins that still apply KGP manually. Flutter includes temporary compatibility, but teams should migrate instead of depending on that forever.

18. What Community Coverage Focused On

Community coverage around Flutter 3.44 largely agreed on the core story.

Very Good Ventures emphasized Agentic Hot Reload, Google I/O positioning, Chrome APIs relevant to Flutter Web, GenUI, and the ecosystem signal that Flutter is now the number two SDK on both major app stores.

Sagnik Bhattacharya’s deep-dive coverage framed 3.44 as a release that looks quiet only when evaluated by a single headline feature. The practical story is distributed across SwiftPM, Android build/runtime changes, Web, tooling, framework fixes, and migration risks.

Daily.dev and other summaries highlighted Hybrid Composition++, SwiftPM, Impeller/Vulkan improvements, Agentic Hot Reload, Agent Skills, and Genkit Dart.

Reddit discussion reflected two recurring themes:

• developers are relieved to see SwiftPM replacing CocoaPods as the default path,
• the Google I/O presentation helped counter recurring fears that Flutter is being abandoned.

The community reaction is useful because it separates the official marketing layer from developer pain points. The features developers immediately noticed were not decorative widgets. They were tooling, platform integration, native dependency management, and proof of continued investment.

19. Upgrade Checklist for Production Apps

Use this checklist before upgrading a serious app to Flutter 3.44.

General

• Run the full test suite on Flutter 3.44.
• Run flutter analyze and compare new warnings.
• Verify IDE performance and analysis behavior on large workspaces.
• Recreate a clean development environment from scratch.
• Test flutter clean followed by fresh builds.
• Check generated files and lockfiles.

iOS and macOS

• Confirm SwiftPM migration succeeds.
• Identify plugins that still trigger CocoaPods fallback.
• Test CI without assuming CocoaPods is the only path.
• Test add-to-app when a native iOS project embeds Flutter.
• Verify code signing and Xcode project changes.
• Check whether the project still needs the temporary SwiftPM opt-out.
• Validate UIScene migration if AppDelegate is customized.
• Test text input if enabling inline prediction.

Android

• Test platform views with and without HCPP.
• Test WebView, maps, ads, camera, video, and payment SDK views.
• Validate touch input and scrolling on real devices.
• Check Android 17 beta behavior for apps targeting upcoming Android releases.
• Review AGP 9 and Kotlin Gradle plugin usage.
• Audit plugins that apply KGP manually.
• Check custom ABI filters and flavors.
• Test display corner radius behavior in full-screen layouts.

Web

• Test reduced-motion behavior.
• Test screen reader feedback for form errors.
• Test Safari autofill, especially on iOS 26.
• Test keyboard input and key-up behavior.
• Test deep links with production base-href.
• Test CanvasKit and Skwasm rendering paths.
• Test text selection and multiline copy.

Desktop

• Track Canonical-led desktop roadmap updates.
• Avoid production dependence on main-channel-only windowing APIs.
• Test tooltips, popups, and dialogs if experimenting with windowing.
• Test stylus pressure and rotation on Windows if relevant.
• Test accessibility and keyboard navigation on all desktop targets.

UI Framework

• Search for Material/Cupertino imports and wrapper layers.
• Track material_ui and cupertino_ui migration guidance.
• Test menus, sheets, carousels, navigation rails, dropdowns, and reorderable lists.
• Update code using deprecated CupertinoSheetRoute parameters.
• Plan migration from onReorder to onReorderItem.

Graphics

• Test Impeller-heavy screens.
• Test shader-heavy screens.
• Check transformed shadows and perspective effects.
• Test charts, avatars, circular clipping, and custom painted geometry.
• Watch shader compiler warnings for cross-backend compatibility.

20. Final Take

Flutter 3.44 is a major release, but not because of one flashy screenshot-friendly feature.

It is major because it moves Flutter on several strategic axes at once:

• from manual coding workflows toward agent-assisted workflows,
• from CocoaPods toward SwiftPM,
• from older Android platform-view tradeoffs toward HCPP,
• from mobile-only perception toward desktop, embedded, TV, and automotive,
• from monolithic framework UI libraries toward decoupled packages,
• from cloud-only AI assumptions toward local and cross-platform AI infrastructure,
• from “Flutter Web exists” toward more serious browser behavior and accessibility,
• from desktop availability toward desktop stewardship.

The upgrade is worth taking seriously. Teams should not rush it blindly, especially when projects depend on iOS/macOS plugins, Android platform views, custom Gradle setups, Flutter Web, or complex Material/Cupertino wrappers.

But the direction is strong. Flutter 3.44 is not just a framework update. It is a platform signal: Flutter wants to be the UI layer for modern apps across screens, devices, agents, and embedded environments.

References

• What’s new in Flutter 3.44
• Flutter 3.44.0 release notes
• Google I/O 2026: What’s new in Flutter
• Flutter 3.44 at Google I/O 2026: What We Saw at the Conference
• Flutter 3.44 Deep Dive: SwiftPM, Android, Web, and Tooling Changes
• Flutter 3.44 Upgrade Checklist: What to Check Before You Ship