flutter/flutter

This system is the Flutter engine and framework codebase, serving as the core runtime and UI toolkit for building cross-platform applications. It provides the underlying rendering engine, platform embedding logic for Android, iOS, macOS, Windows, Linux, and Web, and a comprehensive widget library. The repository also includes extensive infrastructure for performance benchmarking, accessibility validation, and continuous integration testing to ensure stability and quality across all supported platforms.

93 changes.

This period focused on upgrading the framework to Material Design 3 as the default theme and modernizing platform integrations by raising minimum iOS and Android deployment targets. Significant work included migrating examples and benchmarks to the Android Embedding v2 and iOS UIScene lifecycle, while also introducing new testing infrastructure for platform channels, build flavors, and UI interactions.

156 changes.

This period focused on migrating the Flutter codebase and its test suites to modern platform standards, including the Android v2 embedding, iOS UIScene lifecycle, and Xcode 15.1 compatibility. It also involved expanding the integration testing ecosystem with new tools for Fuchsia debugging, Skia Gold visual regression, and comprehensive benchmarks for platform views and web performance.

95 changes.

This period focused on modernizing the continuous integration infrastructure by refactoring bot scripts into modular components and introducing a real-time static analysis plugin. It also significantly expanded the integration test suite, adding comprehensive coverage for new features like windowing, accessibility, and platform channels across all supported desktop and mobile platforms.

22 changes.

This period focused on expanding the integration test suite with new applications for data assets, record-use tree-shaking, wide-gamut color support, and visual regression on Android hardware. Concurrently, the project introduced a suite of autonomous agent configurations and skills to automate development workflows such as browser upgrades, cherry-picks, and engine release summaries.

The \dev/tracing\_tests/android\ directory now includes the standard Android application structure required to build and run the tracing tests on Android devices. This addition introduces the \AndroidManifest.xml\ files for debug, profile, and main configurations (including the INTERNET permission), a Kotlin \MainActivity\ extending \FlutterActivity\, resource files for light and dark mode launch themes, and a \.gitignore\ file to exclude build artifacts and sensitive keys. These files provide the necessary Android-side scaffolding for the tracing test suite.

_dev/tracing\tests/android · high confidence

The platform\_view example now includes a native Android activity that can be launched from the Flutter view. This activity displays a counter and a button to return to Flutter, demonstrating how to pass data between Flutter and native Android code using MethodChannel and Intents.

_examples/platform\view/android · high confidence

A new integration test app has been added at dev/integration\_tests/pure\_android\_host\_apps/android\_host\_app\_v2\_embedding to support the 'add to app' workflow using the V2 Android embedding. This test host app, which extends FlutterActivity and is used by the build\_android\_host\_app\_with\_module\_aar.dart device lab test, includes its own AndroidManifest, MainActivity, and Gradle wrapper configuration.

_dev/integration\_tests/ios\_app\_with\_extensions, dev/integration\_tests/platform\_interaction/ios/Runner.xcodeproj, dev/integration\_tests/pure\_android\_host\_apps/android\_host\_app\_v2\embedding · high confidence

The platform views layout benchmark now includes a complete Android application structure, featuring a \DummyPlatformViewActivity\ and \DummyPlatformViewFactory\ to exercise platform view integration. The \AndroidManifest.xml\ explicitly sets the Flutter embedding to version 2 and disables the HCPP (Hardware Composer) feature flag to ensure consistent benchmark conditions. Additionally, Gradle dependency lockfiles are added to stabilize the build environment.

_dev/benchmarks/platform\_views\layout/android · high confidence

A new benchmark suite for measuring Android platform view performance in hybrid composition mode has been added. It includes a scrolling benchmark that runs via \flutter drive\ and a startup benchmark via \flutter run\, providing timeline and startup logs for performance analysis. The implementation uses \PlatformViewLink\ and \initExpensiveAndroidView\ to embed native Android views within a Flutter \ListView\, alongside a rotating container widget to stress test layout composition.

_dev/benchmarks/platform\_views\_layout\_hybrid\composition · high confidence

The a11y\_assessments sample app now includes its Android project structure, providing a standard Flutter Android template with a Kotlin-based MainActivity, debug and profile AndroidManifest files with internet permissions, and light/dark theme launch backgrounds. The addition also includes Gradle dependency lockfiles (AGP 9.1.0, Kotlin 2.4.0) and a .gitignore to ensure consistent builds and proper source control hygiene for this sample.

_dev/a11y\assessments/android · high confidence

The dev/devicelab directory now includes a README.md file that documents the DeviceLab testing framework, including how tests are executed on physical devices, instructions for running tests locally, and guidance for writing and integrating new tests into continuous integration and presubmit workflows.

dev/devicelab · high confidence

A new Flutter example application has been added to the benchmarks directory to serve as a baseline for comparing performance against an equivalent SwiftUI implementation. The app implements an infinite scrolling list that dynamically loads static data, providing a concrete reference point for cross-platform performance analysis.

_dev/benchmarks/imitation\_game\flutter · high confidence

A new integration test host app located at dev/integration\_tests/pure\_android\_host\_apps/host\_app\_kotlin\_gradle\_dsl has been added to support Android applications that use the Kotlin DSL for Gradle build files. This minimal app, which includes a Compose-based MainActivity and standard Android resources, serves as a test fixture to verify add-to-app functionality when the host project is configured with .kts Gradle scripts rather than the traditional Groovy DSL.

_dev/integration\_tests/pure\_android\_host\_apps/android\_custom\_host\_app/SampleApp, dev/integration\_tests/pure\_android\_host\_apps/host\_app\_kotlin\_gradle\dsl · high confidence

The record\_use test application now includes the necessary build configuration and entry points for Linux and Web platforms. On Linux, CMake build files and GTK-based native runner code have been added to support building and running the app on desktop Linux environments. For Web, standard index.html and manifest.json files have been introduced to enable browser-based execution and PWA capabilities. These changes allow the test app to be used for integration testing across these additional platforms.

_dev/integration\_tests/record\_use\_test\_app/linux, dev/integration\_tests/record\_use\_test\app/web · high confidence

The Linux desktop target for the flavors integration test has been added, providing the necessary CMake build configuration and GTK-based native runner code to build and run the test application on Linux. This includes the project-level CMakeLists.txt, the Flutter ephemeral build rules, and the C++ application entry point that initializes the GTK window and registers plugins.

_dev/integration\tests/flavors/linux · high confidence

The UI integration test now includes the necessary Linux runner files (CMakeLists.txt, main.cc, and application source) to build and execute on Linux desktop environments. This enables the test suite to run on Linux, allowing developers to verify UI behavior on this platform alongside macOS and Windows.

_dev/integration\tests/ui/linux · high confidence

The Flutter Gallery example now includes the necessary Linux build files (CMakeLists.txt, main.cc, my\_application.cc/h) and configuration to run on Linux. This addition enables users to build and run the gallery application on Linux desktop environments using GTK, expanding the example's cross-platform coverage alongside its existing Windows support.

_dev/integration\_tests/flutter\gallery/linux · high confidence

A new Xcode project (Host.xcodeproj) has been added to the \dev/integration\_tests/ios\_host\_app\_swift\ directory to serve as the iOS host application for Swift-based integration tests. This project includes standard iOS application files (AppDelegate, SceneDelegate, ViewController), CocoaPods configuration, and a build script to run the Flutter 'hello' integration test, enabling the test suite to execute within a native Swift environment.

_dev/integration\_tests/ios\_host\_app, dev/integration\_tests/ios\_host\_app\swift/Host.xcodeproj · high confidence

A new SwiftUI-based benchmark app (\hello\_world\_swiftui\) has been added to the \dev/benchmarks/imitation\_game\_swiftui\ directory to serve as a performance comparison against an equivalent Flutter application. The project includes an infinite-scrolling list interface, an Xcode project configuration, and a dedicated \BenchmarkTests\ suite that measures the time to first frame upon application launch.

_dev/benchmarks/imitation\_game\swiftui · high confidence

Adds the complete Windows desktop runner implementation for the manual\_tests application, including the CMake build configuration, Win32 window management, and Flutter view hosting. This enables developers to build and run the manual tests on Windows, with support for high-DPI scaling, dark mode theming, and proper console attachment for debugging.

_dev/manual\tests/windows/runner · high confidence

This change adds the native Windows build files (CMakeLists.txt, runner sources, and resources) for the \dev/integration\_tests/flavors/windows\ directory, enabling the flavors integration test to be built and executed on the Windows desktop platform.

_dev/integration\tests/flavors/windows · high confidence

A new Windows platform implementation has been added to the \record\_use\_test\_app\ integration test. This includes the CMake build configuration, the native Win32 window runner (handling DPI scaling, dark mode, and console attachment), and the necessary resource files. This enables the test application to be built and executed on Windows, extending the test coverage for the \record\_use\ feature to the Windows desktop platform.

_dev/integration\_tests/record\_use\_test\_app/windows, dev/integration\_tests/windowing\_test/linux, dev/integration\_tests/windowing\test/windows · high confidence

The Windows runner source files for the \dev/integration\_tests/ui\ test application have been added, providing the native entry point, window management, and build configuration required to run the UI integration tests on Windows. This includes the CMake build script, the Win32 window abstraction with DPI awareness and dark-mode support, the Flutter window controller, and utilities for console attachment and command-line argument handling.

_dev/integration\tests/ui/windows/runner · high confidence

The Flutter Gallery example now includes a native Windows runner, allowing the app to be built and executed on Windows. This adds the necessary CMake build configuration, a Win32 window implementation that supports high-DPI scaling and dark mode theming, and utility code for console attachment and command-line argument handling.

_dev/integration\_tests/flutter\gallery/windows/runner · high confidence

The iOS integration test example project now includes a defined Xcode scheme (Runner.xcscheme) that configures the build, test, launch, profile, analyze, and archive actions for the Runner app. This enables developers to run and debug the UI integration tests directly within Xcode, with launch actions configured to enable GPU validation mode and use the LLDB debugger.

_dev/integration\_tests/platform\_interaction/ios/Runner.xcodeproj/xcshareddata, dev/integration\tests/ui/ios/Runner.xcodeproj/xcshareddata · high confidence

The flutter\_view example has been added to demonstrate how to communicate between Flutter and the host platform using a BasicMessageChannel. The app displays a counter that increments when a button is pressed, sending a message to the platform side which triggers the update in the UI.

_examples/flutter\view · high confidence

The flutter\_view example now includes generated Gradle dependency lockfiles that pin the Android build toolchain to AGP 9.1.0 and Kotlin 2.4.0, ensuring reproducible builds for this embedding sample.

examples · high confidence

A new test harness has been added at dev/forbidden\_from\_release\_tests that compiles a Flutter application to the AOT format used for release builds and verifies that debugging-related types are not retained in the output. The tool accepts a V8 snapshot file and a list of forbidden type names via command-line arguments, checking the compiled binary to ensure these specific types have been stripped. This helps prevent accidental inclusion of debug-only code in production releases.

_dev/forbidden\_from\_release\tests · high confidence

A new Flutter module project has been added to the integration tests suite to verify app lifecycle state transitions on iOS. The module includes a test widget that spies on the sequence of AppLifecycleState changes (detached, inactive, resumed) and uses a custom SwitchableSemanticsBinding to signal test success to the native iOS host by re-enabling semantics when the expected lifecycle sequence is observed.

_dev/integration\_tests/ios\_add2app\_life\cycle/flutterapp · high confidence

The integration test suite now includes a new iOS Xcode project (\Runner.xcodeproj\) designed to validate app flavor support. This project defines two distinct application targets, "Free App" and "Paid App", each with its own Info.plist (\Info-Free.plist\ and \Info-Paid.plist\) and build configurations. The project structure incorporates CocoaPods dependencies for both flavors and links the \FlutterGeneratedPluginSwiftPackage\, ensuring that the build system correctly handles separate resource and framework bundling for different app variants.

_dev/integration\tests/flavors/ios/Runner.xcodeproj · high confidence

The iOS benchmark runner now includes explicit LaunchScreen.storyboard and Main.storyboard files. The launch screen displays a centered image, while the main storyboard initializes the FlutterViewController as the root view controller, ensuring the app launches correctly on iOS devices during macrobenchmark execution.

dev/benchmarks/macrobenchmarks/ios/Runner/Base.lproj · high confidence

The iOS runner for the platform views layout hybrid composition benchmark now includes the standard LaunchScreen.storyboard and Main.storyboard files. These additions provide the necessary interface builder definitions for the app's launch screen and initial Flutter view controller, ensuring the benchmark project builds and runs correctly on iOS devices and simulators.

_dev/benchmarks/platform\_views\_layout/ios/Runner/Base.lproj, dev/benchmarks/platform\_views\_layout\_hybrid\composition/ios/Runner/Base.lproj · high confidence

The platform interaction integration test now includes the necessary iOS interface files (LaunchScreen.storyboard and Main.storyboard) to properly initialize the test application. These files define the initial view controller hierarchy, including a Flutter view controller and a test navigation controller, ensuring the app launches correctly during integration testing.

_dev/integration\_tests/platform\interaction/ios/Runner/Base.lproj · high confidence

The iOS Xcode project for the UI integration test runner has been added, establishing the native build configuration required to execute end-to-end UI tests on iOS devices. This includes the standard Runner target structure with CocoaPods support, necessary build phases (Sources, Frameworks, Resources, Embed Frameworks, Thin Binary), and configuration files (Debug, Release, Generated, and Pods xcconfigs) to ensure the test app builds and runs correctly within the Flutter development environment.

_dev/integration\tests/ui/ios/Runner.xcodeproj · high confidence

The iOS side of the platform interaction integration test suite is now implemented with native code. The Runner app's AppDelegate conforms to FlutterImplicitEngineDelegate to support implicit engine initialization, and a custom TestNavigationController sends a 'ping' message via a FlutterBasicMessageChannel when popping the navigation stack, enabling the test harness to verify platform channel communication from the native side.

_dev/integration\_tests/platform\interaction/ios/Runner · high confidence

A new integration test application has been added to verify iOS platform view behavior, including focus handling, z-ordering, and interaction with context menus and scrollable lists. The app provides dedicated test pages for platform view focus, z-order tests, web view interactions behind context menus, AdMob banner gesture handling in scrollable lists, and reorderable list semantics.

_dev/integration\_tests/android\_verified\_input/android, dev/integration\_tests/ios\_platform\_view\_tests, dev/integration\_tests/platform\interaction · high confidence

The iOS runner for the platform views layout benchmark has been added, providing a native host application to measure platform view performance. The implementation registers a custom DummyPlatformView factory within the AppDelegate to create and manage platform views, and the Info.plist is configured to enable embedded view previews and Metal rendering. Additionally, the project adopts the UIScene lifecycle via a scene manifest and enables CADisableMinimumFrameDurationOnPhone to ensure consistent frame timing during benchmarking.

_dev/benchmarks/platform\_views\layout/ios/Runner · high confidence

The Flutter Gallery integration test now includes the standard iOS LaunchScreen and Main storyboards for the Runner target. These files define the initial view controller hierarchy and ensure the app launches correctly on iOS devices within the test environment.

_dev/integration\_tests/flutter\gallery/ios/Runner/Base.lproj · high confidence

An iOS test application has been added to the \dev/integration\_tests/record\_use\_test\_app\ directory to support the new \record\_use\ experimental feature. This project includes a standard Xcode workspace configuration, a \Runner\ target with Swift-based \AppDelegate\ and \SceneDelegate\ implementations, and a \RunnerTests\ unit test bundle. The \AppDelegate\ is configured to implement \FlutterImplicitEngineDelegate\, ensuring that plugins are registered with the implicit Flutter engine upon initialization, which is required for the feature's integration tests.

_dev/integration\_tests/record\_use\_test\app/ios · high confidence

The platform views layout benchmark now includes the necessary iOS workspace files (contents.xcworkspacedata, IDEWorkspaceChecks.plist, and WorkspaceSettings.xcsettings) to properly configure the Xcode workspace for the benchmark target.

_dev/benchmarks/platform\_views\layout/ios/Runner.xcodeproj/project.xcworkspace · high confidence

Added a new integration test project in \dev/integration\_tests/flavors\ to verify the functionality of build flavors (Android product flavors and Xcode schemes). The test app displays the current flavor name on screen, allowing automated tests to confirm that the correct flavor is being built and detected across different platforms.

_dev/integration\tests/flavors · high confidence

The manual tests macOS runner now includes the necessary Xcode configuration files (AppInfo.xcconfig, Debug.xcconfig, Release.xcconfig, and Warnings.xcconfig) and the MainMenu.xib interface file. These additions define the application bundle identifier (dev.flutter.manualTests), product name, copyright, and compiler warning settings, enabling the manual tests to be built and run as a native macOS application.

_dev/manual\tests/macos/Runner/Configs · high confidence

The macOS side of the windowing\_test integration test now includes a complete Xcode project (Runner), enabling the test to build and run as a native macOS application. This adds the necessary build configuration, entitlements, and source files to support the test on macOS.

_dev/integration\_tests/windowing\test/macos · high confidence

The macOS UI integration test project now includes a defined Xcode scheme (Runner.xcscheme) that configures how the \ui.app\ target is built, tested, launched, profiled, analyzed, and archived. This enables developers to run UI integration tests and performance profiling directly within Xcode for the macOS platform.

_dev/integration\tests/ui/macos/Runner.xcodeproj/xcshareddata · high confidence

The \darwin\_add2app\_swiftpm\ integration test now includes complete Xcode project structures for both macOS and iOS native host applications. These new template projects demonstrate how to embed a Flutter engine within a native app using Swift Package Manager, featuring the necessary \AppDelegate\ implementations to initialize the Flutter engine and register plugins, along with standard Xcode project files, asset catalogs, and storyboards.

_dev/integration\_tests/darwin\_add2app\swiftpm · high confidence

Adds a new macOS project under \dev/integration\_tests/flavors\ to serve as an integration test for the Flutter flavors feature. The project is configured with Xcode schemes for 'free' and 'paid' flavors, includes an \AppDelegate\ that supports secure restorable state, and implements a method channel in \MainFlutterWindow.swift\ to expose the current flavor to the application.

_dev/integration\_tests/flavors/macos, dev/integration\tests/ui/macos/Runner.xcodeproj · high confidence

A new macOS Runner project has been added to the UI integration tests to validate platform-specific behaviors. The application is configured with modern Swift entry points (@main) and enables secure restorable state by default. It includes a method channel implementation that allows the test suite to programmatically resize the main window, facilitating UI tests that depend on dynamic layout changes.

_dev/integration\tests/ui/macos/Runner · high confidence

The macOS manual test project now includes a complete Runner configuration that adopts the modern @main entry point and enables secure restorable state by default. The app delegate explicitly supports secure restorable state and ensures the application terminates after the last window closes. Additionally, the project configures app sandboxing via DebugProfile and Release entitlements, with JIT and network server permissions enabled for the debug profile to support development workflows.

_dev/manual\tests/macos/Runner · high confidence

A new macOS sample application named 'a11y\_assessments' has been added to the development tools, providing a complete Xcode project structure (including the Runner target, build configurations, and entitlements) to facilitate accessibility testing on macOS. The app is configured to support secure restorable state by default and includes a basic XCTest suite for future test coverage.

_dev/a11y\assessments/macos · high confidence

A new macOS test application (record\_use\_test\_app) has been added to the integration tests directory to support the record\_use feature. This includes the full Xcode project structure, Swift source files for the app delegate and main window, and a basic unit test target, providing the necessary host environment to exercise the record\_use experimental functionality on macOS.

_dev/benchmarks/macrobenchmarks/macos/Runner, dev/benchmarks/macrobenchmarks/macos/Runner.xcodeproj, dev/integration\_tests/record\_use\_test\app/macos · high confidence

New entry-point scripts have been added to the test\_memory benchmark suite to measure memory usage for specific UI scenarios. The heavy\_gridview.dart script now runs the heavy grid view route, while large\_images.dart runs the large images route; both wait for animation frames to settle before printing a ready signal, enabling targeted memory profiling for these intensive widgets.

_dev/benchmarks/macrobenchmarks/test\memory · high confidence

A new integration test application has been added to verify Flutter platform channel communication. The app exercises BasicMessageChannel and MethodChannel interactions using various codecs (Binary, String, JSON, Standard) and payloads, including support for background isolates and custom codec extensions. It validates message handshakes, error handling, and unknown channel behavior across different data types.

_dev/integration\tests/channels · high confidence

A new benchmark harness has been added to measure the performance of Platform Channels. This includes tests for BasicMessageChannel with StandardMessageCodec (sending small and large payloads) and BinaryCodec (sending large payloads), allowing developers to track latency in microseconds for Flutter-to-host communication.

_dev/benchmarks/platform\_channels\benchmarks · high confidence

The examples/layers/rendering directory now includes new source files demonstrating advanced rendering concepts. binding.dart introduces ViewRenderingFlutterBinding, a custom binding that manages a dedicated RenderView and handles semantics initialization, simplifying bootstrapping for apps with a main view. sector\_layout.dart defines a polar coordinate rendering system, including SectorConstraints, SectorDimensions, and RenderSector classes for layout and hit-testing in radial space. solid\_color\_box.dart provides a simple RenderDecoratedBox example that changes color on pointer events and demonstrates intrinsic dimension calculations.

examples/layers/rendering · high confidence

A new example application has been added to the examples/texture directory that demonstrates how to create and manipulate a native texture within a Flutter app. The example uses a MethodChannel to invoke platform-specific code for creating a texture and setting its color, displaying the result in a UI with buttons to change the texture's color to various predefined shades.

examples/texture · high confidence

A new command-line tool, vitool, is available in dev/tools/vitool/bin to generate Dart code for animated vector icons. Users can provide a list of SVG frame files, and the tool will produce a Dart file containing the necessary data structures (wrapped in an \_AnimatedIconData class) to support animated icon rendering. The tool supports options to specify the output path, asset name, library part-of directive, and a custom header file to prepend to the generated code.

dev/tools/vitool/bin · high confidence

The integration test located at dev/integration\_tests/ios\_app\_with\_extensions/ios/watch Extension now includes the necessary source files and asset catalogs to build a watchOS app extension. This addition provides the SwiftUI ContentView, ExtensionDelegate, and HostingController, along with the required Info.plist and complication asset definitions, enabling the test suite to verify the build and structure of a companion watchOS extension.

_dev/integration\_tests/ios\_app\_with\extensions/ios/watch Extension · high confidence

The a11y\_assessments sample app now includes the necessary web entry point files (index.html, manifest.json, and flutter\bootstrap.js) to run in a browser. The bootstrap configuration uses a local CanvasKit bundle to reduce test flakiness and exposes a debug flag for visualizing semantic nodes. The HTML and manifest define the app as a standalone PWA with mobile-web-app-capable support, though the meta tags still use the legacy apple-mobile-web-\ naming convention.

_dev/a11y\assessments/web · high confidence

The \dev/integration\_tests/web\_e2e\_tests\ directory now contains a new set of end-to-end integration tests for Flutter Web. This includes a README with setup instructions for chromedriver and \flutter drive\, along with test application sources covering text editing, scroll wheel interactions, platform detection, URL strategy, deferred loading, screenshot support, and tree-shaking verification.

_dev/integration\_tests/web\_e2e\tests · high confidence

The manual\_tests application now includes the necessary HTML entry point and web manifest to run in a browser. The index.html file sets up the base href for Flutter builds, includes standard meta tags, and links the main JavaScript bundle. The manifest.json file configures the app as a standalone PWA with specific theme colors, icons, and display settings, enabling proper installation and rendering on web platforms.

_dev/manual\tests/web · high confidence

The web integration test location now includes the necessary static assets to serve a Flutter web application, including an index.html that implements a service worker registration mechanism for Progressive Web App (PWA) functionality, a manifest.json defining the app as standalone with specific theme colors, and standard iOS meta tags for mobile web app capabilities. A .gitignore file is also added to exclude the generated entrypoint file, and a placeholder example file is created.

_dev/integration\tests/web/web · high confidence

The Android benchmark application has been introduced to measure platform channel performance, featuring a Kotlin-based MainActivity that registers various BasicMessageChannel handlers (standard, binary, and background) to facilitate performance comparisons with iOS benchmarks. A corresponding .gitignore file has also been added to exclude build artifacts and sensitive keystore files from version control.

_dev/benchmarks/platform\_channels\benchmarks/android · high confidence

The macOS manual tests application now includes a dedicated Xcode scheme (Runner.xcscheme) that configures build, test, launch, profile, analyze, and archive actions. This scheme enables developers to run, debug, and profile the manual tests app directly within Xcode, with specific settings for GPU validation and debugging tools.

_dev/manual\tests/macos/Runner.xcodeproj/xcshareddata · high confidence

The macrobenchmarks macOS project now includes a dedicated Xcode scheme (Runner.xcscheme) that configures the build, test, launch, profile, analyze, and archive actions for the macrobenchmarks.app target. This enables developers to run and benchmark the macrobenchmarks directly from Xcode on macOS.

dev/benchmarks/macrobenchmarks/macos/Runner.xcodeproj/xcshareddata · high confidence

A new benchmark suite has been added to measure scrolling performance and startup time. The application includes a README with instructions for running the scroll benchmark (via \flutter drive\) and the startup benchmark (via \flutter run --trace-startup\), along with the Dart source code for the app itself, which features complex layouts with nested lists, image items, and gallery drawers to stress-test rendering performance.

_dev/benchmarks/complex\layout · high confidence

A new integration test suite located at dev/integration\_tests/external\_textures has been introduced to verify the correct rendering of external textures between native platforms (iOS and Android) and Flutter. This specific test case, frame\_rate\_main.dart, validates that texture frame rates are accurately produced and consumed by exercising speed variations (0.5x and 2x) and asserting the resulting metrics via the Flutter Driver extension.

_dev/integration\_tests/external\textures · high confidence

The iOS runner for the UI integration tests now includes standard LaunchScreen.storyboard and Main.storyboard files. These files define the initial view controller and the Flutter view controller setup, providing the necessary interface builder assets for the test application to launch correctly on iOS devices and simulators.

_dev/integration\tests/ui/ios/Runner/Base.lproj · high confidence

The release smoke test application now includes standard iOS interface files: a LaunchScreen.storyboard for the app launch screen and a Main.storyboard containing the initial FlutterViewController. These additions ensure the test app has the necessary UI structure to run correctly on iOS devices during release smoke tests.

_dev/integration\_tests/release\_smoke\test/ios/Runner/Base.lproj · high confidence

Added the base iOS project files (LaunchScreen.storyboard and Main.storyboard) for the ios\_platform\_view\_tests integration test suite. These files provide the standard Xcode storyboard structure required to host the Flutter view controller for testing iOS platform views.

_dev/integration\_tests/ios\_platform\_view\tests/ios/Runner/Base.lproj · high confidence

The iOS Runner project for the flavors integration test now includes \LaunchScreen.storyboard\ and \Main.storyboard\ files. These additions provide the necessary interface builder definitions for the launch screen and the main Flutter view controller, ensuring the test application has the required UI structure to run correctly on iOS.

_dev/integration\tests/flavors/ios/Runner/Base.lproj · high confidence

The integration test project for iOS app flavors now includes a properly configured Xcode workspace. This workspace groups the main Runner project and the CocoaPods dependencies, ensuring that the test environment correctly resolves dependencies and builds flavors as intended.

_dev/integration\tests/flavors/ios/Runner.xcworkspace · high confidence

The macOS manual test application now includes the necessary Xcode project workspace and build configuration files (Flutter-Debug.xcconfig, Flutter-Release.xcconfig, and workspace settings). This enables the manual tests to be built and run directly on macOS using Xcode, providing a proper development environment for testing Flutter desktop capabilities on this platform.

_dev/manual\_tests/macos/Flutter, dev/manual\_tests/macos/Runner.xcodeproj/project.xcworkspace, dev/manual\tests/macos/Runner.xcworkspace · high confidence

The UI integration test suite now includes a macOS workspace configuration, enabling the tests to be built and run on macOS. This change adds the necessary Xcode workspace files (including references to the Runner project and CocoaPods) to support the macOS platform within the test infrastructure.

_dev/benchmarks/macrobenchmarks/macos/Runner.xcworkspace, dev/integration\_tests/ui/ios/Runner.xcworkspace, dev/integration\tests/ui/macos/Runner.xcworkspace · high confidence

The integration test located at dev/integration\_tests/ios\_app\_with\_extensions/ios/watch now includes the necessary watchOS application bundle files. This adds the AppIcon asset catalog with images for various watch sizes and roles (notification center, app launcher, quick look), the base Interface.storyboard defining the initial hosting controller, and the Info.plist configuring the bundle as a WatchKit app. These files provide the structural foundation for the watch companion extension within the test suite.

_dev/integration\_tests/ios\_app\_with\extensions/ios/watch · high confidence

The Android side of the integration\_test plugin now includes a new FlutterDeviceScreenshot utility class that enables capturing screenshots of the combined Android and Flutter UI by converting the Flutter surface to an image view, and a new FlutterTestRunner class that allows running integration tests via JUnit's ActivityTestRule. The IntegrationTestPlugin exposes method channel handlers for these capabilities, including converting the surface, reverting it, and capturing the screenshot, while also handling test result reporting.

_packages/integration\_test/android/src/main/java/dev/flutter/plugins/integration\test · high confidence

A new Android integration test application has been added to validate deferred components functionality. The project is configured to use the FlutterPlayStoreSplitApplication class, includes the necessary manifest metadata for deferred component mapping (specifically mapping loading unit 2 to component1), and sets the main activity as exported to support external ADB execution in CI environments. The setup also includes standard Android resources, a Kotlin MainActivity extending FlutterActivity, and Gradle dependency lockfiles to ensure reproducible builds.

_dev/integration\_tests/deferred\_components\test/android · high confidence

The flutter\_driver package is initialized with its core source files, configuration, and test infrastructure. This includes the main library exports, the driver extension for test harnesses, and the common command/finder definitions. Additionally, data-driven fix rules are added to automatically migrate users from the deprecated FlutterDriver.enableAccessibility method to setSemantics, and from TimelineSummary.writeSummaryToFile to writeTimelineToFile.

_packages/flutter\driver · high confidence

The Flutter Gallery integration test app now includes a complete Android project structure with an AndroidManifest.xml declaring the MainActivity and test instrumentation support, Java classes for the MainActivity and a FlutterGalleryInstrumentation handler to bridge test lifecycle events, and generated Gradle dependency lockfiles (buildscript-gradle.lockfile and project-app.lockfile) pinning Android Gradle Plugin 9.1.0 and Kotlin 2.4.0 to ensure reproducible builds.

_dev/integration\_tests/flutter\gallery/android · high confidence

The Android embedding now includes a new KeyboardManager and associated responder classes (KeyChannelResponder and KeyEmbedderResponder) to handle hardware keyboard input. This change introduces the HardwareKeyboard API support on Android, allowing the framework to receive and process raw and processed key events from physical keyboards, including complex character composition and modifier key synchronization.

android · high confidence

The Hello World example application has been updated to include support for right-to-left (RTL) text rendering. A new Arabic language variant (arabic.dart) has been added alongside the existing English version (main.dart), allowing users to view the application with Arabic text and proper RTL layout direction.

_examples/hello\world · high confidence

The a11y\_assessments directory now contains a dedicated test application designed to validate widget accessibility. This app provides a structured suite of use cases—covering components such as buttons, menus, dialogs, and navigation elements—allowing developers to verify that semantic labels, focus management, and high-contrast themes are correctly implemented across the framework.

_dev/a11y\assessments · high confidence

A new integration test project, \android\_hardware\_smoke\_test\, has been added to verify visual rendering correctness on Android hardware. The suite supports two execution modes: a host-driven mode for CI pipelines using \flutter drive\, and a self-contained instrumented mode for OEMs to run native JUnit tests directly on devices. It includes test scenarios for vector drawings, text rendering, image textures, blend modes, backdrop blur effects, and native platform views (using Texture Layer Hybrid Composition, Hybrid Composition, and Hybrid Composition++). The app features a dual-mode architecture where host-driven tests stream image bytes to the host for comparison, while instrumented tests perform pixel-exact local comparisons against bundled golden assets using a custom \PixelExactLocalFileComparator\ to bypass encoding discrepancies.

_dev/integration\_tests/android\_hardware\_smoke\test · high confidence

The \flutter\_goldens\ package now integrates with the Skia Gold infrastructure to manage visual regression testing. It provides a \testExecutable\ entry point that automatically selects the appropriate golden file comparator based on the environment: \FlutterPostSubmitFileComparator\ for post-submit CI runs, \FlutterPreSubmitFileComparator\ for pre-submit tryjobs, \FlutterLocalFileComparator\ for local development (which fetches baselines and compares pixels), and \FlutterSkippingFileComparator\ for environments where testing is not configured. The package includes a \SkiaGoldClient\ to handle authentication and image uploads via the \goldctl\ tool, and exports the necessary comparators and client for use in test configurations.

_packages/flutter\goldens · high confidence

The \dev/tools/gen\_keycodes/data\ directory now contains the authoritative source files for generating keyboard key mappings across all supported platforms. This includes platform-specific mapping data (Android, iOS, macOS, Windows, Linux/GTK, Linux/GLFW, Web, and Fuchsia) in JSON format, along with code generation templates for C++, Java, and Dart. These files feed into the \gen\_keycodes\ tool to produce the final \LogicalKeyboardKey\ and \PhysicalKeyboardKey\ definitions and platform-specific embedder maps, ensuring consistent key code handling across the framework.

_dev/tools/gen\keycodes/data · high confidence

The \dev/customer\_testing\ directory now provides a new tooling infrastructure to automatically check out the \flutter/tests\ repository (pinned to the SHA in \tests.version\) and run registered test suites against the current tip-of-tree Flutter. This includes a new \CustomerTest\ parser that supports directives for contacts, fetch steps, setup commands, update directories, and platform-specific test execution, as well as a runner that supports test sharding, verbose logging, and iteration limits. CI scripts (\ci.sh\, \ci.bat\) and a central \ci.dart\ entry point allow this shard to be executed in continuous integration environments to verify that end-user apps and libraries remain compatible with the latest Flutter changes.

_dev/customer\testing · high confidence

The \dev/snippets\ directory now contains a standalone Dart package that handles the parsing, analysis, and HTML generation of code samples for Flutter's API documentation. This package introduces a structured toolchain with a \SnippetGenerator\ to interpolate code into HTML skeletons, a \SnippetDartdocParser\ to extract \{@tool snippet}\ and \{@tool sample}\ blocks from source comments, and an \analysis\ module to validate sample code using the Dart analyzer. It also provides configuration classes to locate skeleton templates and supports channel-specific DartPad integration, centralizing the logic previously scattered across the repository for generating documentation code blocks.

dev/snippets · high confidence

The \dev/flutter\_analyzer\_plugin\ directory now provides a custom Dart Analysis Server plugin that replaces legacy regex-based and manual AST scripts (previously in \dev/bots/analyze.dart\) with native, real-time analyzer diagnostics integrated directly into developer IDEs (VS Code, Android Studio) and the \flutter analyze\ CLI. The plugin registers a suite of custom rules—including \avoid\_future\_catch\_error\, \no\_double\_clamp\, \no\_stopwatches\, \deprecation\_syntax\, \no\_runtimetype\_in\_tostring\, \no\_sync\_async\_star\, \no\_bad\_imports\_in\_flutter\, \protect\_public\_state\_subtypes\, \render\_box\_intrinsics\, \lazy\_initialized\_debug\_expensive\_fields\, \skip\_test\_comments\, \integration\_test\_timeouts\, \golden\_test\_tags\, \issue\_link\_syntax\, \repository\_link\_syntax\, \no\_test\_imports\, and \taboo\_documentation\—which enforce architectural boundaries, performance invariants, test hygiene, and style conventions across the repository. These rules are enabled by default upon loading the plugin via \analysis\_options.yaml\ and can be opted out of using the \diagnostics:\ configuration block.

_dev/flutter\_analyzer\plugin · high confidence

Adds the \fuchsia\_remote\_debug\_protocol\ package, providing an API to test and debug Flutter applications on remote Fuchsia devices and emulators. The package exposes a \FuchsiaRemoteConnection\ class that manages SSH-based port forwarding to forward Dart VM service ports from the device to the local machine, allowing developers to connect to and inspect Dart VMs, isolates, and Flutter views. It includes a configurable \SshCommandRunner\ for executing remote commands, a logging system with adjustable verbosity levels, and network utilities for validating IPv4/IPv6 addresses. The implementation relies on the \vm\_service\ package for VM communication and the \process\ package for local process management, with comprehensive tests covering connection flows, port forwarding, and command execution.

_packages/fuchsia\_remote\_debug\protocol · high confidence

A new \gen\_defaults\ tool has been added to \dev/tools/gen\_defaults/bin\ to automatically generate widget theme data defaults from the Material token database. This script reads JSON token files (including light/dark color schemes) and updates the default values for a wide range of Material components—such as Buttons, Cards, Chips, Dialogs, Navigation bars, and Search bars—ensuring they align with the latest Material 3 design specifications.

_dev/tools/gen\defaults/bin · high confidence

A new command-line tool located in dev/tools/gen\_keycodes/bin has been added to automate the generation of keyboard key code mappings for Flutter. The tool collects raw key data from external sources such as Chromium, Android, Windows, GTK, and GLFW, and generates platform-specific Dart code files (keyboard\_key.g.dart and keyboard\_maps.g.dart) to ensure consistent hardware keyboard support across iOS, macOS, Linux, Windows, and Web.

_dev/tools/gen\keycodes/bin · high confidence

The macrobenchmarks package now provides a unified suite of performance tests for both mobile and web platforms. Mobile benchmarks are executed via \flutter drive\ and cover scenarios such as cull opacity, cubic bezier animations, backdrop filters, picture caching, and text layout. Web benchmarks are compiled from a shared entry point and support CanvasKit and Skwasm renderers, allowing developers to measure low-level engine primitives, widget build costs, and widget-level performance using raw, widget, or widget-build recorders. The suite includes a navigation app for running individual tests and a README with instructions for both platforms.

dev/benchmarks/macrobenchmarks · high confidence

The devicelab/bin directory now includes three new command-line tools: run.dart, which adds support for A/B testing modes (comparing default vs. local engines) and new flags like --luci-builder and --git-branch; summarize.dart, which processes A/B test JSON results into raw, TSV, or ASCII table formats; and test\_runner.dart, a unified entry point using the args library to manage TestCommand and UploadMetricsCommand subcommands.

dev/devicelab/bin · high confidence

The \dev/tools/gen\_keycodes\ directory now contains a dedicated tool for generating Dart code for \LogicalKeyboardKey\ and \PhysicalKeyboardKey\ classes. This tool produces \keyboard\_key.g.dart\ and \keyboard\_maps.g.dart\ in the framework, as well as platform-specific mapping files in the engine. It uses a 52-bit key ID scheme organized into planes (Unicode, unprintable, Flutter, and platform-specific) to ensure unique, opaque key codes, and supports data collection from online sources or local JSON databases for Android, iOS, macOS, GTK, Windows, and Web platforms.

_dev/tools/gen\keycodes · high confidence

A new tool named \vitool\ has been added to \dev/tools/vitool\ to generate Dart source files from SVG frames. This utility is designed specifically for Material Design animation assets, parsing a subset of SVG features (such as groups, transforms, opacities, and path fills) to produce optimized Dart code for \AnimatedIcon\ animations. It is not intended as a general-purpose SVG converter.

dev/tools/vitool · high confidence

The \flutter\_web\_plugins\ package now exposes a configurable URL strategy system for web apps, allowing developers to switch from the default hash-based routing to pathname-based routing via \usePathUrlStrategy()\ or \setUrlStrategy()\. This includes the \PathUrlStrategy\ class, which respects the HTML \\<base\>\ href and supports optional hash inclusion for backward compatibility. Additionally, the package introduces \PluginEventChannel\ to enable platform-side plugins to send event streams to the Flutter framework, and provides the \Registrar\ class for registering web plugins with the engine.

_packages/flutter\_web\plugins · high confidence

A new \android\_driver\_extensions\ library has been added to provide extensions for interacting with the native Android platform from external Flutter Driver tests. This includes capabilities to take screenshots of native widgets (platform views, textures), tap on native elements, rotate the device, and manage app lifecycle (backgrounding, resuming, and simulating low memory). The library also integrates with Skia Gold for golden file testing in CI environments, allowing for automated visual regression testing of native UI elements.

_dev/tools/android\_driver\extensions · high confidence

The flutter\_view example has been updated to demonstrate the modern Android embedding v2 API. The sample now uses \FlutterEngine\ and \FlutterView\ to embed a Flutter UI within a native Android Activity, replacing the previous approach. It includes a native UI with a Floating Action Button that communicates with the Flutter engine via a \BasicMessageChannel\, and it explicitly declares the \flutterEmbedding\ meta-data and \android:exported\ attribute in the manifest to comply with current Android standards.

_examples/flutter\view/android · high confidence

The Android embedding introduces three new interfaces in the \io.flutter.embedding.engine.plugins.activity\ package to manage plugin lifecycle and activity integration. \ActivityAware\ allows plugins to receive callbacks when attached to, detached from, or re-attached to an Android Activity, including handling configuration changes. \ActivityControlSurface\ provides the mechanism for an Activity to coordinate its lifecycle events (such as \onCreate\, \onDestroy\, \onNewIntent\, and permission results) with the Flutter Engine. \ActivityPluginBinding\ gives plugins access to the associated Activity, its Lifecycle, and methods to register listeners for various Activity events like result codes and window focus changes.

engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/plugins/activity · high confidence

The \dev/integration\_tests/android\_semantics\_testing\ directory now contains a complete Flutter application and supporting library for verifying Android accessibility. The app includes dedicated test pages for selection controls (checkboxes, radio buttons, switches), headings, popups (menus, dropdowns, alerts), and text fields. The accompanying library exports constants, matchers, and an \AndroidSemanticsNode\ class that deserializes Android accessibility information, enabling integration tests to assert on specific accessibility properties like text, content description, flags, and actions.

_dev/integration\_tests/android\_semantics\testing · high confidence

The new\_gallery integration test now includes a full suite of Cupertino UI demos, covering activity indicators, alerts, buttons, context menus, navigation bars, pickers, scrollbars, search text fields, segmented controls, sliders, switches, tab bars, and text fields. This expansion allows the test suite to validate the behavior and rendering of the complete set of Cupertino widgets within the gallery application.

_dev/integration\_tests/new\gallery · high confidence

The \dev/integration\_tests/ui\ directory now contains a dedicated Flutter application designed to exercise various \flutter\_driver\ capabilities and platform interactions. This test app includes specific entry points for verifying keyboard resize behavior, text field interactions, route handling, and platform channel communication (such as resizing the window on mobile). It also provides utilities for testing feature flags, license registry contents, frame timing acquisition, and widget creation tracking, serving as a comprehensive harness for UI integration tests.

_dev/integration\tests/ui · high confidence

A new Windows runner for the a11y\_assessments sample application has been added, providing the native C++ entry point, window management, and build configuration required to run the Flutter app on Windows. This includes the CMake build files, a Win32 window implementation with high-DPI and dark-mode support, and a console attachment utility for debugging output.

_dev/a11y\assessments/windows · high confidence

A new agent skill has been added to automate the process of cherry-picking merged pull requests from the Flutter master branch to the stable or beta release channels. This includes a new \SKILL.md\ guide for the agent workflow and a Dart helper script (\flutter\_cp.dart\) that orchestrates the process by detecting the target release candidate branch, running the cherry-pick, handling conflicts, and updating the resulting pull request with the correct title, body template, and labels.

.agents/skills/flutter-cherry-pick · high confidence

Added a new 'upgrade-browser' skill that provides an automated workflow for upgrading Chrome and Firefox versions in the Flutter Web Engine and Framework tests. This includes scripts to fetch and verify the latest stable versions from official sources, update configuration files like \package\_lock.yaml\ and \.ci.yaml\, sync CI builder JSON, and handle CIPD package uploads, streamlining the browser roll process for developers.

.agents/skills/upgrade-browser · high confidence

The \dev/integration\_tests/android\_engine\_test\ directory now contains a comprehensive end-to-end test suite for the Android engine, including a new \.metadata\ file for project tracking and a detailed \README.md\. The suite introduces multiple standalone Flutter apps to test the native driver API, external textures (\SurfaceProducer\, \SurfaceTexture\), and various platform view modes (Hybrid Composition, Texture Layer Hybrid Composition, Virtual Display). A significant addition is the \lib/hcpp/\ directory, which hosts a set of apps specifically designed to test the new Hybrid Composition Platform Views (HCPP) feature, covering scenarios like clipping (\clipPath\, \clipRect\), opacity, transforms, overlay layer management, and fractional pixel precision. The suite also includes tests for \SystemUiMode\ transitions and input mirroring in RTL languages, with CI targets configured to run these tests against both OpenGLES and Vulkan backends.

_dev/integration\_tests/android\_engine\test · high confidence

The \.agents/agents\ directory now hosts several pre-configured autonomous agents to streamline specific development workflows. Contributors can use the \android-agent\ for specialized Android platform tasks (Java, Kotlin, Gradle), the \ios-agent\ for iOS-specific development (Swift, Objective-C), and the \bare-agent\ for general-purpose tasks without pre-loaded skills. Additionally, the \reidbaker-agent\ is available, featuring an 'Expert' persona and pre-installed skills for code review and natural writing. Each agent includes its own configuration, README, and skill-lock files to manage dependencies and behavior.

.agents/agents · high confidence

Added a new Flutter application at dev/integration\_tests/data\_asset\_app to serve as an integration test for the Dart data assets feature. The app demonstrates loading both local data assets and assets from a dependency package (data\_asset\_package), displaying their content on screen and printing status logs for test verification. It includes full platform support (Linux, macOS) and a build hook to register the data assets.

_dev/integration\_tests/data\_asset\app · high confidence

A new integration test application has been added to validate deferred component loading behavior. The app includes a release test script that builds an Android App Bundle, uses bundletool to install it, and monitors logcat for a specific sentinel message to confirm that deferred libraries load correctly within a timeout. It also supports debug-mode driver tests to verify framework-side logic.

_dev/integration\_tests/deferred\_components\test · high confidence

The \dev/tools\ directory now includes a suite of new scripts to streamline framework maintenance. The \create\_api\_docs.dart\ script generates the public API documentation site, integrating platform-specific Javadoc and documentation for Android, iOS, macOS, Linux, and Windows, while the \dartdoc\_checker.dart\ tool validates the output for unresolved directives. The \update\_icons.dart\ script has been refactored to regenerate the Material icons Dart file, handling RTL mirroring, identifier rewrites, and platform-adaptive icons. Additionally, \examples\_smoke\_test.dart\ provides automated smoke tests for the API examples to ensure they compile and run without errors, and \mega\_gallery.dart\ generates a large-scale test application by copying the gallery multiple times.

dev/tools · high confidence

Added several new scripts to \dev/tools/bin\ to streamline development workflows. \bump\_version\_constraints.dart\ allows developers to update the Dart SDK constraint across all \pubspec.yaml\ files in the repository by specifying old and new version arguments. \check\_engine\_version.dart\ verifies that the \bin/internal/engine.version\ file matches the current engine commit, supporting CI presubmit checks. \format.dart\ provides a robust way to check or fix Dart formatting for changed files (or all files) by comparing against the base git revision. Additionally, \get\_files\_changed.dart\ outputs a list of files modified since a specific commit in text or JSON format, useful for automation.

dev/tools/bin · high confidence

Added the iOS native runner for the \ios\_platform\_view\_tests\ integration test suite. This app registers multiple platform view factories—including standard views, text fields, buttons, web views, a drawing canvas, and a fake AdMob banner—to exercise platform view creation, interaction, and gesture handling on iOS.

_dev/integration\_tests/ios\_platform\_view\tests/ios/Runner · high confidence

The \dev/integration\_tests/android\_views\ directory now contains a new Flutter test application designed to verify the behavior of embedded Android views. This app includes a 'Motion Events' page that records touch events on both the Flutter view and the embedded Android view, allowing automated tests to assert that synthesized motion events match the original inputs. It also features a 'Window Manager Integrations' page that tests the creation of Android AlertDialogs and the handling of touch events on additional windows added by platform views, ensuring correct pointer propagation and event tracking.

_dev/integration\_tests/android\views · high confidence

Added a new integration test app in \dev/integration\_tests/hybrid\_android\_views\ that verifies synthesized motion events reaching embedded Android views match those hitting the FlutterView. The test app includes pages for recording and replaying touch sequences to validate event equivalence, as well as testing nested view interactions, alert dialogs, and toggling hybrid composition modes.

_dev/integration\_tests/hybrid\_android\views · high confidence

Added a new integration test application in \dev/integration\_tests/wide\_gamut\_test\ to verify wide gamut (Display P3) color rendering. The test app renders various UI elements—including images, gradients, and save layers—using the Display P3 colorspace, allowing developers to validate that the engine correctly handles wide gamut content on supported platforms.

_dev/integration\_tests/wide\_gamut\test · high confidence

Added several new executable scripts to the localization tooling to improve the generation and maintenance of Flutter's localization resources. The \gen\_date\_localizations.dart\ script extracts date symbols and patterns from the \intl\ package, including a specific override for Arabic ZERODIGIT to ensure correct formatting. The \gen\_localizations.dart\ script generates the Dart code for material, cupertino, and widget localizations from ARB files. A new \gen\_missing\_localizations.dart\ script helps translators by copying English source strings into other locale ARB files for any missing resources, and optionally removing undefined entries. Additionally, \encode\_kn\_arb\_files.dart\ was added to escape Kannada string characters in ARB files to prevent Emacs crashes on Linux, and \gen\_subtag\_registry.dart\ provides a way to cache the IANA language subtag registry locally.

dev/tools/localization/bin · high confidence

The Flutter Gallery integration test now includes a complete, newly generated Xcode project file (project.pbxproj) for macOS. This file defines the build configuration for the 'Flutter Gallery.app', including the 'Flutter Assemble' aggregate target, source files like AppDelegate.swift and MainFlutterWindow.swift, resource bundles, and CocoaPods integration for testing frameworks. This establishes the native macOS build infrastructure required to run the gallery app in the integration test suite.

_dev/integration\_tests/flutter\gallery/macos/Runner.xcodeproj · high confidence

A new collection of microbenchmarks has been added to the \dev/benchmarks/microbenchmarks\ directory to measure the performance of core Flutter framework components. The suite includes benchmarks for ChangeNotifier listener operations, ObserverList and HashedObserverList notification performance, asset manifest loading, StandardMessageCodec and StandardMethodCodec encoding, timeline events, geometry transformations (MatrixUtils), RRect containment checks, and gesture velocity tracking. A central \benchmark\_collection.dart\ runner orchestrates these tests, providing a \BenchmarkResultPrinter\ that outputs results in both machine-readable JSON and human-readable plain text, along with statistical probability margins for key metrics.

dev/benchmarks/microbenchmarks · high confidence

Added new benchmark applications in the \dev/benchmarks/platform\_views\_layout\ directory to measure scrolling and startup performance of platform views. The suite includes \main.dart\ for a standard scrolling layout with platform views and rotating containers, \main\_hcpp.dart\ for hybrid composition (HCPP) on Android, \main\_non\_intersecting.dart\ for complex non-intersecting widgets, and \main\_ad\_banners.dart\ and \main\_bottom\_ad\_banner.dart\ for testing layouts with AdMob ad banners. These benchmarks allow developers to profile the performance impact of platform views in various complex UI scenarios.

_dev/benchmarks/platform\_views\layout · high confidence

The Android embedding engine now exposes new interfaces that allow Flutter plugins to detect and interact with Android's BroadcastReceiver and ContentProvider components. This change adds the BroadcastReceiverAware and ContentProviderAware interfaces, along with their corresponding control surfaces and plugin bindings, enabling plugins to receive lifecycle callbacks when attached to or detached from these Android components and access the associated instances.

engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/plugins/broadcastreceiver, engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/plugins/contentprovider · high confidence

A new 'engine-whats-new' skill has been added to the agents toolkit, enabling users to automatically generate release summaries and unified diffs for the Flutter engine. By running the included Dart script, users can compare changes between two engine releases (e.g., 3.47 vs 3.44) to produce a categorized Markdown summary covering graphics, platform embeddings, and dependencies, alongside a full git diff file.

.agents/skills/engine-whats-new · high confidence

A new command-line tool has been added to generate Dart code samples, snippets, and Dartpad applications. Users can now invoke the tool to produce formatted sample code or full sample applications by specifying input files and output directories via command-line arguments or environment variables, with support for different output types such as 'dartpad', 'sample', and 'snippet'.

dev/snippets/bin · high confidence

A new \GeneratedPluginRegister\ utility class has been added to the Flutter engine's Android embedding layer. This class provides a static method that uses reflection to locate and invoke the app-generated \GeneratedPluginRegistrant\ class, allowing \FlutterEngine\ instances to automatically register plugins listed in \pubspec.yaml\ without requiring a compile-time dependency on the app's generated code. This supports the automatic plugin registration flow used by \FlutterActivity\ and \FlutterFragmentActivity\, while also offering a mechanism for apps to manually trigger this registration or disable it to fine-tune launch latency.

engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/plugins/util · high confidence

A new web benchmark harness has been added to the macrobenchmarks suite, consisting of an HTML entry point and a JavaScript bootstrap script. The bootstrap script configures the Flutter loader to use a local CanvasKit bundle (served from /canvaskit/) instead of a CDN to improve test hermeticity and reduce flakiness. It also supports a URL query parameter \force\_st\ to enable single-threaded Skwasm execution via the \forceSingleThreadedSkwasm\ config option.

dev/benchmarks/macrobenchmarks/web · high confidence

The platform interaction integration test now includes a complete Android application structure, featuring an AndroidManifest.xml configured for the v2 embedding and a Java MainActivity that registers a BasicMessageChannel for navigation testing. To ensure reproducible builds, Gradle dependency lockfiles have been added for both the buildscript and the project-app modules, pinning specific versions for the Android Gradle Plugin (9.1.0), Kotlin (2.4.0), and their transitive dependencies.

_dev/integration\_tests/platform\interaction/android · high confidence

The stocks demo application has been moved into the dev/benchmarks/test\_apps directory as a benchmark test app. It includes a complete set of internationalization files (ARB sources and generated Dart classes for English and Spanish) configured via l10n.yaml, along with the core Flutter widgets for displaying stock data, navigation, and settings. The app uses Material 2 (useMaterial3: false) and demonstrates standard Flutter patterns like localizations, routing, and state management for benchmarking purposes.

_dev/benchmarks/test\apps/stocks · high confidence

The \integration\_test\ package is now included in the Flutter SDK, providing a unified way to run end-to-end tests on mobile and web platforms. This release introduces the core testing bindings, an extended driver for capturing screenshots, and example projects for Android and iOS. It also includes updated documentation and configuration files to support modern Android (AGP 9, Gradle 9.3.1) and iOS development workflows.

_packages/integration\test · high confidence

The \dev/tools/gen\_defaults\ script, which previously generated Material component theme defaults from the token database, is now deprecated. Active Material defaults generation has moved to the standalone \material\_ui\ package in the \flutter/packages\ repository. Users should migrate to the new tooling location for future Material design updates.

_dev/tools/gen\defaults · high confidence

The localization generation tooling in dev/tools/localization has been refactored to separate concerns by UI framework. New dedicated generator files (gen\_material\_localizations.dart, gen\_cupertino\_localizations.dart, gen\_widgets\_localizations.dart) now produce framework-specific translation classes and constructors, replacing the previous monolithic approach. This change also introduces a new localizations\_utils.dart module containing shared utilities like LocaleInfo parsing and ARB loading, alongside a language\_subtag\_registry.dart for locale validation and a localizations\_validator.dart for enforcing integrity of translation keys. Users benefit from cleaner separation of Material, Cupertino, and Widgets localization logic, making it easier to maintain and extend framework-specific localizations independently.

dev/tools/localization · high confidence

The macOS application template for the Flutter gallery now includes a Help menu item in the main menu bar, aligning the template with standard macOS application conventions. This change updates the MainMenu.xib file to include the new menu entry, providing a more complete and native-feeling user interface for macOS applications generated from this template.

_dev/integration\_tests/flutter\gallery/macos/Runner/Base.lproj · high confidence

The complex\_layout iOS benchmark now includes IDE workspace settings to suppress the 32-bit warning and disable previews. This ensures the benchmark project builds cleanly without unnecessary UI overhead in Xcode.

_dev/benchmarks/complex\layout/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata · high confidence

The iOS integration test project now includes a \contents.xcworkspacedata\ file, establishing the standard Xcode workspace structure required for the test environment.

_dev/integration\tests/channels/ios/Runner.xcodeproj/project.xcworkspace · medium confidence

The iOS host app integration test suite now includes a Flutter application that demonstrates platform integration features. The app enables the set semantics API for accessibility testing and implements a dynamic content resizing demo, allowing users to verify how the framework handles layout changes and accessibility tree updates in an add-to-app scenario.

_dev/integration\_tests/ios\_host\app/flutterapp · high confidence

The integration test app located at dev/integration\_tests/ios\_app\_with\_extensions now includes Base.lproj/LaunchScreen.storyboard and Main.storyboard. These files define the initial launch screen and the main Flutter view controller scene, ensuring the generated iOS project has the necessary interface builder resources to build and run correctly.

_dev/integration\_tests/ios\_app\_with\extensions/ios/Runner/Base.lproj · high confidence

The macOS runner for the platform channel integration tests has been migrated to use the \pkg:integration\_test\ package. This update includes a modernized Xcode project structure (Xcode 15.1 scheme), updated build configurations, and an \AppDelegate\ that enables secure restorable state by default. The \MainFlutterWindow\ now initializes specific platform channels (binary, string, JSON, and standard message/method channels) to exercise communication between the Flutter engine and the host platform.

_dev/integration\tests/channels/macos · high confidence

The iOS integration test projects for flavors, platform interaction, and UI now include an IDEWorkspaceChecks.plist file that enables the 32-bit warning check. This ensures that Xcode workspace configurations for these test apps are properly initialized and consistent with the project's build settings.

_dev/integration\_tests/flavors/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata, dev/integration\_tests/platform\_interaction/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata, dev/integration\tests/ui/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata · high confidence

The iOS microbenchmark runner now includes standard Xcode workspace settings files (IDEWorkspaceChecks.plist and WorkspaceSettings.xcsettings). These additions ensure that Xcode workspace checks are enabled and that previews are disabled, providing a consistent build environment for the benchmarking tool.

dev/benchmarks/microbenchmarks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata · high confidence

The Flutter Gallery integration test now includes the standard Xcode workspace structure for its iOS Runner target. Specifically, the \contents.xcworkspacedata\ and \IDEWorkspaceChecks.plist\ files have been added, ensuring the project workspace is correctly initialized and recognized by Xcode during build and test execution.

_dev/integration\_tests/flutter\gallery/ios/Runner.xcodeproj/project.xcworkspace · high confidence

Explicit workspace definition files (contents.xcworkspacedata) were added for the complex\_layout and microbenchmarks iOS example projects. This ensures that these benchmark apps are properly recognized as part of an Xcode workspace structure, which is required for correct project integration and build configuration in Xcode.

_dev/benchmarks/complex\layout/ios/Runner.xcodeproj/project.xcworkspace, dev/benchmarks/microbenchmarks/ios/Runner.xcodeproj/project.xcworkspace · high confidence

The iOS integration test runner now includes a standard Xcode workspace file (contents.xcworkspacedata) that references the project itself. This ensures the test environment has a properly defined workspace structure, which is necessary for managing project dependencies and build settings in the test suite.

_dev/integration\tests/ui/ios/Runner.xcodeproj/project.xcworkspace · high confidence

The macrobenchmark iOS runner now includes a dedicated Xcode workspace file that groups the main project and the CocoaPods dependencies. This ensures that the benchmark application can be built and tested with its required third-party libraries properly linked, supporting the addition of new performance tests like the cull opacity test.

dev/benchmarks/macrobenchmarks/ios/Runner.xcworkspace · high confidence

The macOS integration test project now includes explicit build configuration files (Flutter-Debug.xcconfig and Flutter-Release.xcconfig) that include the ephemeral Flutter-generated configuration and optional CocoaPods support files. This ensures the test app builds correctly with the expected debug and release settings during pre-submit checks.

_dev/integration\tests/ui/macos/Flutter · high confidence

The macrobenchmarks Android app now uses the Android embedding v2 (declared in AndroidManifest.xml) and extends FlutterActivity, ensuring compatibility with modern Flutter tooling. Additionally, Gradle dependency locking is enabled via new buildscript-gradle.lockfile and project-app.lockfile files, which pin specific versions for the Android Gradle Plugin (9.1.0), Kotlin (2.4.0), and various AndroidX libraries to ensure reproducible builds.

dev/benchmarks/macrobenchmarks/android · high confidence

The Android side of the platform views layout hybrid composition benchmark has been updated to use the v2 embedding (FlutterActivity) instead of the deprecated v1 embedding. This change includes a new AndroidManifest.xml that explicitly sets the flutterEmbedding to 2 and disables the Hybrid Composition (HCPP) feature flag via meta-data, ensuring the benchmark runs in a controlled environment without tool-injected feature flags. The app now uses a custom DummyPlatformViewActivity and DummyPlatformViewFactory to register platform views, and includes a .gitignore file to exclude build artifacts and keystore files.

_dev/benchmarks/platform\_views\_layout\_hybrid\composition/android · high confidence

The Android side of the multiple\_flutters benchmark has been updated to launch and manage 20 concurrent Flutter engines. The new MainActivity creates a FlutterEngineGroup and spawns 20 individual engines, caching each one to display a corresponding FlutterFragment in a vertical layout. This change significantly increases the benchmark's memory footprint to stress-test the engine's multi-engine capabilities.

_dev/benchmarks/multiple\flutters/android · high confidence

The Android side of the channels integration test app has been updated to use the Android embedding v2 (declared in AndroidManifest.xml) and upgraded to Android Gradle Plugin 9.1.0 (evidenced by the generated lockfiles). The MainActivity.java implementation now uses the v2 embedding API (FlutterActivity and FlutterEngine) and registers a comprehensive set of platform channels—including BasicMessageChannel, MethodChannel, and a custom ExtendedStandardMessageCodec—to exercise binary, string, JSON, and standard message types.

_dev/integration\tests/channels/android · high confidence

The \android\_engine\_test\ integration test app has been updated to explicitly enable the Impeller rendering backend using the Vulkan driver, ensuring tests exercise this modern graphics pipeline. Additionally, the app now includes configuration to control the HC++ (Hybrid Composition) feature flag, allowing the test suite to verify behavior with and without this platform view optimization. The test app also registers several native platform view factories and texture plugins to support these specific engine-level integration scenarios.

_dev/integration\_tests/android\_engine\test/android · high confidence

The Android integration test app (android\_views) has been migrated to the v2 embedding, explicitly setting the flutterEmbedding metadata to 2 and disabling the HCPP feature flag to ensure consistent testing conditions. The app now includes a new MainActivity that registers a simple platform view and exposes a MethodChannel for test orchestration, including storage permission handling. Additionally, the app supports synthetic touch event injection via a new MotionEventCodec and TouchPipe, allowing integration tests to simulate and verify touch interactions on platform views.

_dev/integration\_tests/android\views/android · high confidence

The hybrid Android views integration test app has been upgraded to use Android Gradle Plugin (AGP) 9.1.0 and Kotlin 2.4.0, with Gradle dependency lockfiles added to ensure reproducible builds. The test application now explicitly disables Hybrid Composition (HCPP) via the Android manifest to isolate specific platform view behaviors, and the MainActivity has been updated to use the \FLUTTER\_VIEW\_ID\ constant for view lookup and to support synthetic touch event injection for testing.

_dev/integration\_tests/hybrid\_android\views/android · high confidence

The Android side of the spell\_check integration test has been migrated to the Android Gradle Plugin 9.1.0 and Kotlin 2.4.0. This update includes new Kotlin source files for the main activity and application, a manifest configuration that explicitly queries text-processing intents to support Android 11+ package visibility, and regenerated Gradle lockfiles to ensure reproducible builds with the upgraded toolchain.

_dev/integration\_tests/spell\check/android · high confidence

The Android side of the \android\_semantics\_testing\ integration test has been updated to use Android Gradle Plugin 9.1.0 and Kotlin 2.4.0, bringing the test app in line with modern Android build tooling. The \MainActivity\ implementation now uses the v2 embedding (\FlutterActivity\) and includes a robust clipboard synchronization mechanism to prevent race conditions during accessibility testing. Additionally, the \AndroidManifest\ has been updated to explicitly set \android:exported="true"\ on the main activity for API 33+ compatibility and includes the required \\<queries\>\ block for text processing intents.

_dev/integration\_tests/android\_semantics\testing/android · high confidence

The iOS project for the platform views layout hybrid composition benchmark has been updated to require a minimum deployment target of iOS 13 and set the Xcode last upgrade check to version 15.1. This ensures the benchmark runner is built with modern tooling and targets a supported iOS version range.

_dev/benchmarks/platform\_views\_layout\_hybrid\composition/ios/Runner.xcodeproj · high confidence

The build system for the CanvasKit WebAssembly module has been restructured via a new BUILD.gn file, defining the compilation targets and linking flags for the WASM library. This change introduces a configurable initial memory allocation of 32MB for the CanvasKit runtime and enables memory growth, which impacts how much memory the web-based rendering engine reserves and expands during execution.

engine/src/flutter/skia/modules/canvaskit · high confidence

The complex\_layout Android benchmark has been migrated to the Android Gradle Plugin (AGP) 9.1.0 and Gradle 9.1.0, aligning it with the latest template standards. To ensure reproducible builds, the project now includes generated Gradle lockfiles (buildscript-gradle.lockfile, project-app.lockfile, and project-integration\_test.lockfile) that pin specific versions of AndroidX, Kotlin, and other dependencies. Additionally, the AndroidManifest.xml has been updated to explicitly set android:exported="true" on the FlutterActivity and includes uiMode in the configChanges, while the .gitignore file has been refreshed to exclude build artifacts and keystore files.

_dev/benchmarks/complex\layout/android · high confidence

The Android Gradle wrapper for the complex\_layout benchmark has been updated to use Gradle version 9.3.1. This ensures the benchmark project aligns with the latest Gradle distribution, providing compatibility with modern Android build tools and resolving any deprecations associated with older Gradle versions.

_dev/benchmarks/complex\layout/android/gradle · high confidence

The \TestWindow\ class is now deprecated within the \flutter\_test\ package. Users should migrate to the new \TestDisplay\ API and \TestWindowingOwner\ implementations, which remove the previous single-window assumption and support multi-view rendering scenarios. This change aligns the testing framework with the broader engine changes to support dynamically sized and multiple views, ensuring that tests correctly simulate modern display configurations.

_packages/flutter\test · high confidence

The \GlobalCupertinoLocalizations\ and \GlobalMaterialLocalizations\ classes in \flutter\_localizations\ are now deprecated, directing users to migrate to \package:cupertino\_ui/cupertino\_ui.dart\ and \package:material\_ui/material\_ui.dart\ respectively. To support this transition, the package includes generated data-driven fix files (\fix\_cupertino\_localizations.yaml\ and \fix\_material\_localizations.yaml\) that automatically update imports and references to the new packages. The existing localization implementation remains available but is marked for removal after version 3.47.0-0.0.pre.

_packages/flutter\localizations · high confidence

The macOS macrobenchmarks now include Flutter-Debug.xcconfig and Flutter-Release.xcconfig files that optionally include CocoaPods xcconfig settings. This change allows the benchmark project to be built using CocoaPods, resolving previous build issues on macOS by properly integrating pod dependencies alongside the generated Flutter configuration.

dev/benchmarks/macrobenchmarks/macos/Flutter · high confidence

The Host app's Xcode scheme now includes the FlutterUITests test target in its Test Action, meaning running tests from Xcode will automatically execute the iOS UI tests alongside the build. This change ensures that the integration test host app is configured to validate Flutter UI behavior directly within the Xcode IDE environment.

_dev/integration\_tests/ios\_host\app/Host.xcodeproj/xcshareddata · high confidence

The Android project in the flavors integration test has been upgraded to use Android Gradle Plugin 9.1.0 and Kotlin 2.4.0. This update includes regenerated Gradle dependency lockfiles to ensure reproducible builds, adds the required \queries\ section to the Android manifest for text-processing intent resolution, and sets the main activity as exported to comply with modern Android requirements.

_dev/integration\tests/flavors/android · high confidence

The Flutter Gallery integration test now includes the necessary iOS and macOS workspace configuration files (\.xcworkspace\ and \IDEWorkspaceChecks.plist\) for the Runner project. This ensures that the gallery app can be built and tested on Apple platforms using the standard Xcode workspace structure, referencing both the main project and the CocoaPods dependencies.

_dev/integration\_tests/flutter\_gallery/ios/Runner.xcworkspace, dev/integration\_tests/flutter\_gallery/macos/Runner.xcodeproj/project.xcworkspace, dev/integration\_tests/flutter\gallery/macos/Runner.xcworkspace · high confidence

The Flutter Gallery integration test app now requires iOS 15.0 or later to run. This is enforced by the new AppFrameworkInfo.plist file, which sets the MinimumOSVersion to 15.0, and the addition of standard Debug and Release xcconfig files to manage build configurations. Users running this gallery on devices with iOS versions prior to 15 will no longer be able to build or run the application.

_dev/integration\_tests/flutter\gallery/ios/Flutter · high confidence

The Xcode project configuration for the Flutter Gallery integration test has been updated to target Xcode 15.1, as indicated by the \LastUpgradeCheck\ value of 1510 in the project file. This ensures the test app's build settings and project structure are compatible with the latest Xcode release.

_dev/integration\_tests/flutter\gallery/ios/Runner.xcodeproj · high confidence

The Flutter Gallery integration test application has been reorganized into a new directory structure and updated to use modern Dart and Flutter APIs. The app now includes a delayed startup entry point to simulate initialization delays for benchmarking, and all demo widgets have been migrated to use super parameters and the latest Material 3 styling. Configuration files such as analysis options and gitignore have been added to standardize linting and build artifacts for the test environment.

_dev/integration\_tests/flutter\gallery · high confidence

The Flutter Gallery integration test now uses Gradle 9.3.1, as specified in the newly created \gradle-wrapper.properties\ file. This update ensures the test environment aligns with the latest Gradle distribution, which is necessary for compatibility with newer Android Gradle Plugin versions and to resolve deprecations associated with previous Gradle releases.

_dev/integration\_tests/flutter\gallery/android/gradle · high confidence

The Flutter Gallery web integration test now uses a new \index.html\ and \manifest.json\ template. The manifest sets the PWA display mode to 'standalone' and updates meta tags to use the modern \mobile-web-app-capable\ attribute alongside the legacy \apple-mobile-web-\*\ tags. The HTML template includes a placeholder for the base href and loads the Flutter bootstrap script, preparing the gallery for execution with WebAssembly (Wasm) and improved service worker handling.

_dev/integration\_tests/flutter\gallery/web · high confidence

The Flutter Gradle Plugin source code has been converted from Groovy to Kotlin, introducing new utility classes and tasks to support the Android Gradle Plugin (AGP) 9 DSL. This includes the \AppLinkSettings\ data class for managing app link configurations, the \CompileSdkVersion\ helper for handling numeric and preview SDK levels, and the \ValidateCompileSdkVersionTask\ which now explicitly checks and warns when project compile SDK or NDK versions are lower than those required by plugins. These changes ensure the plugin correctly interfaces with the modern AGP APIs and provides clearer guidance for version mismatches.

gradle · high confidence

The skill for rebuilding the Flutter tool and CLI has been updated to use a Dart-based script (rebuild.dart) instead of the previous implementation. This script now explicitly cleans the flutter\_tools snapshot and stamp files from the cache directory before triggering a rebuild by running 'flutter help', providing a standardized workflow for users to compile or regenerate the Flutter CLI.

.agents/skills/rebuilding-flutter-tool · high confidence

The specification for front-face orientation and winding order has been moved from the general context into the rendering pipeline itself. This change ensures that these geometric properties are managed as part of the pipeline state, which can improve rendering consistency and performance by allowing the Impeller backend to optimize draw calls based on explicit pipeline configuration rather than global state.

engine · high confidence

The scripts responsible for downloading and updating the Dart SDK on Windows have been updated to limit the number of retry attempts and to fall back to Invoke-WebRequest if the primary BITS transfer method fails. This ensures that SDK updates complete more reliably in environments where BITS might be unavailable or unstable, preventing installation hangs or failures.

bin/internal · high confidence

The iOS integration test for app flavors now includes a properly initialized workspace file (contents.xcworkspacedata) that references the local project. This ensures the Xcode workspace structure is correctly set up for the test environment, supporting the build and execution of iOS apps using Swift Packages within the flavors test suite.

_dev/integration\tests/flavors/ios/Runner.xcodeproj/project.xcworkspace · medium confidence

The microbenchmarks iOS runner now includes a dedicated Xcode workspace structure. This adds the workspace definition file linking to the project, a settings file disabling Xcode Previews, and a workspace check file to prevent source control conflicts, ensuring the benchmark target builds correctly within the Xcode environment.

dev/benchmarks/macrobenchmarks/ios/Runner.xcodeproj/project.xcworkspace, dev/benchmarks/microbenchmarks/ios/Runner.xcworkspace · high confidence

The iOS benchmark app for platform views layout hybrid composition now includes a properly configured Xcode workspace. This adds the workspace definition file, enables the IDE 32-bit warning check, and disables SwiftUI Previews to streamline the build process for performance testing.

_dev/benchmarks/platform\_views\_layout\_hybrid\composition/ios/Runner.xcodeproj/project.xcworkspace · high confidence

The platform interaction integration test has been updated to use Gradle 9.3.1, as indicated by the new gradle-wrapper.properties file. This ensures the test environment aligns with the latest Gradle version, potentially affecting build behavior and compatibility with Android Studio and AGP versions used in the test.

_dev/integration\_tests/android\_verified\_input/android/gradle, dev/integration\_tests/platform\_interaction/android/gradle, dev/integration\tests/ui/android/gradle · high confidence

The Xcode project for the \ios\_app\_with\_extensions\ integration test has been updated to include a watchOS companion app and its extension. This change adds the necessary build phases, file references, and group structures to compile and embed the \watch Extension.appex\, allowing the test suite to verify the interaction between the iOS app and its watchOS counterpart.

_dev/integration\_tests/ios\_app\_with\extensions/ios/Runner.xcodeproj · high confidence

The \module\_host\_with\_custom\_build\_v2\_embedding\ integration test now uses Gradle 9.3.1, as specified in the newly added \gradle-wrapper.properties\ file. This ensures the test environment aligns with the latest Gradle distribution for validating embedding v2 behavior.

_dev/integration\_tests/android\_views/android/gradle, dev/integration\_tests/module\_host\_with\_custom\_build\_v2\embedding/gradle · high confidence

The layers example application no longer renders a visual demo; instead, it displays a text message instructing users to run specific example files (e.g., 'flutter run xxx/yyy.dart') to view the actual layer demonstrations.

examples/layers · high confidence

The Gradle wrapper configuration for the Android manual test app has been updated to use Gradle version 9.3.1. This ensures the test environment aligns with the latest Gradle distribution, which may be required to support newer Android Gradle Plugin features or resolve compatibility issues with the bundled Java version in Android Studio.

_dev/integration\_tests/channels/android/gradle, dev/manual\tests/android/gradle · high confidence

The manual\_tests application has been completely reorganized to support running on macOS and web platforms. This includes adding platform-specific configuration files like .gitignore and .metadata, and replacing the previous single-entry-point structure with a modular set of demo files (such as actions, animated\_icons, card\_collection, density, drag\_and\_drop, focus, hardware\_keyboard, hover, menu\_anchor, and overlay\_geometry) that can be run individually via flutter run -t.

_dev/manual\tests · high confidence

The framework now defaults to Material Design 3 (M3) styling for all Material widgets. This change updates the default appearance of components such as buttons, cards, and text fields to align with the M3 specification, replacing the previous Material 2 (M2) defaults. Users relying on the legacy M2 look will need to explicitly opt out by setting \useMaterial3: false\ in their \MaterialApp\ or \WidgetsApp\ configuration.

packages/flutter · high confidence

The iOS Runner for the Stocks benchmark app has been updated to use the modern UIScene lifecycle. This involves adding a SceneDelegate configuration in Info.plist (pointing to FlutterSceneDelegate) and updating the AppDelegate to implement the FlutterImplicitEngineDelegate protocol for plugin registration, ensuring the app behaves correctly on iOS 13+ and supports multiple windows if enabled.

_dev/benchmarks/test\apps/stocks/ios/Runner · high confidence

The iOS project for the a11y\_assessments sample app has been updated to use the modern UIScene lifecycle. The Info.plist now declares a scene configuration pointing to FlutterSceneDelegate, and the AppDelegate implements FlutterImplicitEngineDelegate to support this architecture, replacing the legacy application-based lifecycle.

_dev/a11y\assessments/ios · high confidence

The test driver scripts in dev/benchmarks/complex\_layout have been replaced to use the integration\_test framework and flutter\_driver API. The new setup includes dedicated driver entry points (scroll\_perf.dart, semantics\_perf.dart, etc.) that enable the Flutter driver extension, and corresponding test files (scroll\_perf\_test.dart, semantics\_perf\_test.dart, etc.) that execute scroll and semantics performance benchmarks. The scroll tests now explicitly wait for the first frame rasterized, force garbage collection before tracing, and write timeline summaries to files. The semantics test now uses ADB to disable accessibility services to isolate initial tree creation timing and writes results as JSON.

_dev/benchmarks/complex\_layout/test\driver · high confidence

The iOS runner for the complex\_layout benchmark has been updated to use the modern UIScene lifecycle instead of the legacy application lifecycle. This involves adding a UIScene configuration in Info.plist that delegates scene management to FlutterSceneDelegate, updating the AppDelegate to implement the implicit engine bridge for plugin registration, and switching the entry point to use the @main attribute. Users running this benchmark on iOS will now benefit from the improved app lifecycle management and multi-window support provided by UIScene.

_dev/benchmarks/complex\layout/ios/Runner · high confidence

The CI bot scripts in dev/bots have been migrated to Dart null safety, ensuring they run correctly with the null-safe Dart SDK and removing legacy non-nullable handling code.

dev/bots · high confidence

The image\_list example has been updated to use the material\_ui package instead of the core Flutter framework. This change introduces a dependency on the external material\_ui library and updates the application structure to utilize its components, such as the MaterialApp and related UI widgets, while maintaining the existing functionality of loading images from a local secure HTTP server for performance testing.

_examples/image\_list, examples/platform\_channel, examples/platform\view · high confidence

The macrobenchmarks iOS application has been updated to use the modern UIScene lifecycle instead of the legacy application lifecycle. This change involves adding a SceneDelegate configuration in Info.plist and implementing the new AppDelegate structure to support implicit engine initialization, ensuring the benchmark app aligns with current iOS standards and supports indirect input events.

dev/benchmarks/macrobenchmarks/ios/Runner · high confidence

The iOS runner for the microbenchmarks example has been updated to use the modern UIScene lifecycle instead of the legacy application lifecycle. This involves configuring the Info.plist to define a scene configuration with a FlutterSceneDelegate, updating the AppDelegate to implement the implicit engine delegate protocol for plugin registration, and adjusting the main entry point to align with the new scene-based initialization model.

dev/benchmarks/microbenchmarks/ios/Runner · high confidence

The multiple\_windows example app has been rewritten to showcase the full range of window types supported by the windowing API. It now includes interactive demonstrations for regular, dialog, tooltip, and popup windows, each with dedicated UI components and edit dialogs for adjusting properties like size, position, and anchors. The app uses the WindowRegistry to manage and display all open windows in a central table, allowing users to create, edit, and destroy any window type directly from the interface.

_examples/multiple\windows · high confidence

The documentation generation system now uses dedicated HTML skeleton templates to render code samples and snippets. Three new files define the structure: \dartpad-sample.html\ embeds an interactive DartPad iframe with clipboard-write permissions and channel support; \sample.html\ displays copyable code blocks with a 'Copy to clipboard' button and a command to create a local project; and \snippet.html\ provides a similar copyable code block structure for general snippets. These templates standardize how code examples appear in the generated API docs, including anchor links for sharing and consistent styling.

dev/snippets/config/skeletons · high confidence

A new \dev/checks\ script has been added to run the \checks\_tool\ located in the \dev/checks\_tool\ directory, providing a convenient entry point for internal development checks. Additionally, \dev/analysis\_options.yaml\ now includes the \flutter\_analyzer\_plugin\ and explicitly disables \avoid\_print\, \only\_throw\_errors\, \avoid\_catching\_errors\, and \avoid\_catches\_without\_on\_clauses\ to accommodate debugging practices and test behaviors within the framework's development environment.

dev · high confidence

The iOS host application used for add-to-app integration tests has been replaced with a new implementation that supports modern iOS lifecycle patterns (UIScene/SceneDelegate) and provides a suite of demo views. These views allow testers to exercise specific Flutter embedding behaviors, including cold and warm engine initialization, full-screen embedding, hybrid Flutter/native layouts with message channel communication, dual Flutter views, and dynamic content resizing.

_dev/integration\_tests/ios\_host\app/Host · high confidence

The iOS Runner for the channels integration test has been replaced with a new implementation that registers platform channels directly in the AppDelegate. This setup supports testing binary, string, JSON, and standard message codecs, as well as method channels, including custom serialization for Date and Pair types via an extended standard codec. The app also configures UISceneDelegate via Info.plist to ensure compatibility with modern iOS lifecycle handling while maintaining backward compatibility for channel registration.

_dev/integration\tests/channels/ios/Runner · high confidence

The packages autoroller is now a standalone Dart tool located in dev/packages\_autoroller, separated from the conductor framework. It is executed via the dev/packages\_autoroller/run script and uses the dart build cli system to generate a binary for regenerating Gradle lockfiles. The tool automates the process of updating pub packages and opening pull requests, featuring a new Git abstraction for safer subprocess handling, token redaction in logs, and validation to ensure only lockfile changes are committed.

_dev/packages\autoroller · high confidence

The Android side of the platform\_channel example has been migrated to the new Android embedding v2, requiring the app to extend FlutterActivity and override configureFlutterEngine to register platform channels instead of using the deprecated GeneratedPluginRegistrant. The example now explicitly declares android:exported on the main activity and includes the required \<queries\> block in the manifest for text processing. Additionally, the example demonstrates how to retrieve battery level and charging status via platform channels, exposing this information to the Flutter UI.

_examples/platform\channel/android · high confidence

The \android\_verified\_input\ integration test, which verifies that MotionEvents delivered to platform views are correctly validated, has been re-enabled. This change restores the test directory and its associated Flutter application code, allowing the test to run again after previous removals.

_dev/integration\_tests/android\_verified\input · high confidence

The \dev/bots/prepare\_package\ script has been refactored from a single monolithic file into a modular Dart package structure. The new layout introduces \archive\_creator.dart\ to handle SDK archive generation (including support for the \--target\_arch\ option), \archive\_publisher.dart\ to manage Google Cloud Storage uploads and metadata updates, \process\_runner.dart\ to standardize subprocess execution, \transactional\_update.dart\ to ensure safe concurrent metadata writes, and \common.dart\ to centralize shared constants and types. This change improves maintainability and testability of the package preparation workflow.

_dev/bots/prepare\package · high confidence

The monolithic test execution logic in \dev/bots\ has been reorganized into a set of distinct, single-responsibility runner scripts under \dev/bots/suite\_runners/\. This change introduces dedicated entry points for specific test suites—including Android engine and hardware smoke tests, web tests, framework coverage, and codesign verification—allowing each suite to be executed, sharded, and debugged independently. For example, the new \run\_android\_engine\_tests.dart\ and \run\_android\_hardware\_smoke\_tests.dart\ scripts handle Impeller backend configuration and golden file management for Android, while \run\_web\_tests.dart\ manages the complex build modes and known failures for the web shard. This modularization improves maintainability and local debugging capabilities for the continuous integration infrastructure.

_dev/bots/suite\runners · high confidence

The \bin\ directory entry points (\flutter\, \flutter.bat\, \dart\, \dart.bat\) and new development scripts (\flutter-dev\, \flutter-dev.bat\) have been refactored to enhance reliability on Windows. The batch scripts now explicitly detect and support both legacy PowerShell (PowerShell.exe) and modern PowerShell (pwsh.exe), ensure Git is available in the PATH, and utilize a bundled \mingit\ if present. Execution logic has been hardened to prevent errors when scripts are modified during runtime by chaining commands with ampersands instead of \CALL\. Additionally, the new \flutter-dev\ scripts allow developers to run the Flutter tool directly from source code without relying on prebuilt snapshots, facilitating faster iteration during tool development.

bin · high confidence

The manual tests iOS runner now includes a standard Xcode workspace file (contents.xcworkspacedata) that references the project itself. This change reverts previous attempts to build iOS apps using Swift Packages, restoring the original project structure for the manual tests target.

_dev/manual\tests/ios/Runner.xcodeproj/project.xcworkspace · medium confidence

The Android side of the release smoke test integration test has been migrated to the Android embedding v2 (explicitly declared in AndroidManifest.xml) and upgraded to Android Gradle Plugin 9.1.0 (evidenced by the new Gradle lockfiles). The test app's MainActivity now extends FlutterActivity, and the project includes a new Android instrumentation test (MainActivityTest) to verify the activity launches correctly.

_dev/integration\_tests/release\_smoke\test/android · high confidence

The iOS release smoke test project has reverted the integration of Swift Packages. The workspace configuration file (contents.xcworkspacedata) has been reset to a minimal default state, removing the references to Swift Package dependencies that were previously added. This change restores the test project to its prior build configuration, undoing the experimental Swift Package support.

_dev/integration\_tests/release\_smoke\test/ios/Runner.xcodeproj/project.xcworkspace · high confidence

The build configuration for the skcms module has been updated to explicitly define and enable CPU-specific transform code paths for x64 architectures (excluding Android). This change introduces build targets for Haswell (AVX2) and Skylake (AVX512) optimizations, applying the necessary compiler flags (such as -mavx2, -mavx512f, etc.) to leverage hardware capabilities for color transformation performance where supported.

engine/src/flutter/skia/modules/skcms · high confidence

The .claude/skills location is now a symbolic link pointing to ../.agents/skills, indicating that the skills configuration has been moved to the .agents directory.

.claude · low confidence

The build configuration for the Skunicode module has been updated to reside within the Flutter engine's internal third-party directory structure (//flutter/third\_party/skia). This change consolidates the build logic, ensuring that Skunicode dependencies and source files are correctly resolved relative to the new Skia location, while maintaining support for various Unicode implementations (ICU, client ICU, libgrapheme, and bidi) through conditional build flags.

engine/src/flutter/skia/modules/skunicode · high confidence

The splash example application has been updated to use the material\_ui package, replacing its previous implementation. This change modernizes the example's dependencies and ensures it aligns with the current material design standards provided by the library.

examples/splash · high confidence

The \ios\_app\_with\_extensions\ integration test now includes explicit Xcode workspace configuration files (\contents.xcworkspacedata\, \IDEWorkspaceChecks.plist\, and \WorkspaceSettings.xcsettings\). This ensures consistent workspace settings, such as disabling previews, across different development environments and prevents build inconsistencies related to workspace state.

_dev/integration\_tests/ios\_app\_with\extensions/ios/Runner.xcodeproj/project.xcworkspace · high confidence

The iOS integration test project now includes explicit workspace settings to suppress the 32-bit architecture warning and disable SwiftUI Previews. This ensures a consistent build environment for developers and CI systems by preventing unnecessary warnings and avoiding the overhead of preview rendering during test runs.

_dev/integration\tests/channels/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata · high confidence

The macOS Runner for the Flutter Gallery integration test now uses a dedicated set of xcconfig files to manage build settings. This change introduces explicit application metadata (name, bundle identifier, copyright) in AppInfo.xcconfig, separates Debug and Release build configurations, and enforces a strict set of compiler warnings and sanitizers via Warnings.xcconfig to improve code quality and consistency during testing.

_dev/integration\_tests/flutter\gallery/macos/Runner/Configs · high confidence

The \dev/benchmarks/macrobenchmarks/test\_driver\ directory has been restructured to use a unified \macroPerfTest\ helper and a common \util.dart\ module. This change standardizes how performance tests are executed by centralizing driver connection, garbage collection, page navigation, and timeline summary writing. It introduces consistent configuration options such as \pageDelay\ and \duration\ for most benchmarks, while allowing specific tests (like \fullscreen\_textfield\ and \path\_stress\_tessellation\) to define custom \driverOps\ for complex interactions like scrolling or tapping. Additionally, the \e2e\_test.dart\ driver has been migrated to use the \integration\_test\ package, and specialized drivers for \animated\_image\ and \large\_image\_changer\ have been added to handle specific frame-count and platform-dependent tracing requirements.

_dev/benchmarks/macrobenchmarks/test\driver · high confidence

The Swift-based iOS host application in the integration tests has been updated to use the modern \@main\ attribute for its entry point instead of the legacy \@UIApplicationMain\ attribute. This change is accompanied by the addition of a \SceneDelegate\ and corresponding storyboard configurations, aligning the app with current iOS scene-based lifecycle requirements. For users of this integration test setup, this ensures compatibility with newer Xcode versions and iOS SDKs that deprecate the older application delegate-centric model.

_dev/integration\_tests/ios\_host\_app\swift/Host · high confidence

The \platform\_channel\_swift\ example has been updated to use the \material\_ui\ package instead of the default Flutter widgets, and it now displays the device's battery charging status in addition to the battery level. The UI is built using \Material\ and \ElevatedButton\ components, and the example listens to the \EventChannel\ to update the charging status text in real-time.

_examples/platform\_channel\swift · high confidence

The Gradle wrapper configuration for the Android microbenchmarks has been updated to use Gradle 9.3.1. This ensures that the benchmark suite uses the latest Gradle distribution, aligning with recent template and test infrastructure upgrades.

dev/benchmarks/microbenchmarks/android/gradle · high confidence

The Xcode project schemes for the microbenchmarks, platform\_views\_layout, and platform\_views\_layout\_hybrid\_composition benchmark runners have been updated to set the last upgrade version to 15.1. This ensures these development projects are compatible with the latest Xcode tooling and prevents unnecessary migration prompts when opened in modern versions of the IDE.

_dev/benchmarks/microbenchmarks/ios/Runner.xcodeproj/xcshareddata, dev/benchmarks/platform\_views\_layout/ios/Runner.xcodeproj/xcshareddata, dev/benchmarks/platform\_views\_layout\_hybrid\composition/ios/Runner.xcodeproj/xcshareddata · high confidence

The iOS project for the complex\_layout benchmark has been migrated to be compatible with Xcode 15.1, as indicated by the LastUpgradeCheck attribute set to 1510 in the project.pbxproj file. This ensures the benchmark runner builds correctly with the latest Xcode tooling.

_dev/benchmarks/complex\layout/ios/Runner.xcodeproj · high confidence

The iOS Runner project files have been regenerated to match the new Xcode project template. This migration introduces a scene-based application lifecycle (using \FlutterSceneDelegate\ and \UIWindowScene\) and updates the \AppDelegate\ to implement \FlutterImplicitEngineDelegate\ for implicit engine initialization. Additionally, the \Info.plist\ now includes \CADisableMinimumFrameDurationOnPhone\ and \UIApplicationSupportsIndirectInputEvents\ settings, and uses \$(DEVELOPMENT\_LANGUAGE)\ for the development region.

_dev/integration\tests/ui/ios/Runner · high confidence

The iOS project configuration for the stocks benchmark app has been updated to target Xcode 15.1, ensuring the build system and project file structure are compatible with the latest Xcode version. This change aligns the benchmark tooling with current development environments without altering the application's runtime behavior.

_dev/benchmarks/test\apps/stocks/ios/Runner.xcodeproj · high confidence

The Xcode project for the iOS macrobenchmarks runner has been migrated to support Xcode 15.1, ensuring the benchmark application builds correctly with the latest development tools. This update aligns the project's last upgrade check and configuration with current Xcode standards, maintaining compatibility for developers running performance tests on iOS.

dev/benchmarks/macrobenchmarks/ios/Runner.xcodeproj · high confidence

The iOS project for the spell check integration test has been migrated to Xcode 15.1 and updated to require a minimum deployment target of iOS 15.0. This ensures the test environment aligns with current development standards and tooling versions.

_dev/integration\_tests/spell\check/ios · high confidence

The release smoke test integration app now requires iOS 15.0 or later to run. This change updates the \MinimumOSVersion\ in the \AppFrameworkInfo.plist\ and adjusts the associated build configuration files (\Debug.xcconfig\, \Release.xcconfig\) to reflect the new baseline, ensuring the test environment aligns with current platform requirements.

(repo-wide) · high confidence

The Xcode scheme for the macrobenchmark iOS runner has been migrated to target Xcode 15.1 (indicated by LastUpgradeVersion 1510). This ensures the benchmark project's build and launch configurations are compatible with the latest Xcode toolchain, allowing developers to run performance tests without version mismatch warnings or build failures.

dev/benchmarks/macrobenchmarks/ios/Runner.xcodeproj/xcshareddata · high confidence

The Xcode project file for the manual\_tests iOS app has been updated to set the last upgrade check to 1510 (Xcode 15.1) and the project compatibility version to Xcode 9.3. This ensures the project structure is recognized as up-to-date by modern Xcode versions, preventing unnecessary migration prompts or build warnings when opening the project.

_dev/integration\_tests/release\_smoke\_test/ios/Runner.xcodeproj, dev/manual\tests/ios/Runner.xcodeproj · high confidence

The Xcode scheme for the stocks benchmark app has been updated to set the last upgrade version to 15.1, ensuring compatibility with the latest Xcode release. This change updates the project's build and launch configuration metadata to reflect the current development environment standards.

_dev/benchmarks/test\apps/stocks/ios/Runner.xcodeproj/xcshareddata · high confidence

The IntelliJ IDEA project templates (.iml.copy.tmpl) for core Flutter packages (flutter, flutter\_driver, flutter\_localizations, flutter\_test, and flutter\_tools) have been updated. These changes ensure that the generated project files correctly exclude build directories and properly configure Dart SDK, Dart Packages, and Flutter Plugins order entries, with the flutter\_tools template additionally excluding specific test data build folders.

(repo-wide) · high confidence

The generated defaults data has been updated to use Material Design 3 tokens version 6.1.0. This refreshes the underlying design specifications for components such as Assist Chips, Badges, Date Pickers, Dialogs, Buttons, and Cards, ensuring that the framework's default styles align with the latest M3 guidelines.

_dev/tools/gen\defaults/generated · high confidence

The Windows runner code for the complex\_layout benchmark has been updated to a modern implementation. This includes a new CMake build configuration, a resource script that embeds Flutter version metadata, and a manifest declaring PerMonitorV2 DPI awareness for correct scaling on Windows 10/11. The C++ source files now use the FlutterViewController API, handle command-line argument conversion safely using wcsnlen to prevent buffer over-reads, and support console attachment for debugging.

_dev/benchmarks/complex\layout/windows/runner · high confidence

The integration test project's Xcode scheme has been updated to reflect the last upgrade version as 15.1 (1510). This ensures the project configuration aligns with the latest Xcode standards, preventing version mismatch warnings or build issues when opened in newer versions of the IDE.

_dev/integration\_tests/ios\_app\_with\extensions/ios/Runner.xcodeproj/xcshareddata · high confidence

The Xcode scheme for the manual tests iOS app has been updated to version 1.3 with a last upgrade version of 1510 (Xcode 15.1). This ensures the project configuration is compatible with modern Xcode versions and enables GPU validation mode during launch, which helps developers catch graphics-related issues while running the manual tests.

_dev/integration\_tests/flutter\_gallery/ios/Runner.xcodeproj/xcshareddata, dev/manual\tests/ios/Runner.xcodeproj/xcshareddata · high confidence

The Xcode scheme for the \Runner\ app in the iOS channels integration test has been updated to version 1.3 with a last upgrade version of 15.1. This change ensures the test project is compatible with modern Xcode versions and correctly configures build, test, launch, and profiling actions for the integration test environment.

_dev/integration\tests/channels/ios/Runner.xcodeproj/xcshareddata · high confidence

The iOS manual tests project now includes explicit workspace settings to suppress the 32-bit architecture warning and disable the Previews feature in Xcode, ensuring a cleaner build environment for manual testing.

_dev/manual\tests/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata · high confidence

The Xcode scheme for the complex\_layout benchmark has been updated to target Xcode 15.1 (LastUpgradeVersion 1510). This ensures the benchmark project remains compatible with the latest Xcode version and includes configuration for GPU validation mode during launch.

_dev/benchmarks/complex\layout/ios/Runner.xcodeproj/xcshareddata · high confidence

The iOS Runner project files have been updated to align with current Apple development standards. The Swift entry point now uses the @main attribute instead of @UIApplicationMain, and the Info.plist has been configured to enable UIViewControllerBasedStatusBarAppearance, disable minimum frame duration on phones, and define scene configurations for the Flutter scene delegate. These changes ensure the integration test app builds correctly with newer Xcode versions and adheres to modern iOS lifecycle requirements.

_dev/integration\_tests/ios\_app\_with\extensions/ios/Runner · high confidence

The manual\_tests iOS app has been updated to use the modern @main entry point in Swift instead of @UIApplicationMain, and its Info.plist now configures UIWindowScene with a FlutterSceneDelegate. This change aligns the test app with current iOS project templates, ensuring it supports the latest scene-based lifecycle and implicit engine registration patterns.

_dev/manual\tests/ios/Runner · high confidence

The complex\_layout iOS benchmark project has been updated to require a minimum deployment target of iOS 15.0, as defined in the new AppFrameworkInfo.plist. The project structure now includes standard Flutter iOS configuration files, including Debug and Release xcconfig files for build settings, and a workspace configuration that references both the main Xcode project and the CocoaPods dependencies.

_dev/benchmarks/complex\layout/ios/Flutter · high confidence

The iOS runner for the platform views layout hybrid composition benchmark has been updated to set the minimum deployment target to iOS 15.0. This change ensures the benchmark application is built and tested against modern iOS versions, aligning with current platform requirements.

_dev/benchmarks/platform\_views\_layout\_hybrid\composition/ios/Flutter · high confidence

The LaunchScreen.storyboard and Main.storyboard files in the complex\_layout and microbenchmarks iOS runners have been replaced with updated versions. These changes align the iOS project configurations with the HelloServices model and ensure the storyboards use consistent Xcode tool versions, resolving issues with outdated runner templates.

_dev/benchmarks/complex\layout/ios/Runner/Base.lproj, dev/benchmarks/microbenchmarks/ios/Runner/Base.lproj · medium confidence

The manual tests iOS project now uses regenerated LaunchScreen.storyboard and Main.storyboard files that align with the current project template. These changes update the Interface Builder tool versions and plugin identifiers within the storyboards, ensuring compatibility with modern Xcode tooling and resolving previous issues related to encoded Xcode tools versions.

_dev/manual\tests/ios/Runner/Base.lproj · medium confidence

The iOS workspace for the manual tests application has been restructured to align with the current project template. This includes adding the standard workspace data file, enabling the IDE 32-bit warning check, and disabling previews in the workspace settings to ensure a consistent development environment.

_dev/integration\_tests/channels/ios/Runner.xcworkspace, dev/manual\tests/ios/Runner.xcworkspace · high confidence

The macOS project for the complex\_layout benchmark has been regenerated to align with current Flutter tooling. The Xcode project is now configured for Xcode 15.1 (object version 54) and includes a workspace scheme that enables GPU validation mode for Metal debugging. The Swift entry point has been migrated to use the @main attribute, and the application now supports secure restorable state by default. Additionally, the project enforces stricter compiler warnings and includes sandbox entitlements for both debug and release builds.

_dev/benchmarks/complex\layout/macos · high confidence

The iOS project for the microbenchmarks has been migrated to support Xcode 15.1, updating the project's last upgrade check to 1510 and ensuring compatibility with the latest Xcode toolchain. This change updates the underlying build configuration to reflect the current development environment standards for iOS benchmarking.

dev/benchmarks/microbenchmarks/ios/Runner.xcodeproj · high confidence

The benchmark module in dev/benchmarks/multiple\_flutters/module has been updated to use modern Dart and Flutter conventions. The main application code now utilizes super parameters for constructors (e.g., {super.key}) and includes explicit entry-point pragmas for topMain and bottomMain functions. Additionally, the module's configuration files (.gitignore and .metadata) have been refreshed to reflect current tooling standards, including the removal of obsolete plugin references and an update to the tracked Flutter revision.

_dev/benchmarks/multiple\flutters/module · high confidence

The project now explicitly tracks the Ninja build tool within the third\_party directory, replacing the previous gclient-managed approach. A new .gitignore file ensures that only specific, necessary folders are version-controlled while ignoring others, and a README.flutter file has been added to document Ninja's origin, license, and revision source (CIPD), providing clearer visibility into this critical build dependency for users and contributors.

_third\party · high confidence

The Android build configuration for the a11y\_assessments sample app now uses Gradle 9.3.1. This ensures the project builds with the latest Gradle release, providing access to new features and performance improvements while maintaining compatibility with the existing Android Gradle Plugin setup.

(repo-wide) · high confidence

The web end-to-end test suite has been updated to load the CanvasKit rendering engine from a local bundle rather than a CDN. This change, implemented via a new flutter\_bootstrap.js configuration in the test app, aims to improve test stability by removing external network dependencies.

_dev/integration\_tests/web\_e2e\tests/web · high confidence

The \widget\_preview\_scaffold\ project template, used to host widget previews, has been updated with several new capabilities. Users can now search and filter previews by group name, preview name, containing script, or package. The preview viewer includes improved zoom behavior with a slider and controls to zoom in, out, and reset. Additionally, the scaffold now integrates with the Dart Tooling Daemon (DTD) to support IDE features such as navigating to code locations and syncing editor themes (dark/light mode, colors). A fix also ensures that resizing the split pane no longer loses focus when dragging over WebViews/iframes.

_dev/integration\_tests/widget\_preview\scaffold · high confidence

The iOS Runner for the Flutter Gallery integration test has been migrated to the modern iOS application lifecycle. The app delegate now implements the \FlutterImplicitEngineDelegate\ protocol to handle implicit engine initialization, and the \Info.plist\ has been updated to use \UIScene\ configurations (specifically \UIWindowScene\) instead of the legacy \UIWindow\ approach. Additionally, the \CADisableMinimumFrameDurationOnPhone\ setting is enabled to enforce minimum frame durations on iPhone.

_dev/integration\_tests/flutter\gallery/ios/Runner · high confidence

The iOS host application for the \ios\_add2app\_life\_cycle\ integration test has been updated to use the modern \UIScene\ lifecycle (via \SceneDelegate\) and migrated to Earl Grey 2 for UI testing. The app now initializes a shared \FlutterEngine\ in the \AppDelegate\ and presents it via a \FullScreenViewController\, allowing the new Earl Grey 2-based integration tests to verify Flutter semantics updates and view transitions.

_dev/integration\_tests/ios\_add2app\_life\_cycle/ios\add2app · high confidence

The Xcode project for the iOS add-to-app lifecycle integration test has been regenerated to target Xcode 15.1 and migrate the UI testing framework to EarlGrey 2. This update ensures the test host application and its associated unit tests are built with the latest iOS SDK standards, providing a more reliable environment for validating Flutter app lifecycle events within native iOS hosts.

_dev/integration\_tests/ios\_add2app\_life\_cycle/ios\add2app.xcodeproj · high confidence

The iOS runner for the release smoke test has been migrated to the modern iOS app lifecycle. The app now uses a SceneDelegate (exporting FlutterSceneDelegate) and configures UISceneManifest in Info.plist, replacing the legacy window-based startup. Additionally, the AppDelegate implements the FlutterImplicitEngineDelegate protocol to handle plugin registration via the implicit engine bridge, and Info.plist enables CADisableMinimumFrameDurationOnPhone and UIApplicationSupportsIndirectInputEvents.

_dev/integration\_tests/release\_smoke\test/ios/Runner · high confidence

The iOS runner for the platform views layout hybrid composition benchmark has been updated to use the modern UIScene application lifecycle (configuring UISceneDelegateClassName as FlutterSceneDelegate in Info.plist) and implements the FlutterImplicitEngineDelegate protocol in its AppDelegate. This change migrates the benchmark app to the implicit engine model, allowing it to initialize the Flutter engine and register platform view plugins (specifically DummyPlatformView) via the didInitializeImplicitFlutterEngine callback, ensuring the benchmark runs correctly on newer iOS deployment targets that require scene-based lifecycle management.

_dev/benchmarks/platform\_views\_layout\_hybrid\composition/ios/Runner · high confidence

The Xcode project file for the iOS platform channels benchmark runner has been migrated to support Xcode 15.1, indicated by the \LastUpgradeCheck\ attribute set to 1510. This ensures the benchmark application builds correctly with the latest Xcode toolchain and maintains compatibility with the current Flutter iOS template standards.

_dev/benchmarks/platform\_channels\_benchmarks/ios/Runner.xcodeproj, dev/benchmarks/platform\_views\layout/ios/Runner.xcodeproj · high confidence

The iOS runner for the platform channels benchmarks has been migrated to use the modern UIScene lifecycle (configuring UIWindowScene and FlutterSceneDelegate in Info.plist) and implements the FlutterImplicitEngineDelegate protocol. This allows the benchmark app to register and measure performance for background platform channels (specifically dev.flutter.echo.background.standard) alongside standard basic message channels, providing more comprehensive benchmarking capabilities for developers.

_dev/benchmarks/platform\_channels\benchmarks/ios/Runner · high confidence

The Xcode schemes for the 'free' and 'paid' integration test flavors have been updated to support case-insensitive matching of flavor names against Xcode schemes. This change ensures that build and launch configurations remain robust regardless of the casing used for the flavor identifier, preventing potential mismatches in the test environment.

_dev/integration\tests/flavors/ios/Runner.xcodeproj/xcshareddata · medium confidence

The iOS Runner for the flavors integration test has been updated to support modern iOS app lifecycle patterns. The application delegate now implements the \FlutterImplicitEngineDelegate\ protocol and registers plugins via the \didInitializeImplicitFlutterEngine\ callback, aligning with the implicit engine model. Additionally, the Info.plist files for both 'Free' and 'Paid' flavors now declare a \UIApplicationSceneManifest\, configuring the app to use \UIWindowScene\ and \FlutterSceneDelegate\ instead of the legacy window-based lifecycle. The \CADisableMinimumFrameDurationOnPhone\ key is also set to true in these plists.

_dev/integration\tests/flavors/ios/Runner · high confidence

The iOS host app integration test has been updated to materialize a proper Xcode workspace that includes both the main project and the Pods project. This change enables the use of CocoaPods for dependency management within the host app, allowing the integration tests to verify scenarios that rely on pod-based libraries.

_dev/integration\_tests/ios\_host\_app/Host.xcodeproj/project.xcworkspace, dev/integration\_tests/ios\_host\app/Host.xcworkspace · high confidence

The iOS host application project file has been migrated to use the Xcode 15.1 project format (objectVersion 54) and the minimum supported iOS version has been raised to 13.0. This ensures the integration test host app remains compatible with current Xcode toolchains and reflects the updated platform requirements for the Flutter iOS integration tests.

_dev/integration\_tests/ios\_host\app/Host.xcodeproj · high confidence

The iOS runner for the external\_textures integration test has been regenerated to target iOS 15.0 (up from 13.0) and now uses the UIScene lifecycle. The app delegate implements \FlutterImplicitEngineDelegate\ to support the implicit engine, and the Info.plist is configured with \FlutterSceneDelegate\ and \UIWindowScene\. The test view controller remains responsible for driving the external texture frame generation via a method channel.

_dev/integration\_tests/external\textures/ios · high confidence

The iOS integration test app for wide gamut testing has been updated to include an Info.plist that explicitly enables wide gamut color support via the FLTEnableWideGamut key. Additionally, the configuration has been migrated to use the scene-based UI lifecycle (UISceneConfigurations) instead of the legacy window-based approach, ensuring the test environment accurately reflects modern iOS application structure.

_dev/integration\_tests/wide\_gamut\test/ios · high confidence

The \flutter\_tools\ package now enforces a minimum iOS version of 13.0 for builds. This change updates the tooling to ensure that generated iOS projects and build configurations target at least iOS 13, aligning with modern platform requirements and removing support for older iOS versions in new or updated projects.

_packages/flutter\tools · high confidence

The macOS Runner project files for the Flutter Gallery integration test have been updated to align with current macOS development practices. The application entry point now uses the @main attribute in AppDelegate.swift instead of the legacy @NSApplicationMain attribute, and the main window initialization has been simplified. Secure restorable state is enabled by default, and the app delegate explicitly handles application termination behavior. Additionally, the Info.plist has been standardized with NSPrincipalClass set to NSApplication, and entitlements files have been separated into DebugProfile and Release configurations to properly manage sandboxing and JIT permissions for testing.

_dev/integration\_tests/flutter\gallery/macos/Runner · high confidence

The macOS Flutter build configuration for the integration test gallery has been updated to optionally include CocoaPods xcconfig files. The Flutter-Debug.xcconfig and Flutter-Release.xcconfig files now conditionally include the corresponding Pods-Runner xcconfig files, allowing the build to integrate CocoaPods dependencies when they are present while maintaining compatibility with setups that do not use CocoaPods.

_dev/integration\_tests/flutter\gallery/macos/Flutter · high confidence

The macOS integration test app now supports wide-gamut color rendering by configuring the app bundle to enable Impeller and overriding the window's view controller to force 10-bit surface support via reflection.

_dev/integration\_tests/wide\_gamut\test/macos · high confidence

The Xcode project file for the macOS manual tests application has been updated to set the last upgrade check to version 15.1 and the last Swift update check to 9.2. This ensures the project metadata aligns with the current Xcode toolchain, allowing developers to build and run the manual tests without version mismatch warnings or unnecessary migration prompts in the IDE.

_dev/manual\tests/macos/Runner.xcodeproj · high confidence

The integration test project now includes an Xcode workspace file that groups the main project and the CocoaPods dependencies, ensuring the test environment is correctly configured for building and running.

_dev/integration\_tests/ios\_add2app\_life\_cycle/ios\add2app.xcworkspace · high confidence

The stocks benchmark test app now includes the standard Xcode workspace configuration files (contents.xcworkspacedata and IDEWorkspaceChecks.plist). This ensures the iOS project is correctly recognized by Xcode, resolving issues where the workspace might not be properly generated or checked out, which previously caused build failures or required manual intervention to set up the workspace structure.

_dev/benchmarks/test\apps/stocks/ios/Runner.xcodeproj/project.xcworkspace · high confidence

Add Android custom host app integration test fixture; Add Android hardware smoke test driver with golden image verification; Add Android test app for record\_use integration tests; Add Xcode scheme for macOS Flutter Gallery integration tests; Add devicelab tasks for Android dependency version smoke tests and release dev-dependency exclusion; Add golden tests for Cupertino navigation demo; Add iOS UI tests for the Flutter integration host app; Add iOS UIScene integration test templates for SwiftUI and UIKit; Add iOS integration test project for channel communication; Add iOS launch and main storyboards to channels integration test; Add iOS platform view integration test project; Add iOS platform view integration test scaffolding; Add iOS workspace configuration for platform interaction integration test; Add integration test for display cutout rotation; Add integration test for user-defined native asset hooks; Add link hook integration test to verify asset linking behavior; Add link\_hook integration test for native assets; Add memory benchmark for complex layout scrolling; Add release smoke test to verify release-mode behavior; Add web compile tests for background isolate and dart:io support; Added Android and iOS platform view scroll performance benchmarks; Added Android host app for v2 embedding integration test; Added accessibility assessment tests for the a11y\_assessments app; Added automated tests for flutter\_tools test harness features; Added driver test for deferred component loading; Added driver tests for the Stocks benchmark app; Added end-to-end driver tests for hybrid Android views; Added end-to-end driver tests for window state and lifecycle; Added end-to-end macrobenchmark test suite; Added iOS Add2App lifecycle integration test suite; Added iOS platform view UI tests for focus, accessibility, and z-ordering; Added iOS workspace configuration for platform interaction integration test; Added instrumentation test runner script for Flutter Gallery; Added integration test app for record-use and icon tree-shaking features; Added integration test apps for iOS UIScene lifecycle and state restoration; Added integration test for app flavor verification; Added integration test for channels app; Added integration test for link hook native function invocation; Added integration test for runtime flavor detection; Added integration test harness for exception handling and trivial widgets; Added integration tests for Android platform views; Added integration tests for Android platform views and external textures; Added integration tests for Android semantics mapping; Added integration tests for FlutterDriver capabilities and UI behaviors; Added integration tests for HCPP platform view rendering and interaction; Added integration tests for UI resizing and smoke testing; Added integration tests for display cutout rotation behavior; Added integration tests for spell check functionality; Added integration tests for wide gamut (Display P3) rendering; Added macOS native integration tests for Flutter Gallery; Added missing dependency validation test; Added platform view scroll performance benchmarks and test drivers; Added scroll smoothness benchmark test; Added smoke test for the layers example; Added smoke tests for manual demo apps; Added smoke tests to verify test runner failure detection; Added spell check integration test for EditableText; Added static analysis test fixtures for lint rules; Added test files for flutter test directory scanning; Added test fixtures for static analysis validation; Added test for Android verified input integration; Added test for external texture frame consumption rates; Added test for loading assets from the same package; Added test infrastructure for Kotlin linting analysis; Added test input for localization generation script; Added test stubs for Android driver extensions; Added tests for CI validation, code sample checks, and cross-import analysis; Added tests for Flutter framework tracing and timeline events; Added tests for browser framework and trace event parsing; Added tests for dev/tools scripts and skill validation rules; Added tests for gen\_defaults template behavior; Added tests for the BuildTestTask runner behavior; Added tests for the customer test runner and common utilities; Added tests for the gen\_keycodes tool across all platforms; Added tests for the snippets tool configuration and generation logic; Added tracing tests to verify timeline logic compilation; Added unit and smoke tests for the Flutter Gallery calculator; Added unit and widget tests for android\_hardware\_smoke\_test; Added unit tests for Android semantics node parsing; Added unit tests for FlutterDeviceScreenshot utility; Added unit tests for devicelab framework components; Added unit tests for flutter\_analyzer\_plugin lint rules; Added unit tests for the vitool SVG parsing and path animation logic; Added web integration test for conditional import resolution; Added widget tests for Material demo components; Added widget tests for the Stocks benchmark app; Android hardware smoke test adds platform view and rendering tests with improved reliability and reporting; Integration test package for record\_use hook behavior; New Android engine integration tests for UI mode transitions and screenshot stability; New Android integration test fixtures and driver infrastructure for platform views; New Windows startup integration test; New engine integration golden test suite for primitive shapes and text rendering; New integration test drivers for Gallery performance and demo execution; New integration test to verify keyboard state after hot restart; New memory benchmark tests for navigation and image caching; New web end-to-end integration tests for image caching, deferred loading, and URL strategy; New web integration tests for stack traces, null safety, and resource loading; New windowing integration test app for end-to-end verification; Widget Preview Scaffold integration tests.

The multiple\_flutters benchmark's Android Gradle wrapper has been updated to use Gradle 9.3.1. This ensures the benchmark environment aligns with the latest Gradle distribution, potentially affecting build performance and compatibility for developers running these specific benchmarks.

_dev/benchmarks/multiple\flutters/android/gradle · high confidence

This change rolls the repository's pub packages and engine dependencies to their latest versions. This includes updates to core tooling packages such as \dwds\, \vm\_service\, \dds\, and \leak\_tracker\, as well as general dependency bumps across the framework and tools. These rolls ensure the SDK stays aligned with the latest Dart SDK releases and incorporates upstream fixes and improvements from the Flutter package ecosystem.

(dependencies) · high confidence

The sky\_engine package has been updated to include the latest Dart SDK and Skia library versions. This ensures that the engine's core Dart libraries and graphics rendering capabilities are aligned with the most recent upstream releases, providing improved stability and performance for Flutter applications.

_engine/src/flutter/sky/packages/sky\engine · high confidence

The engine's Android SDK dependency has been upgraded to version 35. This ensures compatibility with the latest Android platform features and tooling.

(repo-wide) · high confidence

The Android integration test app has been upgraded to use Android Gradle Plugin (AGP) 9.1.0 and Kotlin 2.4.0, with Gradle dependency lockfiles added to ensure reproducible builds. The app now uses the Android embedding v2 (declared in AndroidManifest.xml), and the MainActivity extends FlutterActivity from the v2 embedding library. Additionally, the AndroidManifest.xml includes the required \<queries\> block for text processing support.

_dev/integration\tests/ui/android · high confidence

Added documentation and ignore configuration for Dartdoc snippets; Added empty Gradle cache property files.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 41 → 43 (+2.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 40 → 40 (+0.9)
• Architecture 99 → 96 (-3.6)
• Maturity 71 → 72 (+1.3)
• Readiness 33 → 38 (+4.4)
• Security 56 → 67 (+11.3)
• Domain Modelling 100 → 100 (+0.0)
• Accessibility 36 → 36 (+0.0)

• Boundary-crossing change coupling: build.dart ↔ native_assets.dart (dev/integration_tests/link_hook/hook/build.dart)
• Boundary-crossing change coupling: build.dart ↔ update_packages_pins.dart (dev/integration_tests/link_hook/hook/build.dart)
• Boundary-crossing change coupling: widget_previews.dart ↔ preview_code_generator.dart (packages/flutter/lib/src/widget_previews/widget_previews.dart)
• Change coupling: FlutterPluginConstants.kt ↔ FlutterPluginUtils.kt (packages/flutter_tools/gradle/src/main/kotlin/FlutterPluginConstants.kt)
• Change coupling: android_device.dart ↔ desktop_device.dart (packages/flutter_tools/lib/src/android/android_device.dart)
• Change coupling: build.dart ↔ copy_artifacts_step.dart (engine/src/flutter/lib/web_ui/dev/build.dart)
• Change coupling: locale_initialization.dart ↔ semantics.dart (engine/src/flutter/testing/ios_scenario_app/lib/src/locale_initialization.dart)
• Change coupling: main.dart ↔ locale_initialization.dart (engine/src/flutter/shell/platform/embedder/fixtures/main.dart)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (dev/a11y_assessments/android/buildscript-gradle.lockfile)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• FileTooLong: bots/check_examples_cross_imports.dart (dev/bots/check_examples_cross_imports.dart)
• FileTooLong: canvaskit/painting.dart (engine/src/flutter/lib/web_ui/lib/src/engine/canvaskit/painting.dart)
• FileTooLong: commands/custom_devices.dart (packages/flutter_tools/lib/src/commands/custom_devices.dart)
• FileTooLong: localizations/gen_l10n_types.dart (packages/flutter_tools/lib/src/localizations/gen_l10n_types.dart)
• High CVE: [GHSA redacted] (dev/a11y_assessments/android/buildscript-gradle.lockfile)
• High CVE: [GHSA redacted] (dev/a11y_assessments/android/buildscript-gradle.lockfile)
• High: security finding (details withheld)
• Medium CVE: [GHSA redacted] (dev/a11y_assessments/android/buildscript-gradle.lockfile)
• Medium CVE: [GHSA redacted] (dev/a11y_assessments/android/buildscript-gradle.lockfile)
• …and 37 more

• $skwasm_support_setup (cognitive 22) (engine/src/flutter/skwasm/library_skwasm_support.js)
• 1.call (cognitive 28) (engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/loader/FlutterLoader.java)
• 1.create (cognitive 17) (engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/systemchannels/PlatformViewsChannel.java)
• 1.onMethodCall (cognitive 17) (engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/systemchannels/TextInputChannel.java)
• 1.onMethodCall (cognitive 25) (engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/systemchannels/PlatformChannel.java)
• 1.onMethodCall (cyclomatic 20) (engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/systemchannels/TextInputChannel.java)
• 1.onMethodCall (cyclomatic 28) (engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/systemchannels/PlatformChannel.java)
• AOTSnapshotter.build (cognitive 45) (packages/flutter_tools/lib/src/base/build.dart)
• AOTSnapshotter.build (cyclomatic 28) (packages/flutter_tools/lib/src/base/build.dart)
• AccessibilityBridge.createAccessibilityNodeInfo (cognitive 36) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.createAccessibilityNodeInfo (cyclomatic 22) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.performAction (cognitive 33) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.performAction (cyclomatic 38) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.performCursorMoveAction (cognitive 17) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.performCursorMoveAction (cyclomatic 17) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.predictCursorMovement (cognitive 39) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.predictCursorMovement (cyclomatic 26) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.updateSemantics (cognitive 112) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityBridge.updateSemantics (cyclomatic 54) (engine/src/flutter/shell/platform/android/io/flutter/view/AccessibilityBridge.java)
• AccessibilityInspector._getSemanticsTree (cognitive 16) (packages/flutter/lib/src/widgets/accessibility_inspector.dart)
• …and 4220 more

• 300 commits — 261 feature/other, 39 fixes

• (root) — 110 commits
• packages/flutter_tools — 63 commits
• engine/src — 60 commits
• packages/flutter — 30 commits
• dev/integration_tests — 8 commits
• bin/internal — 7 commits
• dev/devicelab — 4 commits
• (repo) — 2 commits
• .github/workflows — 2 commits
• dev/bots — 2 commits
• dev/flutter_analyzer_plugin — 2 commits
• docs/contributing — 2 commits
• docs/ecosystem — 2 commits
• .github/ISSUE_TEMPLATE — 1 commit
• dev/tools — 1 commit
• docs/rules — 1 commit
• docs/triage — 1 commit
• examples/hello_world — 1 commit
• packages/flutter_localizations — 1 commit

• fix: Deprecate decoupled localizations, add dart fixes (#192954)
• fix: Fix DeleteSurrounding splitting UTF-16 surrogate pairs (#190514)
• fix: Fix FFI links for Linux in README.md (#192981)
• fix: Fix TabBarView/PageView edge auto-scroll during mouse text selection (#189544)
• fix: Fix Wasm build cache mismatch in ResidentWebRunner and browser 404 fallbacks (#190786)
• fix: Fix black tooltips and popups on Wayland (#192910)
• fix: Fix incorrect UberSDF pixelsize used for stroked shapes (#192659)
• fix: Fix issue where shapes rendered with gradient+blur+rotation end up incorrectly cut off (#192136)
• fix: Fix nested scroll view fling crash (#191130)
• fix: Fix parsing of --enable-hcpp-and-surface-control switch and add --no-enable-hcpp tests (#192202)
• fix: Fix sibling nodes crash under MergeSemantics (#191587)
• fix: Fix specify_nonobvious_local_variable_types lints in luci_resultdb_test.dart (#192543)
• fix: Fix square corner issue (#191096)
• fix: Fix unawaited async calls in fragment_shader_test and skip Vulkan in canvas_test (#193030)
• fix: Fixes OverlayPortal semantics bounds corruption (#192139)
• fix: Handle linear and radial gradients in UberSDF (re-implement after fix) (#192124)
• fix: Revert: Fix square corner issue (#193189)
• fix: Revert: [devicelab] Clean up Chrome profile directories and trap abort signals in web benchmarks (#192615)
• fix: Revert: fix(widgets): dismiss open RawTooltip on Escape key (WCAG 1.4.13) (#193183)
• fix: [Android] Fix the HCPP SurfaceControl transaction-list race and split the transaction entry points (#192606)
• …and 280 more

• Containers 0 added · 0 removed · contexts 2 added · 1 removed · edges 1 added · 0 removed

• app
• gradle

• .

• app → android

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

flutter/flutter was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.