Skip to content
CAI
Software that uses CAICheck a score

flutter/devtools

63.2

Adequate · 17 November 2026

339.3k

lines of production code

JavaScript

with Dart

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add CPU profiler method table with call graph visualization

The CPU profiler pane now includes a method table that displays methods and their timing information (self time and total time) in a sortable, searchable list. Selecting a method reveals a call graph view showing its callers and callees, allowing users to trace execution paths and understand performance impact within the profile data.

_packages/devtools\_app/lib/src/screens/profiler/panes/method\table · high confidence

Add DevTools web benchmark test infrastructure

The benchmark test infrastructure now supports running DevTools web benchmarks for both JavaScript (dart2js) and WebAssembly (Wasm) compilation targets. New entry points in \client/client\_js.dart\ and \client/client\_wasm.dart\ allow the benchmark server to build and automate the DevTools web app to record performance data, while \common.dart\ defines the benchmark types (such as navigating offline screens and profiling) and the \DevToolsRecorder\ in \devtools\_recorder.dart\ handles the actual measurement of frame building durations.

_packages/devtools\_app/benchmark/test\infra · high confidence

Add Process Memory view to VM Tools

A new Process Memory view has been added to the VM Tools section, allowing developers to inspect the target application's total resident set size (RSS) and break down memory usage by isolate groups, system services, and tooling overhead. The view presents this data through two tabs: a sortable tree table and an interactive treemap, with controls to refresh statistics and expand or collapse the memory hierarchy.

_packages/devtools\_app/lib/src/screens/vm\_developer/process\memory · high confidence

Add Queued Microtasks tab to VM Tools screen

A new Queued Microtasks tab has been added to the VM Developer Tools screen, allowing users to inspect the microtask queue of the selected isolate. The feature includes a controller to fetch and track the status of microtask snapshots, a table view to list queued microtasks by their dequeue order, and a detailed view showing the stack trace captured when a specific microtask was enqueued. Users can refresh the snapshot to get the latest state and select individual microtasks to view their associated stack traces.

_packages/devtools\_app/lib/src/screens/vm\_developer/queued\microtasks · high confidence

Add UI component examples to devtools\_app\_shared

The devtools\_app\_shared package now includes an example directory containing demonstration widgets for its shared UI components. These examples illustrate how to use the RoundedOutlinedBorder, AreaPaneHeader, DevToolsDialog, and SplitPane widgets within a Material UI context, providing developers with ready-to-use patterns for integrating these shared elements into their applications.

_packages/devtools\_app\shared/example/ui · high confidence

Add conditional URL utilities for web and VS Code integration

The \devtools\_app\_shared\ package now includes a new \url\ utility module that provides platform-specific implementations for web URL handling. Using conditional imports based on \dart.library.js\_interop\, the module exposes stub implementations for non-web platforms and web-specific logic (using \package:web\) for browser environments, including functions to load query parameters, get the current URL, perform redirects, reload pages, and update query parameters. It also introduces a \launchUrl\ function that attempts to launch URLs via the standard \url\_launcher\ package but always sends a \postMessage\ to the parent VS Code window to ensure embedded views can handle link clicks correctly.

_packages/devtools\_app\shared/lib/src/utils/url · high confidence

Add example DevTools extension for package:foo

An example DevTools extension for \package:foo\ is now included, providing a reference implementation for extension authors. This Flutter web app demonstrates key capabilities, including calling service extensions and evaluating expressions via the VM Service protocol, interacting with the Dart Tooling Daemon (DTD) to read/write files and fetch workspace roots, listening for DevTools events, and using extension APIs such as \copyToClipboard\, \showNotification\, and \showBannerMessage\. The example also migrates its UI to use \package:material\_ui\ and includes VS Code launch configurations for running the extension in simulated environments.

_packages/devtools\_extensions/example/packages\_with\_extensions/foo/packages/foo\_devtools\extension · high confidence

Add example code for using the DevTools service manager

An example file has been added to the \devtools\_app\_shared\ package demonstrating how to use the \ServiceManager\ to connect to a VM service, listen for connection state changes, and interact with service extensions and isolates.

_packages/devtools\_app\shared/example · high confidence

Add macOS native runner configuration for DevTools

The macOS application bundle is now fully configured with native files including the AppDelegate, MainFlutterWindow, MainMenu.xib, and Info.plist. This setup enables the DevTools app to run as a standalone macOS application, featuring standard menu structures, app icon assets, and build configurations for both Debug and Release modes.

_packages/devtools\app/macos/Runner · high confidence

Add macOS platform support for DevTools

The DevTools application now includes the necessary macOS project files to build and run as a native macOS app. This change adds the Flutter configuration files (Debug and Release xcconfigs), the generated plugin registrant (registering file\_selector\_macos and url\_launcher\_macos), and the Xcode workspace structure, enabling users to launch and use DevTools directly on macOS.

_packages/devtools\app/macos/Flutter · high confidence

Add platform-specific notification support for web and desktop

The notifications module now uses conditional imports to provide native notification capabilities on web platforms while maintaining a stub for desktop. On web, the \Notification\ class wraps the \package:web\ API to handle title, body, permission requests, and closing notifications. On desktop, the class remains a stub that throws an exception, indicating that notifications are not yet supported in that environment.

_packages/devtools\_app/lib/src/shared/config\specific/notifications · high confidence

Add retaining path visualization for class details in memory diff view

The memory diff screen now includes a dedicated class details pane that displays retaining paths for selected classes. This feature introduces a split-view interface: on the left, a sortable table lists retaining paths with columns for the shortest path, instance count, shallow size, and retained size (showing deltas in diff mode); on the right, a detailed view renders the full path with controls to copy the path text, hide standard libraries, and invert the path direction. This allows users to deeply analyze memory retention relationships directly within the diff context.

_packages/devtools\_app/lib/src/screens/memory/panes/diff/widgets/class\details · high confidence

Add widget\_icons package for Flutter widget iconography and theming

A new \widget\_icons\ package has been added to the third-party directory, providing a set of icons representing Flutter widgets and a \WidgetTheme\ utility for categorizing them. The package exports a \WidgetIcons\ class with static \IconData\ constants for various widgets (such as \alert\_dialog\, \list\_view\, \checkbox\, and \scaffold\) and a \WidgetTheme\ class that maps widget type names to specific icons and colors (e.g., green for content widgets, orange for animations). An example app demonstrates how to use these icons in a \MaterialApp\, and unit tests verify the theme mapping logic, including handling of generic type names like \AnimatedBuilder\<String\>\.

_third\_party/packages/widget\icons · high confidence

Added Xcode scheme for building and running the macOS DevTools app

A new Xcode scheme (Runner.xcscheme) has been added to the macOS project configuration. This enables developers to build, run, test, profile, and archive the DevTools application directly within Xcode. The scheme includes a pre-action script to prepare the Flutter framework and is configured to launch the app with LLDB debugging enabled.

_packages/devtools\app/macos/Runner.xcodeproj/xcshareddata · high confidence

Added example code for devtools\_app\_shared utilities

The \packages/devtools\_app\_shared/example/utils\ directory now contains example files demonstrating how to use shared utilities from \package:devtools\_app\_shared/utils.dart\. These examples cover the \AutoDisposeMixin\ and \AutoDisposeControllerMixin\ for managing widget and controller lifecycles, global state management via \setGlobal\ and \globals\, the \ListValueNotifier\ for notifying listeners on list modifications, helper functions like \pluralize\ and \equalsWithinEpsilon\, and the \ImmediateValueNotifier\ for triggering listeners on initialization.

_packages/devtools\_app\shared/example/utils · high confidence

Automated validation and lifecycle hooks for AI agent skills

The \.agents\ directory now includes a validation framework to ensure AI agent skills meet quality and consistency standards. A new \hooks.json\ configuration registers shell scripts that automatically trigger after file modifications: \validate\_skills\_hook.sh\ runs the \skills\_lint\ tool whenever a \SKILL.md\ file is edited, while \skill\_post\_invocation\_hook.sh\ injects ephemeral review prompts for modified skills. The \README.md\ in \.agents/skills/\ documents how to run this linter locally via \dart run dart\_skills\_lint:cli\ or through Dart tests, and a \skills\_lint\_ignore.json\ file allows specific rules to be bypassed for certain skills.

.agents · high confidence

Embedded DevTools extensions now render in web iframes with sandboxing and theme support

DevTools extensions embedded within the DevTools UI are now rendered using HTML iframes on web platforms, replacing previous stub implementations. This change introduces platform-specific controllers that manage iframe lifecycle, including a sandboxed environment with specific permissions (scripts, same-origin, forms, downloads, popups) for security. The implementation supports dynamic theme switching (dark/light) passed to the extension via query parameters and handles communication between the DevTools host and the extension via postMessage. On desktop platforms, the view displays a placeholder message indicating that iframe support is not available. The view also checks for required service connections before rendering, showing a specific error state if the extension requires a connected application but none is present.

_packages/devtools\app/lib/src/extensions/embedded · high confidence

Initial macOS project configuration for DevTools

The macOS build configuration (project.pbxproj) has been added, establishing the native Xcode project structure required to build and run the DevTools application on macOS. This includes the necessary build phases, file references for the Flutter engine integration, and target definitions for both the main application and its test suite.

_packages/devtools\app/macos/Runner.xcodeproj · high confidence

Initial release of the devtools\_shared package

This change introduces the \devtools\_shared\ package, consolidating shared Dart code previously scattered across \devtools\_app\, \dds\, and other locations. It provides core structures for JSON file formats (such as HeapSample and ADB memory info), a shared DevTools server implementation, and utilities for managing DevTools extensions, deep links, and integration testing. This centralization simplifies dependency management and ensures consistent behavior across the DevTools ecosystem.

_packages/devtools\shared · high confidence

Introduce App Size analysis and diff screens

Adds a new App Size screen to DevTools that allows users to analyze application size breakdowns and compare differences between builds. The feature includes an Analysis tab with a treemap and tree table for visualizing code size attribution, and a Diff tab for comparing two size analysis files. It also provides a Call Graph and Dominator Tree view to help identify memory and size contributors, with support for deferred loading indicators and dropdown filters for viewing specific app segments.

_packages/devtools\_app/lib/src/screens/app\size · high confidence

Adds a new Deep Link Validation screen to DevTools that helps developers diagnose issues with Android App Links and iOS Universal Links. The tool connects to the Deep Link Assistant API to validate domain configurations (such as Digital Asset Links and Apple-App-Site-Association files) and path checks, presenting results in a split-screen view with detailed error explanations and fix suggestions.

_packages/devtools\_app/lib/src/screens/deep\_link\validation · high confidence

Introduce DevTools extension CLI commands and validation

The \package:devtools\_extensions\ package now ships with a CLI tool (\dart run devtools\_extensions\) that includes a \build\_and\_copy\ command to build a Flutter web extension and copy the output to the parent package's \extension/devtools\ directory, and a \validate\ command to check that an extension's \pubspec.yaml\ and \config.yaml\ meet the requirements for loading in DevTools. This is accompanied by a comprehensive example app (\app\_that\_uses\_foo\) demonstrating how to structure both companion and standalone extensions, including VS Code launch configurations and integration tests.

_packages/devtools\extensions · high confidence

Introduce DevTools extension management and embedded screen views

Adds the core UI and service logic for managing DevTools extensions within the app. Users can now enable or disable extensions via a new settings dialog, view a list of available extensions, and see their enabled state. The extension screen itself now supports embedded views (for IDE tool windows) with a header showing the package name and version, a 'Force reload' action, and a prompt to enable the extension if it is not yet active. The extension service handles detecting runtime and static extensions, deduplicating them by package name, and refreshing the list when the connected app or main isolate changes.

_packages/devtools\app/lib/src/extensions · high confidence

Introduce Enhance Tracing controls for detailed timeline profiling

Adds a new 'Enhance Tracing' button to the Performance pane that allows users to toggle additional profiling options—specifically widget builds, render object layouts, and render object paints—to add more detail to the Timeline trace. This feature includes a dedicated UI component for selecting the scope of widget build tracing (all code vs. user-created code) and a controller that manages the state of these service extensions, ensuring that frame data in the timeline reflects the current tracing configuration.

_packages/devtools\_app/lib/src/screens/performance/panes/controls/enhance\tracing · high confidence

Introduce IDE-shared Property Editor with refactor support and filtering

The Property Editor now uses a new shared implementation located in the \ide\_shared\ directory, providing a consistent experience across IDEs. This update adds the ability to trigger 'Wrap with' refactors directly from the editor, allows users to filter properties by name or value, and includes a dedicated footer with documentation links and a feedback button. The UI has been migrated to use \material\_ui\ for styling, and the controller now debounces requests to the Analysis Server to improve performance.

_packages/devtools\_app/lib/src/standalone\_ui/ide\_shared/property\editor · high confidence

Introduce Memory Diff pane for comparing heap snapshots

Adds a new Diff pane to the Memory screen, allowing users to compare two heap snapshots to identify allocation changes. The pane features a split view with a snapshot list on the left and a detailed view on the right, which displays either snapshot instance details or embedded documentation. The documentation provides step-by-step instructions on taking snapshots, importing them, and using the diff feature to detect memory issues, including links to external resources and class type legends.

_packages/devtools\app/lib/src/screens/memory/panes/diff · high confidence

Introduce VM Statistics view for Dart VM and process metrics

A new VM Statistics screen has been added to the VM Developer tools, providing a consolidated view of the Dart VM and host process state. Users can now see general VM details (name, version, embedder, start time, profiler mode, and current memory) alongside process-level statistics (PID, host/target CPU, operating system, and RSS/zone memory utilization). The view also includes previews of user and system isolates, with a refresh button to update the data on demand.

_packages/devtools\_app/lib/src/screens/vm\_developer/vm\statistics · high confidence

Introduce \`package:devtools\_test\` for shared test utilities and mocks

A new \package:devtools\_test\ has been created to centralize test infrastructure for Dart DevTools. This package provides shared test helpers for navigation, widget finding, and UI actions, along with a suite of fake implementations for core services such as \IsolateManager\, \ServiceManager\, and \VmServiceWrapper\. It also includes utilities for integration testing, allowing developers to write consistent and reusable tests for DevTools screens and features.

_packages/devtools\test · high confidence

Introduce allocation tracing for specific classes in the Memory screen

The Memory screen now includes a new Tracing tab that allows you to enable or disable allocation tracing for specific Dart classes. You can filter the class list, select classes to trace, and then view the collected allocation samples as a tree of stack frames (both Bottom-Up and Call Tree views) to identify where instances of those classes are being allocated. This feature is available in both standard and profile build modes and supports saving and loading the tracing state.

_packages/devtools\app/lib/src/screens/memory/panes/tracing · high confidence

Introduce box layout visualizer in the inspector

The inspector's layout explorer now includes a dedicated visualizer for box model properties. This new component renders a graphical representation of a widget's padding, size, and constraints, allowing users to inspect the spatial layout of selected elements directly within the DevTools interface.

_packages/devtools\_app/lib/src/screens/inspector/layout\explorer/box · high confidence

Introduce custom DevTools charting subsystem

The shared charts package now uses a new, custom charting implementation for plotting timeseries data, replacing previous external dependencies. This subsystem supports line charts for non-numeric events and scatter charts with optional shading, managed via a \ChartController\ that handles trace creation, data addition, and axis scaling. The package also includes a new \FlameChart\ widget for visualizing hierarchical performance data and a \Treemap\ widget for displaying hierarchical byte-size data, both integrated with the shared UI utilities.

_packages/devtools\app/lib/src/shared/charts · high confidence

Introduce dedicated Flutter Frames pane with jank detection and Impeller support

The Performance screen now includes a dedicated Flutter Frames pane that visualizes individual frame timing data (build, raster, and vsync overhead) and detects jank based on the device's display refresh rate. This change introduces a new data model and controller to manage frame recording, linking UI and raster timeline events to specific frames, and highlights shader jank with banner messages. The chart also exposes whether the app is using Impeller or Skia, allowing users to correlate rendering backend performance with frame smoothness.

_packages/devtools\_app/lib/src/screens/performance/panes/flutter\frames · high confidence

Introduce dedicated Frame Analysis pane with jank hints and phase visualizer

A new Frame Analysis pane has been added to the Performance view, providing a dedicated interface for inspecting individual Flutter frames. This pane displays a visual breakdown of frame timing across UI phases (Build, Layout, Paint) and Raster phases (including Shader compilation), allowing users to quickly identify performance bottlenecks. It also presents actionable jank detection hints, such as warnings for excessive SaveLayer operations or intrinsic layout calculations, and integrates with the Rebuild Table to show widget rebuild counts when the corresponding service extension is enabled.

_packages/devtools\_app/lib/src/screens/performance/panes/frame\analysis · high confidence

Introduce dedicated Memory Profile pane with class pinning and instance sampling

A new Profile pane has been added to the Memory screen, providing a dedicated view for allocation profiles. This pane allows users to pin specific classes to the top of the table for easier tracking and offers context menu actions to store individual or all class instances as console variables for further inspection. The implementation includes a new data model for adapting and filtering profile records, a controller managing the profile state and GC refresh behavior, and UI components built with the Material UI library.

_packages/devtools\app/lib/src/screens/memory/panes/profile · high confidence

Introduce devtools\_app\_shared package with shared service and UI exports

The \devtools\_app\_shared\ library now exposes a consolidated set of shared resources for DevTools consumers. This includes service-layer utilities such as the DTD manager, service extension manager, and isolate management, alongside UI components like the SplitPane, FlexSplitColumn, and theme definitions. Additionally, it introduces an \EmbedMode\ enum to support multi-tab embedded views, allowing DevTools to adapt its interface (e.g., hiding the top-level tab bar) based on query parameters provided by the embedding IDE.

_packages/devtools\_app\shared/lib · high confidence

Introduce new CPU profiler pane views and table columns

The CPU profiler pane now includes dedicated views for the bottom-up call tree, the top-down call tree, and the flame chart, along with the specific table columns required to display them. Users can now inspect CPU profiles through these new visualizations, which render method names, source locations, and time metrics (self time and total time) with appropriate tooltips and sorting defaults.

_packages/devtools\app/lib/src/screens/profiler/panes · high confidence

Introduce offline mode for DevTools screens

DevTools now supports viewing saved data without an active connection to a Dart/Flutter app. This change adds an \OfflineDataController\ to manage the global offline state and an \OfflineScreenControllerMixin\ that screen controllers can use to load and display previously exported JSON data. An \OfflineScreenBody\ widget renders the appropriate screen view when offline, allowing users to continue exploring their app's state even when disconnected.

_packages/devtools\app/lib/src/shared/offline · high confidence

Introduce shared Console widget and service for DevTools

A new shared console component and its backing service have been added to the DevTools application, enabling consistent console output rendering and management across different screens. The \Console\ widget displays a scrollable list of text and variable lines, while the \ConsoleService\ manages the state of console entries, including appending standard I/O text and browsable Dart object instances. This change provides a unified foundation for console features, such as the ability to browse heap objects and view variable values, within the shared UI library.

_packages/devtools\app/lib/src/shared/console · high confidence

Introduce shared code folder with feature flags and development helpers

A new \shared\ folder has been created to house code common across DevTools screens, starting with a README defining its scope, constants for logging and UI icons, and a feature flag system that gates experimental features like DevTools extensions and accessibility. The update also adds development helpers for debugging extensions without a server connection, a log storage utility, and logic to dynamically generate the app title based on the connected app type.

_packages/devtools\app/lib/src/shared · high confidence

Introduce shared console UI components

Added a new set of widgets in the shared console package to standardize the debugging console experience. This includes the ConsolePane for displaying stdout/stderr and managing the expression evaluation footer, the ExpressionEvalField with integrated autocomplete for code completion, and a suite of display widgets (DisplayProvider, DiagnosticsNodeDescription, ExpandableVariable) for rendering variable values and diagnostic nodes consistently across the debugger and inspector.

_packages/devtools\app/lib/src/shared/console/widgets · high confidence

Introduce standalone diagnostics primitives for object references, source locations, and record fields

The \diagnostics/primitives\ folder now contains independent utility libraries that do not depend on other libraries in the \diagnostics\ package. This includes \InspectorInstanceRef\ for stable, non-expiring references to Dart objects, \InspectorSourceLocation\ and \SourcePosition\ for parsing and calculating source file locations, and \RecordFields\ for separating and sorting positional and named fields from Dart records. These primitives provide foundational data structures for the DevTools diagnostics system.

_packages/devtools\app/lib/src/shared/diagnostics/primitives · high confidence

Memory pressure monitoring and automatic memory reduction for DevTools

DevTools now monitors its own memory usage and warns users when it approaches a 3GB limit, offering a "Reduce memory" action to clear stale data from unused screens and partially from the current screen to prevent out-of-memory crashes. This feature includes platform-specific memory measurement implementations (using the browser's \measureUserAgentSpecificMemory\ API for web and a null placeholder for desktop) and a new \DisconnectObserver\ widget that manages connection state changes, displaying a disconnected overlay with options to reconnect or review offline data history.

_packages/devtools\app/lib/src/framework/observer · high confidence

Network screen now supports exporting and importing traffic as HAR files

The Network screen now allows users to export captured HTTP, Socket, and WebSocket traffic to the standard HTTP Archive (HAR) format and import previously saved HAR files for offline analysis. This change introduces new files in the network screen directory to handle HAR serialization and deserialization, including \har\_builder.dart\ and \har\_data\_entry.dart\ for constructing HAR objects from internal request data, and \har\_network\_data.dart\ for managing the HAR structure. The \NetworkController\ now exposes an \exportAsHarFile\ method that triggers a download of the current filtered network data, while the \NetworkScreen\ body includes a file import container to load saved HAR data back into the profiler, enabling users to share or review network traces outside of an active DevTools session.

_packages/devtools\app/lib/src/screens/network · high confidence

New Accessibility screen with semantics tree and override controls

The DevTools app now includes a dedicated Accessibility screen that lets you inspect the semantics tree of the connected app and apply real-time accessibility overrides. The screen is split into three panes: a Semantics Tree view to browse and select nodes, a Semantics Node Details pane showing label, value, hint, bounding box, and flags for the selected node, and an Accessibility Overrides pane to adjust brightness (system/light/dark), text scale (0.5x–3.0x), bold text, screen reader debugger, and high contrast. The controller automatically loads the semantics tree when an isolate connects and refreshes it on isolate changes, with manual refresh and retry-on-error support.

_packages/devtools\app/lib/src/screens/accessibility · high confidence

New DTD Tools screen for inspecting Dart Tooling Daemon instances

A new DTD Tools screen has been added to DevTools, accessible via the Advanced Developer Mode setting. This screen allows users to connect to a Dart Tooling Daemon (DTD) instance—either the one DevTools is using or a manually specified URI—and inspect its registered service methods and event streams. The UI provides a split view with a list of services that can be manually invoked and a live log of DTD events, with the controller managing a local DTD connection separate from the global one to avoid affecting other screens.

_packages/devtools\app/lib/src/screens/profiler · high confidence

New DartDocConverter utility for formatting property documentation

A new \DartDocConverter\ utility class has been added to the property editor's utils module. This component parses raw Dart documentation strings and converts them into styled Flutter widgets, specifically handling the removal of template indicators and applying distinct font styles to code snippets (marked with backticks or brackets) versus regular text, thereby improving the readability of property documentation in the UI.

_packages/devtools\_app/lib/src/standalone\_ui/ide\_shared/property\editor/utils · high confidence

New DevTools sidebar UI for VS Code integration

A new sidebar interface has been added to the VS Code DevTools integration, providing a dedicated panel for navigating DevTools screens and extensions. This UI, built with the \material\_ui\ package, displays a list of available DevTools screens (excluding home, debugger, VM tools, provider, and simple screens) and detected extensions. It handles responsive layout by switching between single and double-column views based on width, and correctly manages debug session requirements by disabling tools that require an active session when none are present. The implementation includes a controller to manage extension discovery and lifecycle, ensuring extensions are detected for both the workspace and individual debug sessions.

_packages/devtools\_app/lib/src/standalone\_ui/vs\code/devtools · high confidence

New Flex layout visualization in the Inspector

The Inspector now includes a dedicated Flex layout explorer, allowing users to visualize and interact with the layout properties of Flex widgets (such as Row and Column). This new feature, implemented in the \flex\ directory of the inspector screens, provides a detailed view of alignment, direction, and spacing, enabling developers to better understand and debug flex-based layouts.

_packages/devtools\_app/lib/src/screens/inspector/layout\explorer/flex · high confidence

New Isolate Statistics screen in VM Developer Tools

A new Isolate Statistics view has been added to the VM Developer Tools, providing a consolidated dashboard for monitoring the state of the currently selected isolate. This screen displays general information such as the isolate name, start time, uptime, root library, and ID. It also presents detailed memory statistics, including Dart heap size and capacity, as well as New and Old space usage. Additionally, it shows tag statistics derived from the CPU profiler and lists active service ports, allowing developers to quickly assess isolate health and resource usage.

_packages/devtools\_app/lib/src/screens/vm\_developer/isolate\statistics · high confidence

New Memory Diff tab for comparing heap snapshots

A new Memory \> Diff tab has been added to DevTools, allowing users to load two heap snapshots and view a side-by-side comparison of class-level changes. The diff view presents a table showing the number of instances and memory size for classes that were created, deleted, persisted, or changed (delta) between the two snapshots. Users can filter classes, export the diff data to CSV, and drill down into retaining paths for specific classes. The implementation includes new data models for calculating object set differences, a caching store for diff results, and UI widgets for the comparison table and snapshot management controls.

_packages/devtools\app/lib/src/screens/memory/panes/diff/widgets · high confidence

New VS Code sidebar panel with device and debug session management

The VS Code sidebar now features a dedicated Flutter panel that displays active debug sessions and connected devices. Users can select devices directly from the sidebar, enable unsupported platform types for the current project, and perform Hot Reload or Hot Restart actions on debug sessions. The panel also includes a scrollable interface for DevTools options and integrates analytics for user interactions.

_packages/devtools\_app/lib/src/standalone\_ui/vs\code · high confidence

New benchmarking scripts for running, comparing, and exporting DevTools performance data

Added a suite of Dart scripts in \packages/devtools\_app/benchmark/scripts\ to streamline performance testing. Users can now run benchmarks with \run\_benchmarks.dart\, supporting options to average multiple runs (\--average-of\), save results to JSON (\--save-to-file\), and compare against a baseline (\--baseline\). A dedicated script, \dart2wasm\_performance\_diff.dart\, automates the comparison of dart2wasm versus dart2js performance, outputting a CSV file for easy analysis in spreadsheets. The \compare\_benchmarks.dart\ script allows for standalone comparison of two benchmark result files.

_packages/devtools\app/benchmark/scripts · high confidence

New class filtering and legend widgets for the memory screen

The memory profiling UI now includes a dedicated class filter dialog and a class type legend. Users can filter heap classes by package or name using the new \ClassFilterButton\ and \ClassFilterDialog\, which support 'Show all', 'Show all except', and 'Show only' modes, with analytics tracking for filter actions. Additionally, a \ClassTypeLegend\ widget has been added to explain the color coding for different class types on the memory screen, improving usability when interpreting memory data.

_packages/devtools\app/lib/src/screens/memory/shared/widgets · high confidence

New class filtering and live instance sampling for memory heap view

The Memory \> Heap screen now supports filtering classes by type (show all, except, or only) with a default filter that excludes runtime and SDK classes, and allows users to drop live instances of selected classes directly into the console for inspection. This change introduces a shared \ClassFilter\ component for consistent filtering across diff and profile tabs, and adds \LiveClassSampler\ and \SnapshotClassSampler\ classes to fetch and display live object instances from the running isolate, enabling interactive evaluation of heap objects.

_packages/devtools\app/lib/src/screens/memory/shared/heap · high confidence

New memory screen controls and settings dialog

The memory screen now includes a dedicated control pane with primary and secondary controls. Users can toggle the visibility of the memory chart via a new button, trigger garbage collection (when not in offline mode), and save/load memory data (when the feature flag is enabled). A new settings dialog allows users to show the Android memory chart alongside the Dart chart and adjust the reference limit for exploring live references in the console.

_packages/devtools\app/lib/src/screens/memory/panes/control · high confidence

New performance controls UI and settings dialog

The performance pane now features a dedicated controls bar with primary actions (toggle Flutter frames chart, clear data) and secondary options (performance overlay, enhance tracing, more debugging options, open/save, and settings). A new 'More debugging options' button exposes checkboxes for rendering layer toggles (disable clip/opacity/physical shape layers, count widget builds) with a warning that they are unavailable in profile mode. The 'Performance Settings' dialog, accessible only for Flutter apps, allows users to toggle a badge on the Performance tab when Flutter UI jank is detected. These controls are built using the new material\_ui library and respect offline mode constraints.

_packages/devtools\app/lib/src/screens/performance/panes/controls · high confidence

The Network tab now includes a new shared HTTP library (\packages/devtools\_app/lib/src/shared/http\) that provides platform-independent utilities for parsing HTTP cookies and generating cURL commands. This addition enables the DevTools UI to correctly parse \Set-Cookie\ headers (including attributes like \expires\, \domain\, \path\, \httponly\, and \secure\) and to generate accurate cURL command strings from request data, including proper escaping and header/body inclusion. The library also introduces \DartIOHttpRequestData\ to abstract HTTP request data from the VM service and \http\_service.dart\ to manage HTTP timeline logging toggles across isolates.

_packages/devtools\app/lib/src/shared/http · high confidence

New shared console primitive libraries for variable assignment, history, and scope

The console subsystem now includes a new \primitives\ folder containing independent libraries that support core console functionality. \ConsoleVariableAssignment\ parses expressions like \var x=$2\ to bind console output to named variables. \EvalHistory\ manages the expression evaluation history, allowing users to navigate up and down through previous commands. \EvalScope\ tracks variable references for specific isolates, handling refreshes and removals to keep the evaluation context accurate. Additionally, \simple\_items.dart\ introduces a \FlutterTreeType\ enum to identify widget trees.

_packages/devtools\app/lib/src/shared/console/primitives · high confidence

New shared primitives library for independent utilities

A new \shared/primitives\ folder has been introduced to house independent libraries that do not depend on other libraries within \devtools\_app\. This location now contains core utility classes and mixins, including \AnsiParser\ for parsing ANSI color escape codes, \BlockingActionMixin\ for managing long-running action states, \ByteUtils\ for formatting and converting byte sizes, \CollapsibleAnimationMixin\ for tree node animations, \CustomPointerScrollView\ for handling pointer signals in scroll views, \DiagnosticsTextStyles\ for diagnostic text styling, \EncodeDecode\ implementations for serializing types like \HeapSnapshotGraph\ and \ByteData\, \ExtentDelegateListView\ for efficient list rendering with variable item extents, \Graph\ and \GraphNode\ for graph data structures, \HistoryManager\ for managing historical state stacks, \ListQueueValueNotifier\ for observable list queues, \FixedValueListenable\ for static value listening, and \MessageBus\ for event-based communication.

_packages/devtools\app/lib/src/shared/primitives · high confidence

New shared utility classes and functions for DevTools extensions

The \devtools\_app\_shared\ package now includes a new \utils\ directory containing reusable components for extension development. This adds \AutoDisposeMixin\ and \DisposerMixin\ to automatically manage the lifecycle of listeners, stream subscriptions, and focus nodes, reducing boilerplate in widgets. It introduces \ListValueNotifier\ for managing list state with change notifications, \ImmutableList\ for read-only list views, and \ImmediateValueNotifier\ for listeners that require immediate execution. Additionally, it provides helper utilities for global state management (\globals\), enum comparison (\EnumIndexOrdering\), string operations (pluralization, fuzzy matching, CSS color parsing), and web-specific type checking via \package:web\.

_packages/devtools\_app\shared/lib/src/utils · high confidence

New timeline events pane with CPU sampling and memory safeguards

The Timeline Events pane in the Performance screen now uses a dedicated controller and processor to handle Perfetto trace data, introducing a ring buffer to cap memory usage and prevent out-of-memory errors during long sessions. Users can now opt-in to include CPU samples in the timeline via a new toggle, which provides more detailed profiling data but may negatively impact performance. The UI also displays a refreshing overlay while the timeline is being processed and disables the refresh button during active loads to prevent duplicate requests.

_packages/devtools\_app/lib/src/screens/performance/panes/timeline\events · high confidence

New visual indicators for widget dimensions, constraints, and overflow in the Layout Explorer

The Layout Explorer UI now renders visual overlays on selected widgets to display their actual dimensions, layout constraints, and overflow status. New components in the \layout\_explorer/ui\ package introduce bidirectional arrows for width and height, color-coded indicators for unconstrained or overflowing layouts, and a theming system that applies specific icons and colors to different widget categories (e.g., text, images, animations). This provides immediate visual feedback on how widgets are sized and constrained within the app hierarchy.

_packages/devtools\_app/lib/src/screens/inspector/layout\explorer/ui · high confidence

Object Inspector now supports Class Hierarchy, Object Store, and Inbound References views

The Object Inspector in the VM Developer tools has been expanded with three new inspection modes accessible via a dropdown selector: Class Hierarchy, Object Store, and Inbound References. The Class Hierarchy view displays the inheritance structure of all classes in the selected isolate, allowing users to navigate the tree and select classes for detailed inspection. The Object Store view presents a table of key-value pairs from the isolate's object store, enabling users to inspect internal VM objects. The Inbound References view provides a tree of objects referencing the currently selected object, helping users understand memory retention and reachability. These additions complement the existing Program Explorer, offering deeper visibility into VM internals and object relationships.

_packages/devtools\_app/lib/src/screens/vm\_developer/object\inspector · high confidence

Property Editor available as a standalone screen with automatic DTD reconnection

The Property Editor is now accessible as a standalone screen, allowing it to be embedded directly in an IDE via a specific URL route rather than through DevTools' normal navigation. This change introduces a dedicated connection management flow for standalone screens: the UI now displays a 'NotConnectedOverlay' that shows connection status (waiting, connecting, retrying) and provides a 'Retry' button to automatically reconnect to the Dart Tooling Daemon (DTD) if the connection drops, ensuring a more resilient experience for embedded usage.

_packages/devtools\_app/lib/src/standalone\ui · high confidence

Support connecting to VM service via MessagePort on the web

DevTools on the web can now connect to a VM service through a \MessagePort\ provided by the embedding page or parent window, using the \messageport:\ URI scheme. This enables scenarios where DevTools runs inside an iframe or as a popup, allowing the embedder to forward VM service traffic securely. A stub implementation is provided for non-web platforms to maintain API consistency.

_packages/devtools\app/lib/src/service · high confidence

Support for saving and loading offline memory analysis state

The Memory screen now supports persisting its state for offline use. A new \OfflineMemoryData\ class handles serialization and deserialization of the diff, profile, chart, and trace pane controllers, along with the selected tab index and class filter. This allows users to save their memory analysis session and reload it later without needing an active connection to the target application.

_packages/devtools\_app/lib/src/screens/memory/framework/offline\data · high confidence

Architecture

Extracted shared memory primitives and UI components

The memory screen's shared code has been reorganized into a new \primitives\ folder, isolating independent libraries that do not depend on other parts of the memory module. This change introduces dedicated components for rendering instance counts with context menus (\InstanceViewWithContextMenu\), managing memory timeline data and events (\MemoryTimeline\), and providing utility functions for heap snapshots and isolate selection. It also includes reusable UI elements for chart painting (dashed/solid lines) and standardized definitions for memory size types (shallow vs. retained), improving code modularity and maintainability for the memory analysis interface.

_packages/devtools\app/lib/src/screens/memory/shared/primitives · high confidence

Framework code reorganized into dedicated folder

The core framework logic has been reorganized into a new \packages/devtools\_app/lib/src/framework\ directory. This change consolidates previously scattered files into a structured layout, introducing \framework\_core.dart\ for initialization and service management, \home\_screen.dart\ for the landing UI, \initializer.dart\ for connection-wrapping logic, \notifications\_view.dart\ for the overlay notification system, \release\_notes.dart\ for the side-panel viewer, and \theme\_manager.dart\ for handling IDE theme synchronization. This restructure improves code maintainability and separation of concerns without altering the user-facing features.

_packages/devtools\app/lib/src/framework · high confidence

Behavioural changes

Added macOS workspace configuration files

The macOS build configuration now includes the Xcode workspace data file (contents.xcworkspacedata) and the IDE workspace checks plist (IDEWorkspaceChecks.plist). These files establish the basic workspace structure required for the macOS platform, ensuring the project is correctly recognized and configured by the IDE.

_packages/devtools\app/macos/Runner.xcodeproj/project.xcworkspace · high confidence

Analytics constants refactored into dedicated part files

The analytics constants in the DevTools app have been reorganized from a single monolithic file into separate, named part files (e.g., \\_cpu\_profiler\_constants.dart\, \\_memory\_constants.dart\, \\_property\_editor\_sidebar\_constants.dart\). This structural change groups event definitions by feature area—such as CPU Profiler, Memory, Deep Links, and Property Editor—making the codebase easier to navigate and maintain without altering the actual analytics tracking behavior.

_packages/devtools\app/lib/src/shared/analytics/constants · high confidence

Centralize core service management logic in devtools\_app\_shared

The service management logic previously scattered across the application has been consolidated into the \devtools\_app\_shared\ package. This change introduces shared components for managing the Dart Tooling Daemon (DTD) connection with automatic reconnection and state tracking, handling connected app properties (such as Flutter version and platform detection), and managing isolate lifecycles and service extensions. By centralizing these capabilities, the DevTools app ensures consistent connection handling, isolate selection, and extension state management across different tooling contexts.

_packages/devtools\_app\shared/lib/src/service · high confidence

Debugger screen refactored into modular components with new breakpoint and stack frame UI

The debugger screen has been restructured into distinct, reusable components: \Breakpoints\ and \CallStack\ now render their respective lists with selection highlighting, while \DebuggingControls\ manages the pause/resume and step buttons. A new \BreakpointManager\ handles the lifecycle of breakpoints, including re-establishing them across isolate switches and hot restarts. The \CodeView\ and its controller have been updated to support script history navigation, file search, and profile information gutters, all wired together by the \DebuggerController\.

_packages/devtools\app/lib/src/screens/debugger · high confidence

The project root selection screen in deep link validation has been updated to verify that a selected project is configured for both Android and iOS. Previously, the logic may have relied on a single platform's configuration; the new implementation in \select\_project\_view.dart\ explicitly requests and checks both \androidVariants\ and \iosBuildOptions\. If a project lacks valid build options for either platform, a more informative dialog is displayed to the user explaining the missing configuration, rather than proceeding with incomplete data. This ensures that deep links are only validated against projects that are fully prepared for deployment on both mobile platforms.

_packages/devtools\_app/lib/src/screens/deep\_link\_validation/project\_root\selection · high confidence

DevTools preferences are now persisted across sessions

The DevTools application now saves user settings to local storage, ensuring that configurations such as dark mode, advanced developer mode, WASM experiment opt-in, and specific screen filters (for CPU profiler, extensions, inspector, logging, memory, network, and performance) are retained between restarts. This change replaces the previous behavior where these settings were lost upon closing the application, allowing users to maintain their preferred debugging environment and UI customizations automatically.

_packages/devtools\app/lib/src/shared/preferences · high confidence

DevTools web app now uses skwasm renderer by default with JS escape hatch

The DevTools web application has been migrated to use the new Flutter bootstrapping methods, which enables the skwasm renderer by default for improved performance. Users can now opt out of WASM and force the legacy CanvasKit renderer via the \compiler=js\ URL query parameter, or revert to WASM using \compiler=wasm\. The new \flutter\_bootstrap.js\ handles this logic by checking URL parameters and user preferences, and also unregisters the old custom DevTools service worker to prevent conflicts with the standard Flutter service worker. Additionally, an unsupported browser check has been added to redirect users to a dedicated error page if their browser does not support ES6 classes.

_packages/devtools\app/web · high confidence

Extracted console evaluation and inspector tree logic into shared libraries

The console evaluation and inspector tree logic has been moved from the debugger and inspector screens into the shared \console/eval\ directory. This refactoring extracts the \EvalService\ (handling expression evaluation, scope management, and auto-completion) and the \InspectorTreeNode\/\InspectorTreeRow\ classes into reusable components. This change centralizes the code for console-based expression evaluation and tree rendering, making it available for other parts of the application such as the memory screen.

_packages/devtools\app/lib/src/shared/console/eval · high confidence

Fallback clipboard copy for embedded DevTools in VS Code

When DevTools runs embedded in VS Code, the standard clipboard API may fail due to a known browser limitation. This change introduces a fallback mechanism: if the primary copy attempt fails, the app now posts a message to the parent frame (VS Code) to handle the clipboard write. Users will see a success notification if this fallback is enabled, ensuring copy operations work reliably within the VS Code environment.

_packages/devtools\_app/lib/src/shared/config\_specific/copy\_to\clipboard · high confidence

IDE-embedded DevTools now respects IDE theme preferences

When DevTools is embedded in an IDE, it now automatically adopts the IDE's color theme (light or dark) and background color instead of relying on the user's local DevTools settings. This is achieved by reading query parameters passed from the IDE (such as \theme\, \backgroundColor\, and \darkMode\) via the new \IdeTheme\ and \IdeThemeQueryParams\ classes. On the web, the background color is applied immediately to the DOM to prevent a white flash before the Flutter frame renders. This ensures the DevTools UI visually blends with the host IDE environment.

_packages/devtools\_app\shared/lib/src/ui/theme · high confidence

Inspector screen restructured into a new controller-based architecture

The Inspector screen has been refactored to use a dedicated \InspectorController\ and \InspectorScreenController\ to manage the widget tree, selection, and error states, replacing the previous monolithic implementation. This change introduces a new \InspectorControls\ component for panel actions (such as toggling implementation widgets and service extensions) and a \FlutterInspectorSettingsDialog\ for configuring package directories and inspection modes. The widget details view now utilizes a \DetailsTable\ with dynamic tabs for widget properties, render object properties, and flex layout exploration, and includes a clickable link to the widget's source file location.

_packages/devtools\app/lib/src/screens/inspector · high confidence

Introduce 'dt' CLI wrapper and standardized Flutter SDK selection

The tooling now provides a unified \dt\ command-line interface (via \tool/bin/dt\ and \dt.dart\) to manage DevTools development and release tasks. A key behavioral change is the introduction of the \--flutter-from-path\ flag (and \DEVTOOLS\_TOOL\_FLUTTER\_FROM\_PATH\ environment variable), which allows the tool to use the Flutter SDK currently on the system PATH instead of the local \tool/flutter-sdk\ directory. This simplifies local development workflows and CI integration by removing the strict dependency on the managed SDK copy when desired.

tool · high confidence

Introduce Editor and LSP API definitions for the Property Editor

The Property Editor now relies on a new set of API classes (\api\_classes.dart\) and a dedicated client (\editor\_client.dart\) to communicate with the Dart Tooling Daemon (DTD). This change introduces explicit enums for Editor methods (such as hot reload/restart) and LSP methods (like \textDocument/codeAction\), along with event types for device and debug session changes. The \EditorClient\ manages the DTD connection, tracks which LSP methods are registered by the Analysis Server, and routes events like \ActiveLocationChanged\ to the Property Editor, enabling features such as showing default values and handling reconnection overlays.

_packages/devtools\app/lib/src/shared/editor · high confidence

Introduce Perfetto trace data models for the timeline pane

The performance timeline pane now includes a new \model.dart\ file that defines the core data structures for parsing and representing Perfetto trace data. This adds a \PerfettoTrace\ change notifier to handle binary trace updates, along with data classes like \PerfettoTrackDescriptorEvent\ and \PerfettoTrackEvent\ to represent trace tracks and events. These models enable the UI to interpret Perfetto-specific details, such as converting nanosecond timestamps to microseconds, extracting debug annotations, and identifying Flutter-specific events like UI frames, raster frames, and shader compilation.

_packages/devtools\_app/lib/src/screens/performance/panes/timeline\events/perfetto/tracing · high confidence

Introduce external DevTools environment parameters

The DevTools app now supports an external (third-party) deployment mode via new \DevToolsEnvironmentParameters\ implementations. In this mode, users are recommended to use VS Code or IntelliJ/Android Studio for debugging, and features specific to the Flutter DevTools standalone experience—such as the GitHub issue tracker link, username display, source map enabling, and the Chrome 115 breakpoint bug warning—are disabled or hidden.

_packages/devtools\_app/lib/src/shared/environment\parameters · high confidence

Introduce platform-specific Perfetto trace viewer implementation

The Performance pane's timeline events now uses a new platform-specific implementation for the embedded Perfetto trace viewer. On web platforms, the viewer is rendered via an HTML iFrame with dedicated controller logic for loading traces, handling theme changes, and managing the iFrame lifecycle. On desktop platforms, the viewer displays a message indicating that iFrames are not supported, effectively disabling the embedded trace viewer for those environments.

_packages/devtools\_app/lib/src/screens/performance/panes/timeline\events/perfetto · high confidence

Introduce shared memory analysis data models and graph algorithms

The memory analysis subsystem now uses a new set of shared data structures and algorithms located in \packages/devtools\_app/lib/src/shared/memory\. This includes \HeapData\ for managing snapshot calculations, \HeapClassName\ for class identification and type classification (runtime, SDK, dependency, project), and \ObjectSet\/\ObjectSetStats\ for tracking instance counts and sizes. A new \findShortestRetainers\ algorithm in \retainers.dart\ computes retained sizes and retaining paths more efficiently, while \HeapGraphLoader\ provides a unified interface for loading heap snapshots from runtime or files. These changes support improved performance and filtering capabilities in the memory profiler.

_packages/devtools\app/lib/src/shared/memory · high confidence

Introduces new shared framework infrastructure for error handling, routing, and screen lifecycle management

This change adds a new set of core files to the shared framework layer to standardize how DevTools handles errors, navigation, and screen state. It introduces \app\_error\_handling.dart\ to centralize error reporting and source-map stack trace resolution for web builds, \routing.dart\ to manage navigation via a new \DevToolsRouterDelegate\ and \DevToolsRouteInformationParser\, and \screen\_controllers.dart\ to provide a \ScreenControllers\ manager that handles the lifecycle, lazy initialization, and memory release of individual screen controllers. Additionally, \framework\_controller.dart\ is added to manage connection state and page change events, while \screen.dart\ defines the \ScreenMetaData\ enum that configures properties like icons, titles, and requirements for each DevTools screen.

_packages/devtools\app/lib/src/shared/framework · high confidence

Logging screen refactored with new UI components and metadata display

The Logging screen has been refactored to use a new component-based architecture, introducing dedicated widgets for the logs table (\\_logs\_table.dart\), log details (\\_log\_details.dart\), and column rendering (\\_message\_column.dart\, \\_when\_column.dart\). This change enhances the user experience by displaying metadata chips (such as log level, isolate, and zone information) directly within the log table rows and adding a search capability within the log details view. The screen now also supports a retention limit setting to control the number of logs retained, accessible via a new settings dialog, and improves performance by optimizing how log data is computed and displayed.

_packages/devtools\app/lib/src/screens/logging · high confidence

Memory screen refactored to use a dedicated controller and screen body

The Memory screen's internal structure has been reorganized to improve maintainability and support offline capabilities. A new \MemoryController\ now centralizes the lifecycle and state management for the Diff, Profile, Chart, and Trace panes, handling both connected and offline data initialization. The UI has been split into distinct \MemoryScreenBody\ (connected) and \DisconnectedMemoryScreenBody\ components, with the latter providing a simplified view for offline analysis. Additionally, the tabbed interface (\MemoryTabView\) and control pane have been integrated into this new framework, ensuring consistent state sharing (such as class filters) across panes.

_packages/devtools\app/lib/src/screens/memory/framework · high confidence

Migrate DevTools app to Material 3 and integrate extension support

The DevTools application UI has been migrated from the standard Flutter Material library to \package:material\_ui\, enabling Material 3 styling and theming. Additionally, the app now supports dynamic DevTools extensions; when the \devToolsExtensions\ feature flag is enabled, the app dynamically loads and displays extension screens (such as the Provider screen) alongside the built-in tools, while hiding built-in screens that conflict with available extensions.

_packages/devtools\app/lib/src · high confidence

Migrate DevTools client to HTTP API and decouple server availability checks

The DevTools client now uses a dedicated HTTP API for server communication instead of relying solely on the legacy Server-Sent Events (SSE) connection. This change introduces a new \isDevToolsServerAvailable\ check that verifies server availability independently of the SSE connection, preventing connection failures from blocking core functionality. Additionally, the SSE client is now disabled when DevTools is running in embedded mode to avoid tying up limited server connections, ensuring smoother operation in IDE-integrated environments.

_packages/devtools\app/lib/src/shared/server · high confidence

Migrate UI components to Material 3 and shared design system

DevTools now uses the \material\_ui\ library and the \devtools\_app\_shared\ design system for its shared UI components. This migration introduces a consistent Material 3 appearance across the application, including updated color schemes, typography, and widget styles (such as buttons, dialogs, and dropdowns) defined in the new \colors.dart\ and \common\_widgets.dart\ files. Users will see a refreshed visual theme that aligns with modern Material Design guidelines, with improved consistency in interactive elements like the pause/resume controls, filter dialogs, and search fields.

_packages/devtools\app/lib/src/shared/ui · high confidence

Migrate analytics implementation to package:web and unified\_analytics

The analytics subsystem in \devtools\_app\ has been restructured to support WebAssembly and modern web standards. The platform-specific analytics logic is now split into \\_analytics\_stub.dart\ (for desktop/VM) and \\_analytics\_web.dart\ (for web), selected via conditional imports in \analytics.dart\. The web implementation now uses \package:web\ and \dart:js\_interop\ to interact with the browser, and sends events through \package:unified\_analytics\. A new \AnalyticsController\ manages consent and telemetry state via the DTD manager, and a new \AnalyticsPrompt\ UI component handles user consent. Common utilities, such as path normalization for Windows and stack trace chunking for GA4, have been consolidated in \analytics\_common.dart\.

_packages/devtools\app/lib/src/shared/analytics · high confidence

Migrate debugger variable inspection to the Debug Adapter Protocol (DAP)

The debugger's variable inspection now uses the Debug Adapter Protocol (DAP) instead of the legacy VM Service protocol. This change introduces new internal models, such as \DapObjectNode\ and \GenericInstanceRef\, to handle variable trees and references, and updates the \tree\_builder\ to fetch variable children via DAP requests. For users, this provides a more robust and standardized way to inspect variables in the debugger, ensuring consistent behavior across different debugging backends.

_packages/devtools\app/lib/src/shared/diagnostics · high confidence

Migrate post message handling to package:web

The post message implementation in the DevTools app has been updated to use \package:web\ and the new \dart:js\_interop\ APIs. This change introduces a conditional import structure that provides a web-specific implementation for receiving and sending messages via the browser window, while maintaining a stub for unsupported platforms, ensuring compatibility with modern web standards and WASM targets.

_packages/devtools\_app/lib/src/shared/config\_specific/post\message · high confidence

Migrate shared UI components to material\_ui

The shared UI components in \packages/devtools\_app\_shared/lib/src/ui\ (including buttons, dialogs, split panes, and text fields) have been migrated from \flutter/material.dart\ to \material\_ui/material\_ui.dart\. This change updates the underlying widget implementations and styling logic for these shared elements, ensuring consistent DevTools styling across the application while relying on the new material UI library.

_packages/devtools\_app\shared/lib/src/ui · high confidence

New chart data primitives and trace definitions for memory pane

The memory chart pane now includes dedicated data handling files (\charts.dart\ and \primitives.dart\) that define the specific trace names, JSON field mappings, and legend assets for VM and Android memory metrics. It also introduces a \ChartInterval\ enum, allowing users to filter the displayed memory statistics by time duration (Default, 1, 5, 10 minutes, or All), and establishes the \ChartsValues\ class to aggregate and expose trace data at specific timestamps for rendering.

_packages/devtools\app/lib/src/screens/memory/panes/chart/data · high confidence

New connection summary UI and app state management components

This change introduces new components in the connected app service layer to improve the user experience when viewing connection details and managing app state. The \ConnectedAppSummary\ widget now renders connection information (such as OS, build type, and platform) in a responsive layout that switches between a single column and a two-column view based on screen width, and it uses \SelectionArea\ to allow users to easily copy text from the description entries. Additionally, the \AppState\ class provides a centralized, disposable container for debugger variables, the current frame, and autocomplete caches, ensuring these resources are properly cleaned up when the isolate changes or the app disconnects.

_packages/devtools\_app/lib/src/service/connected\app · high confidence

New integration test runner infrastructure for DevTools app

The integration test runner for the DevTools app has been restructured with new internal utilities. Test configuration is now parsed from comments within test files via \TestFileArgs\, allowing tests to specify the target application path, whether to enable experimental features, and whether to start a separate DevTools server instance. The runner now supports launching test apps on different devices (Flutter or Dart CLI) and can automatically start and connect to a DevTools server process, passing its address to the test environment. This provides a more flexible and configurable foundation for running end-to-end integration tests against the DevTools application.

_packages/devtools\_app/integration\_test/test\infra/run · high confidence

Performance screen restructured for web apps and Impeller support

The Performance screen now displays specific instructions for web apps (Flutter and Dart) instead of the full profiling interface, and it detects whether the connected app is using the Impeller rendering engine to adjust the available data. The screen's internal architecture has been reorganized into a new controller/model structure that manages feature tabs (Frame Analysis, Rebuild Stats, Timeline Events) and supports offline data import, while ensuring that Raster Stats and Frame Analysis tabs are hidden for non-Flutter applications.

_packages/devtools\app/lib/src/screens/performance · high confidence

Platform-specific drag-and-drop and host detection implementations

The drag-and-drop system now uses platform-specific implementations: on the web, it listens to native browser drag events to import JSON files, while the desktop stub remains unimplemented. Additionally, host platform detection (e.g., macOS identification) is now determined via the browser user agent on web instead of the Dart \dart:io\ platform library.

_packages/devtools\_app/lib/src/shared/config\_specific/drag\_and\drop · high confidence

Platform-specific export and import implementation for DevTools

The import/export functionality in DevTools now uses platform-specific implementations to handle file operations correctly on different environments. On desktop, the \FileSystemDesktop\ class writes exported files directly to the user's Downloads directory or system temp folder. On the web, exports are triggered via a browser download using \Blob\ and \HTMLAnchorElement\. The core \ImportController\ validates imported JSON files to ensure they are valid DevTools snapshots, checks for legacy format compatibility (specifically for performance data), and loads the offline data into the controller, while the \ExportController\ abstracts the saving logic to allow these platform-specific behaviors.

_packages/devtools\_app/lib/src/shared/config\_specific/import\export · high confidence

Platform-specific initialization and storage for DevTools

The DevTools app now uses a conditional import strategy to initialize platform-specific behavior: on desktop, it uses a local file-based storage implementation, while on the web, it attempts to connect to the DevTools server for storage and falls back to browser local storage if unavailable. The web initialization also includes logic to handle keyboard shortcuts (like copy/paste) when embedded in VS Code, ensuring IDE shortcuts continue to work correctly.

_packages/devtools\_app/lib/src/shared/config\_specific/framework\initialize · high confidence

Platform-specific logging implementation for web and native environments

The DevTools logging system now uses conditional imports to provide distinct logging behaviors for web and native (IO) platforms. On web, logs are routed to the browser console using \package:web\ APIs (e.g., \console.log\, \console.warn\), while native environments continue to use standard print statements. Additionally, error handling for allowed errors is now platform-aware, ensuring that error messages are formatted and logged appropriately for the current runtime environment.

_packages/devtools\_app/lib/src/shared/config\specific/logger · high confidence

Rebuild stats pane now shows debug-mode warning in profile builds

The Rebuild Stats pane in the Performance screen now displays a clear message ('Rebuild information is not available for this frame. Widget rebuild counts are only available when running an app in debug mode.') when the connected application is running in profile mode. Previously, the pane might have shown empty or misleading data in this scenario; now it explicitly informs users that widget rebuild counts require debug mode, improving the clarity of the debugging experience.

_packages/devtools\_app/lib/src/screens/performance/panes/rebuild\stats · high confidence

Redesigned DevTools UI framework and settings dialog

The DevTools application scaffold has been refactored to use the \material\_ui\ library instead of standard Flutter Material widgets, introducing a new visual style across the app bar, status line, and dialogs. The Settings dialog now includes a dedicated section for experimental features, allowing users to enable WebAssembly compilation for potential performance gains, and adds a verbose logging toggle with options to copy or clear logs. The About dialog has been updated to include a direct link to view licenses, and the app bar now features an overflow button to manage screen tabs when space is limited.

_packages/devtools\app/lib/src/framework/scaffold · high confidence

Refactor CPU Profiler controls into dedicated UI components

The CPU Profiler controls pane has been restructured into two new files: \cpu\_profiler\_controls.dart\ and \profiler\_screen\_controls.dart\. The \cpu\_profiler\_controls.dart\ file introduces \UserTagDropdown\ and \ModeDropdown\ widgets, enabling users to filter profiles by user tags and switch between function and code view modes, with the latter respecting the Advanced Developer Mode setting. The \profiler\_screen\_controls.dart\ file consolidates the main recording controls (Start/Stop, Clear) and secondary actions (Load all CPU samples, sampling rate, Open/Save) into a unified \ProfilerScreenControls\ widget, improving code organization and maintainability for the profiler's user interface.

_packages/devtools\app/lib/src/screens/profiler/panes/controls · high confidence

Refactored banner, error, and notification management into new shared managers

The banner, error badge, and notification systems have been refactored into dedicated manager classes in the shared managers directory. Banner messages now support universal display across all screens and automatically dismiss on connection changes. Error badges are managed centrally with specific screens (Inspector, Performance, Network, Logging) handling their own unread state logic. A new notification service standardizes how user-facing messages and errors are displayed, including support for actionable error reports. Additionally, DTD manager extensions were added to handle unified analytics consent and telemetry settings, and a survey service was introduced to manage periodic user feedback prompts.

_packages/devtools\app/lib/src/shared/managers · high confidence

Refactored memory chart UI into dedicated widget components

The memory chart pane's user interface has been reorganized into specific, reusable widgets: \ChartControlPane\ (controls for pause/resume, clear, legend toggle, and interval selection), \MemoryChartPane\ (the main layout and hover interactions), \IntervalDropdown\ (time-range selector), \MemoryChartLegend\ (legend display), and \MemoryChart\ (the chart rendering). This change improves code modularity and maintainability without altering the visible functionality of the memory profiling tool.

_packages/devtools\app/lib/src/screens/memory/panes/chart/widgets · high confidence

Refactored memory chart controller into modular components

The memory chart pane controller has been restructured into distinct classes to improve maintainability and support offline data modes. The new \ChartVmConnection\ class manages the live connection to the VM service, handling event listeners for memory, GC, and isolate events, as well as periodic polling for memory usage. A new \ChartData\ class handles the serialization and deserialization of chart state (including timeline, interval, and visibility settings) for offline viewing. The \MemoryChartPaneController\ now orchestrates these components, initializing the connection only when the chart is visible and connected, and managing the lifecycle of the underlying chart controllers (VM, Event, and Android). This change also introduces a \MemoryTracker\ to centralize the logic for processing memory data from various sources (isolates, ADB, raster cache) and updating the timeline.

_packages/devtools\app/lib/src/screens/memory/panes/chart/controller · high confidence

Refactored memory chart controllers to use Material UI and new trace structures

The Android, Event, and VM memory chart controllers have been rewritten to migrate from the legacy \flutter/material.dart\ imports to the \material\_ui/material\_ui.dart\ package. This change introduces a new, explicit trace setup mechanism where specific memory metrics (such as Android heap categories, VM memory stats, and event types) are defined with distinct colors, symbols, and stacking behaviors, replacing the previous implicit or less structured charting logic.

_packages/devtools\app/lib/src/screens/memory/panes/chart/controller/charts · high confidence

Refactored memory diff controller with snapshot serialization and retaining path visualization

The memory diff pane's controller logic has been reorganized into dedicated files (class\_data.dart, diff\_pane\_controller.dart, snapshot\_item.dart) to support saving and loading heap diff states. This change introduces serialization for heap snapshots, allowing users to persist and restore their diff configurations, and adds a new RetainingPathController to visualize retaining paths for selected classes. The diff pane now manages snapshot data items with async loading, selection handling, and size type toggling (shallow vs. retained), improving the stability and usability of the memory diffing experience.

_packages/devtools\app/lib/src/screens/memory/panes/diff/controller · high confidence

Rewritten table components with improved sorting, search, and column sizing

The shared table implementation has been refactored to provide a more robust and performant data grid. Users will now experience improved table sorting, including secondary sort support and the ability to sort by default on numeric columns. Search functionality is now integrated directly into the table via a SearchController, allowing for real-time highlighting of matches that refresh after sorting. Column sizing has been enhanced with configurable minimum widths and a new 'size to fit' mode that eliminates unnecessary horizontal scrolling when possible. Additionally, the table now supports column grouping with visual dividers, hover handling for rows, and better state preservation for scroll position and sort preferences across data updates.

_packages/devtools\app/lib/src/shared/table · high confidence

Updated embedded Perfetto UI to v34.0 with DevTools dark theme support

The embedded Perfetto trace viewer has been updated to version 34.0 (commit 16f63abe3), bringing the latest trace viewing features and performance improvements. This update also introduces a native dark theme for the trace viewer within DevTools, ensuring the UI matches the application's current color scheme, while maintaining offline capability through the bundled service worker.

_third\_party/packages/perfetto\_ui\compiled · high confidence

Updated example extension assets and build output

The pre-built assets for the \dart\_foo\ DevTools extension example have been updated, including regenerated font manifests, asset manifests, and the CanvasKit JavaScript library. This ensures the example extension's web app build output is synchronized with the current shared assets and rendering engine.

_packages/devtools\_extensions/example/packages\_with\_extensions/dart\_foo/packages/dart\foo · high confidence

VM Tools screen restructured with new controller and Material 3 UI

The VM Tools screen in the Developer Tools has been reorganized into a dedicated module under \screens/vm\_developer\. This change introduces a new \VMDeveloperToolsController\ to manage the lifecycle of the Object Inspector and tab selection, replacing the previous ad-hoc state management. The UI has been migrated to use \material\_ui/material\_ui.dart\ (Material 3), updating components like \VMInfoCard\ and the main screen body to use \NavigationRail\ and \IndexedStack\ for tab navigation. Additionally, \vm\_service\_private\_extensions.dart\ was added to expose internal VM fields (such as heap stats and private object types like ICData and WeakArray) for advanced debugging scenarios.

_packages/devtools\_app/lib/src/screens/vm\developer · high confidence

Fixes

Fixes text field focus issues in embedded web environments

Added platform-specific focus utilities to resolve a bug where text fields retained focus incorrectly when DevTools was embedded in an IFRAME on the web. The new \focus\_utils.dart\ module introduces a blur listener for web platforms that detects when the window loses focus and blurs active elements within the Flutter view, while remaining a no-op on desktop. This change ensures smoother interaction when DevTools is hosted inside other applications or IDEs.

_packages/devtools\app/lib/src/shared/utils · high confidence

Test coverage

3 commits adding/updating tests in packages/devtools\_app/webdriver\_test; Added CPU profiler test fixtures; Added DevTools benchmark and webdriver tests; Added Perfetto timeline test data for performance testing; Added UI tests for shared DevTools components; Added UI tests for shared DevTools components; Added app size analysis test fixtures; Added comprehensive tests for the CPU Profiler screen and its components; Added comprehensive tests for the Network screen; Added debugger test data for VM service object trees; Added fixture source files for autocomplete and debugger tests; Added golden tests for Dart syntax highlighting; Added integration test driver with golden image comparison; Added integration test runner and documentation for DevTools app; Added integration tests for live DevTools connections; Added integration tests for offline memory data and Perfetto trace viewer; Added macOS Runner test scaffold; Added memory\_app fixture for DevTools testing; Added networking test fixture app; Added offline memory screen test data; Added performance test scene infrastructure; Added simulated editor for testing editor service interactions; Added standalone UI test scenes for editor and property editor sidebars; Added syntax highlighting test data for Dart language features; Added test fixture app for debugger panel integration tests; Added test fixture applications for console output and debugging scenarios; Added test fixture for missing Material error; Added test fixtures for Inspector integration tests; Added test fixtures for cancelled HTTP requests and memory profiling data; Added test fixtures for deep link validation responses; Added test infrastructure for defining and running DevTools scenes; Added test infrastructure for memory heap snapshot analysis; Added test infrastructure for platform-aware golden file matching; Added test infrastructure for the CPU Profiler default scene; Added test infrastructure scenes for the Memory screen; Added test infrastructure utilities for DevTools; Added test utilities for Network View hot-restart scenarios; Added test utilities for widget testing in devtools\_app\_shared; Added tests for App Size screen and code size attribution views; Added tests for CPU flame chart and treemap components; Added tests for Deep Links screen and settings models; Added tests for DevTools extension analytics, screen, service, and settings; Added tests for DevTools routing, screen controller lifecycle, and visible screen configuration; Added tests for DevTools scaffold and about dialog behavior; Added tests for DevTools server API URI resolution and JSON-to-service cache logic; Added tests for DevTools service layer components; Added tests for DisconnectObserver and MemoryObserver components; Added tests for EditorClient refactoring and command APIs; Added tests for EmbedMode argument parsing; Added tests for FutureWorkTracker and utility debouncers; Added tests for GitHub issue URI generation; Added tests for HTTP request data parsing and byte formatting; Added tests for Inspector screen components and error tracking; Added tests for Layout Explorer components and utilities; Added tests for Memory screen controller and UI behavior; Added tests for Perfetto tracing model and timeline event processing; Added tests for Property Editor and DartDoc utility; Added tests for TestFileArgs parsing logic; Added tests for VM Developer object inspector components; Added tests for analytics consent prompt and stack trace optimization; Added tests for banner messages, error badges, and survey logic; Added tests for console variable assignment parsing; Added tests for debugger screen components; Added tests for devtools\_app\_shared utility classes; Added tests for diagnostics nodes and inspector service; Added tests for memory chart, data controller, and settings dialog; Added tests for memory diff pane controller and heap analysis; Added tests for memory heap analysis and class filtering logic; Added tests for retaining path logic; Added tests for shared primitives utilities; Added tests for the Accessibility screen and controller; Added tests for the Allocation Profile table view; Added tests for the DTD Tools screen and its sub-views; Added tests for the Performance screen and Frame Analysis components; Added tests for the network request cURL command generation; Added tests for the shared FlatTable component; Added unit and widget tests for memory allocation tracing; Added unit and widget tests for shared UI components; Added unit and widget tests for the Logging screen; Added unit tests for DevTools preferences controllers; Added unit tests for DevTools preferences controllers; Added unit tests for Flutter Frames performance screen components; Added unit tests for Flutter version parsing and service extension management; Added widget tests for DevTools framework components; Added widget tests for Performance Controls and Enhance Tracing settings; Added widget tests for VS Code sidebar debug sessions and DevTools options; New benchmark automators for CPU Profiler and Performance screens; New test infrastructure for running DevTools against live Flutter apps.

Dependencies

Migrate DevTools packages to Material 3 and Dart 3.11

DevTools packages and their example apps have been upgraded to use the \material\_ui\ package (version 1.4.0), which provides Material 3 components, replacing the previous Material 2 implementation. Additionally, the minimum Dart SDK constraint for the core packages (\devtools\_app\, \devtools\_app\_shared\, \devtools\_extensions\, \devtools\_shared\, \devtools\_test\) has been raised to 3.11.0, and the Flutter SDK constraint to 3.41.0. This change ensures compatibility with the latest Dart and Flutter features and aligns the DevTools UI with the current Material Design standards.

(dependencies) · high confidence

Housekeeping

DevTools 2.61.0 release notes published; DevTools app version updated to 2.61.0.

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

How this codebase got here

Score

  • CAI 59.7 → 63.2 (+3.5)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 69.8 → 69.7 (-0.1)
  • Architecture 95.3 → 95.5 (+0.2)
  • Maturity 64.0 → 71.6 (+7.6)
  • Readiness 50.5 → 53.5 (+3.0)
  • Security 73.3 → 73.3 (0.0)
  • Performance 66.4 → 70.7 (+4.3)

Resolved (12)

  • Change coupling: _ide_theme_web.dart ↔ theme.dart (packages/devtools_app_shared/lib/src/ui/theme/_ide_theme_web.dart)
  • Duplicated block (10–15 lines × 3) (packages/devtools_app/lib/src/screens/inspector/inspector_data_models.dart)
  • Duplicated block (13 lines × 2) (packages/devtools_app/lib/src/extensions/embedded/_view_web.dart)
  • No ADRs found
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #3
  • Orphaned file (packages/devtools_app/lib/src/shared/diagnostics/variable_factory.dart)
  • Projects may be oversized for their cohesion
  • TodoComment (packages/devtools_app/lib/src/shared/framework/app_error_handling.dart)
  • TodoComment (packages/devtools_app/lib/src/shared/framework/app_error_handling.dart)
  • TodoComment (packages/devtools_app/lib/src/shared/framework/app_error_handling.dart)

New (112)

  • Change coupling: flutter_frames_controller.dart ↔ timeline_events_controller.dart (packages/devtools_app/lib/src/screens/performance/panes/flutter_frames/flutter_frames_controller.dart)
  • Documentation: no build, run or usage example (packages/devtools_app/README.md)
  • Documentation: no build, run or usage example (packages/devtools_shared/README.md)
  • Documentation: no map of the repository's parts (README.md)
  • Duplicated block (13 lines × 2) (packages/devtools_app/lib/src/extensions/embedded/_view_web.dart)
  • Edited copies of one member (3 members, 12+ corresponding lines) (packages/devtools_app/lib/src/screens/memory/panes/tracing/tracing_tree.dart)
  • Edited copies of one member (3 members, 14+ corresponding lines) (packages/devtools_app/lib/src/screens/memory/panes/diff/widgets/classes_table_diff.dart)
  • Edited copies of one member (3 members, 14+ corresponding lines) (packages/devtools_app/lib/src/screens/vm_developer/object_inspector/vm_code_display.dart)
  • Edited copies of one member (3 members, 16+ corresponding lines) (packages/devtools_app/lib/src/screens/memory/shared/heap/sampler.dart)
  • Edited copies of one member (3 members, 16+ corresponding lines) (packages/devtools_app/lib/src/screens/network/network_screen.dart)
  • Edited copies of one member (3 members, 26+ corresponding lines) (packages/devtools_app/lib/src/screens/memory/panes/chart/widgets/chart_control_pane.dart)
  • Edited copies of one member (4 members, 17+ corresponding lines) (packages/devtools_app/lib/src/screens/deep_link_validation/deep_links_model.dart)
  • Edited copy of a member (10 corresponding lines) (packages/devtools_app/lib/src/screens/memory/panes/chart/controller/charts/android_chart_controller.dart)
  • Edited copy of a member (10 corresponding lines) (packages/devtools_app/lib/src/screens/performance/panes/frame_analysis/frame_analysis_model.dart)
  • Edited copy of a member (12 corresponding lines) (packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart)
  • Edited copy of a member (12 corresponding lines) (packages/devtools_app/lib/src/service/json_to_service_cache.dart)
  • Edited copy of a member (13 corresponding lines) (packages/devtools_app/lib/src/extensions/extension_settings.dart)
  • Edited copy of a member (13 corresponding lines) (packages/devtools_app/lib/src/screens/app_size/app_size_table.dart)
  • Edited copy of a member (13 corresponding lines) (packages/devtools_app/lib/src/screens/profiler/panes/method_table/method_table.dart)
  • Edited copy of a member (13 corresponding lines) (packages/devtools_app/lib/src/shared/charts/flame_chart.dart)
  • …and 92 more

Changes since last survey

  • 16 commits — 10 feature/other, 6 fixes

By area

  • packages/devtools_app — 10 commits
  • packages/devtools_shared — 6 commits

Notable commits

  • fix: Fix ANSI log styling (#10028)
  • fix: Fix Network toolbar and footer overflow on narrow screens (#10057)
  • fix: Fix serveAvailableExtensions test (#10085)
  • fix: Fix stale "no timeline event analysis data" message in Frame Analysis tab (#10050)
  • fix: Fix treemap tooltip text color across light and dark themes (#10035)
  • fix: Fix vulnerability in identifier for extension configuration (#10090)
  • change: Await notifyForVmServiceConnection when opening a VM service connection (#10086)
  • change: Cache source maps across DevTools error reports (#10084)
  • change: Ensure devtoolsOptionsUri points to a served extension (#10088)
  • change: Explain unavailable debugging for unattached Flutter apps (#10078)
  • change: Fetch latest timeline events before exporting Performance data (#10055)
  • change: Restrict normalizeVmServiceUri to allowed schemes and loopback hosts (#10091)
  • change: Upgrade flutter candidate and DCM version (#10048)
  • change: Validate extension file system access (#10083)
  • change: Validate incoming requests to DevTools server (#10082)
  • change: [analytics]Use unified_analytics getEnvironment() for deep link flutt… (#10077)

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

Survey your own repository

flutter/devtools 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.

About this page

  • The score is its most recent published measurement, taken on 17 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit fc67a756738b669f6a6b2023c250e7d7b52a7a32 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.85+preprod-eba6548ac50f.