flutter/devtools

This system is the Dart DevTools application, a comprehensive suite of debugging and performance profiling tools for Flutter and Dart developers. It provides specialized screens for inspecting widget trees, analyzing memory and CPU usage, monitoring network traffic, and validating deep links, while supporting both live connections and offline data analysis. The application is designed to run natively on desktop platforms and embed seamlessly within IDEs like VS Code, featuring a modular architecture that supports third-party extensions and platform-specific optimizations such as WebAssembly rendering.

78 changes.

This period focused on modernizing the DevTools architecture by migrating to Dart 3 and Flutter 3, introducing a dedicated CLI tool, and establishing native macOS support. Significant effort was directed toward refactoring core screens like the Inspector, Debugger, and Performance profiler into modular, controller-based components, while expanding capabilities with new features such as WASM rendering, memory diffing, and DTD integration.

52 changes.

The project established a shared \devtools\_app\_shared\ package to centralize service management, UI components, and utilities, enabling consistent theming and IDE embedding. Concurrently, it introduced a robust extension system with CLI tooling and iframe support, while significantly enhancing the Memory and CPU Profilers with new analysis views and dedicated integration tests.

55 changes.

This period focused on restructuring the DevTools application shell and shared framework to support robust offline mode and persistent user preferences. Significant refactoring was applied to the memory and performance profilers, introducing modular chart controllers, configurable data intervals, and new data models for Perfetto trace integration. The work also included expanding the standalone UI with a new property editor and VS Code sidebar, alongside comprehensive test coverage for these architectural changes.

15 changes.

This period focused on introducing the Property Editor with LSP integration and DartDoc rendering, alongside a new Accessibility screen for semantics tree inspection and override controls. Significant work also included adding a Queued Microtasks tab to VM Tools, implementing memory pressure monitoring, and establishing automated validation hooks for AI agent skills.

A new Process Memory view has been added to the VM Tools section of DevTools, 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

A new Queued Microtasks tab has been added to the VM Developer tools, allowing users to inspect the microtask queue of the selected isolate. The view displays a table of queued microtasks sorted by their execution order and provides a detailed stack trace for each task, captured at the time it was enqueued. Users can refresh the snapshot to see the current state of the queue and select individual microtasks to view their associated stack traces.

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

Users can now filter heap objects by class or package using a configurable filter (defaulting to excluding runtime and SDK classes) and sample live instances of classes directly from the running isolate. This change introduces a shared class filter mechanism that persists across diff and profile tabs, allowing users to narrow down the heap view, and adds the ability to drop live instances into the console for inspection, enhancing the interactivity of memory profiling.

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

Users can now filter memory profiles by class name or package using a new dialog with options to show all, exclude specific classes, or show only specific classes. A class type legend is also added to help users understand the color coding for different class types in the memory screen.

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

The \devtools\_app\_shared\ package now includes a new \url\ utility module that provides platform-specific implementations for web URL handling and VS Code integration. This change introduces conditional imports to support WebAssembly (WASM) environments by using \dart.library.js\_interop\ to select the appropriate web implementation, while providing no-op stubs for non-web platforms. The module exposes functions for loading query parameters, getting the current web URL, performing redirects and reloads, and updating query parameters without full page reloads. Additionally, it adds 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 URLs are handled correctly in embedded views.

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

An example Flutter web app, \foo\_devtools\_extension\, has been added to demonstrate how to build and integrate a DevTools extension for \package:foo\. This example includes a home page with expandable sections showcasing key extension capabilities: calling service extensions and evaluating Dart expressions via the VM Service protocol, interacting with the Dart Tooling Daemon (DTD) to fetch workspace/project roots and read/write files, listening for DevTools events, and using extension APIs like \copyToClipboard\, notifications, and banner messages. The package also includes configuration files for VS Code debugging with simulated environments and a \.gitignore\ to streamline development.

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

An example file (service\_example.dart) has been added to the devtools\_app\_shared package to demonstrate how to use the service manager, connect to a VM service, and interact with service extensions and isolates.

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

The macOS application runner is now fully configured with the necessary source files and build settings. This includes the AppDelegate and MainFlutterWindow implementations, the MainMenu interface, app icon assets, and configuration files (Info.plist, xcconfigs, and entitlements) that enable the DevTools app to build and run on macOS.

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

The CPU profiler now includes a new method table pane that displays methods sorted by time, supports searching, and allows sorting by columns. When a method is selected in the table, a corresponding call graph view appears alongside it, showing the method's callers and callees along with their timing percentages, enabling deeper inspection of CPU profile data.

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

The DevTools app now supports web notifications on the web platform while providing a stubbed, unsupported implementation for desktop. This change introduces a conditional export in \notifications.dart\ that selects \\_notifications\_web.dart\ (using \package:web\ and \dart:js\_interop\) when running in a browser context, and \\_notifications\_desktop.dart\ (which throws exceptions) otherwise, enabling the application to handle notification permissions and display on web targets.

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

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 and AreaPaneHeader for layout sections, the DevToolsDialog for modal interactions with custom actions, and the SplitPane widget for creating resizable horizontal and vertical splits with both default and custom splitters.

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

A new Xcode scheme (Runner.xcscheme) has been added to the macOS project configuration, enabling 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 devtools\_app.app with LLDB debugging and GPU validation mode enabled.

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

The \packages/devtools\_app\_shared/example/utils\ directory now contains example files demonstrating how to use shared utility classes and methods from \package:devtools\_app\_shared/utils.dart\. These examples cover \AutoDisposeMixin\ and \AutoDisposeControllerMixin\ for managing widget and controller lifecycles, global state management via \setGlobal\ and \globals\, list-aware notifications using \ListValueNotifier\, helper functions like \pluralize\ and \equalsWithinEpsilon\, and immediate value updates with \ImmediateValueNotifier\.

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

The \.agents\ directory now includes a validation system to ensure AI agent skills meet quality standards. A new \hooks.json\ file configures PostToolUse and PostInvocation hooks that trigger scripts to lint skill files and inject review steps when skills are modified. This is supported by a new \skills\_lint\ tool (migrated from \dart\_skills\_lint\) and a \skills\_lint\_ignore.json\ configuration. Additionally, several new skills have been added to guide contributors, including \adding-changelog-entries\, \adding-copyright-headers\, \adding-release-notes\, \authoring-skills\, \closing-obsolete-issues\, \debugging-devtools-extensions\, \preparing-pr\, \reviewing-devtools-prs\, \reviewing-prs\, and \updating-package-versions\.

.agents · high confidence

The main DevTools application shell has been updated to dynamically merge external DevTools extensions into the standard navigation menu. When the 'devToolsExtensions' feature flag is enabled, the app checks for visible extensions (such as the provider extension) and injects their corresponding screens into the route list, allowing users to access third-party tooling alongside built-in tools like Performance and Inspector. This change also handles the lifecycle of these extension screens, ensuring they are properly initialized and disposed of when the app connects or disconnects from a target.

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

The DevTools application now saves user settings to local storage, ensuring that configurations such as dark mode, auto-refresh for the widget inspector, CPU sample inclusion in timelines, and logging retention limits are retained between sessions. This change introduces dedicated preference controllers for the Inspector, Logging, Memory, Network, Performance, and CPU Profiler screens, allowing users to customize their debugging experience without having to reconfigure these options every time they open the tool.

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

The macOS build configuration for the DevTools application has been established, introducing the standard Xcode project structure (\project.pbxproj\) required to build the native macOS app. This includes the primary \Runner\ target, a \RunnerTests\ target for unit testing, and the necessary build phases to compile Swift sources (such as \AppDelegate.swift\ and \MainFlutterWindow.swift\), link the Flutter framework, and bundle resources like assets and the main menu. This change provides the foundational build system for the macOS platform within the DevTools suite.

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

The \devtools\_shared\ package is introduced as a shared library for Dart DevTools, consolidating common structures, server APIs, and utilities. It exports core memory data models (such as \HeapSample\ and \AdbMemoryInfo\), deep link settings for Android and iOS, and the extension management framework (including \ExtensionsManager\ and \DevToolsOptions\). The package also provides the \DtdInfo\ class to replace the deprecated \DTDConnectionInfo\ typedef, supporting separate local and exposed URIs for remote environments, and includes server API definitions for preferences, surveys, release notes, and app size files.

_packages/devtools\shared · high confidence

This change adds the foundational macOS build configuration for the DevTools application. It introduces Xcode workspace and project settings, CocoaPods integration files, and a generated plugin registrant that explicitly registers the \file\_selector\_macos\ and \url\_launcher\_macos\ plugins, enabling the app to run natively on macOS.

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

Adds a new App Size screen to DevTools that allows users to analyze application binary sizes. The screen features an Analysis tab to view size breakdowns and a Diff tab to compare size changes between two builds, with options to filter by increase, decrease, or combined changes. It also supports deferred loading analysis, displaying specific indicators for deferred code segments, and includes a Call Graph/Dominator Tree view to help attribute code size to specific functions and call paths.

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

The Inspector now includes a dedicated visualizer for box model layout properties. This change adds a new widget that 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

A new Deep Link Validation screen has been added to DevTools, allowing developers to diagnose and fix configuration issues with Android App Links and iOS Universal Links. The tool connects to the Flutter project to extract deep link data, then validates domain associations (checking for Digital Asset Links JSON and Apple-App-Site-Association files) and path configurations. It provides a split-view interface with detailed error explanations, fix instructions, and the ability to recheck links or generate asset link templates directly from the UI.

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

The \devtools\_extensions\ package now ships with a CLI tool providing \build\_and\_copy\ and \validate\ commands. The \build\_and\_copy\ command automates building the extension's Flutter web app and copying the output to the parent package's \extension/devtools\ directory, while the \validate\ command checks that an extension's directory structure and \config.yaml\ (including \pubspec.yaml\ existence and valid name characters) meet the requirements for loading in DevTools.

_packages/devtools\extensions · high confidence

Adds the core UI and service logic for managing DevTools extensions within the app. This includes the \ExtensionScreen\ and \ExtensionView\ widgets that render extension content in an embedded iframe, along with controls to force reload or disable extensions. The \ExtensionService\ now tracks available and visible extensions, handling deduplication and state persistence, while the \ExtensionSettingsDialog\ provides a user interface to enable or disable specific extensions and toggle a setting to show only enabled extension screens.

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

A new Enhance Tracing feature has been added to the Performance pane, allowing users to toggle additional service extensions to capture more granular data in the Timeline. This includes options to profile widget builds (scoped to either all code or user-created widgets only), render object layouts, and render object paints. The UI provides a dedicated button to manage these settings, with clear warnings about potential performance impacts, and the system automatically tracks the active tracing state to annotate frame data in the timeline view.

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

The Inspector now includes a dedicated Flex layout explorer, allowing users to visualize and debug Flex widgets (such as Row and Column) directly within the layout tree. This new feature adds a \FlexLayoutExplorerWidget\ that displays axis directions, alignment properties, and child spacing, with animated transitions when properties change. It integrates with the existing inspector service to provide detailed insights into flex layout behavior, enhancing the debugging experience for Flutter developers working with flex-based layouts.

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

A new Property Editor side panel is added to the DevTools standalone UI, allowing users to view and edit Flutter widget properties directly from the IDE. The editor displays the widget name and documentation, supports filtering properties (including a toggle to show only those set in code), and provides input fields for strings, numbers, booleans, and enums with validation. It also exposes "Wrap with" refactor actions (e.g., wrapping in a Container or Padding) via buttons and an overflow menu. The panel includes a footer with a link to IDE-specific documentation and a feedback button, and handles empty states with contextual messages such as "No Dart code found" or "No Flutter widget found at the current cursor location."

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

A new Memory Diff pane has been added to DevTools, allowing users to load two heap snapshots and compare them to identify created, deleted, persisted, and delta class instances. The view features a split layout with a sortable classes table (showing instance counts and shallow/retained sizes) and a retaining path details panel. Users can take new snapshots, import or export them, rename or delete existing ones, and filter classes. The diff table includes a copy button for class names and context menus to store instances in the console, with CSV export support for the diff data.

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

The Rebuild Stats pane now displays a table of widget rebuild counts, allowing users to see which widgets are rebuilding and how often. The view includes a toggle to enable the underlying service extension for counting widget builds, and provides options to clear the collected statistics. It supports viewing stats for the latest frame, a selected frame, and overall totals, helping developers identify unnecessary rebuilds.

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

A new VM Statistics view has been added to the VM Developer tools, providing a consolidated dashboard for monitoring the Dart VM and its processes. This screen displays general VM information (such as version, embedder, and profiler mode) alongside detailed process statistics including CPU architecture, operating system, and memory utilization (RSS and zone memory). It also features an isolates preview that lists both user and system isolates, allowing developers to quickly assess the runtime environment's state.

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

The \widget\_icons\ package is added to the third-party repository, providing a set of icons representing Flutter widgets. It includes a \WidgetIcons\ class with static \IconData\ constants for various widgets (such as \alert\_dialog\, \row\, \list\_view\, and \floating\_action\_button\) and a \WidgetTheme\ class that maps widget names to specific icons and colors. An example application is included to demonstrate usage, and tests verify the theme mapping logic, including handling of generic widget types.

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

The Tracing tab in the Memory screen now allows you to enable allocation tracing for individual classes. You can filter the class list, select specific types to trace via a checkbox, and view the resulting allocation sites in a tree view with Bottom Up and Call Tree tabs. The state is persisted across sessions, and the feature is available in both standard and profile builds.

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

The CPU profiler pane now includes a new bottom-up view (CpuBottomUpTable) that displays stack frames organized by their callers, allowing users to identify which methods are responsible for the most cumulative time. This new table, along with the existing call tree, enforces tree guidelines for better visual hierarchy and sets default sorting to descending by time (self time for bottom-up, total time for call tree). Additionally, the method column now consistently displays the source location alongside the method name for improved context.

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

DevTools replaces its previous external charting dependencies with a new, internal charting subsystem located in \packages/devtools\_app/lib/src/shared/charts\. This new system provides a lightweight, Flutter-native way to plot timeseries data, supporting line charts for non-numeric events and scatter charts with optional shading. The implementation includes a \ChartController\ for managing data traces and axis scaling, a \Chart\ widget for rendering, and specialized visualizations like the \FlameChart\ for CPU profiling and a \Treemap\ for memory usage. This change gives DevTools full control over chart rendering, improving extensibility and eliminating issues associated with the previous third-party packages.

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

The Performance screen now includes a dedicated Flutter Frames pane that visualizes frame build, raster, and vsync overhead times. This feature introduces automatic jank detection based on the device's display refresh rate, including specific detection for shader jank, and displays banner messages when janky frames are identified. The chart respects user visibility preferences, persists its state in offline mode, and indicates whether the app is using the Impeller or Skia renderer.

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

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 inspect individual heap instances directly from the UI via a context menu. The feature includes a new data model for profile records, a controller to manage filtering and pinning state, and support for serializing profile data for offline use.

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

The \devtools\_app\_shared\ library now exposes a consolidated set of shared resources via new barrel files (\service.dart\, \ui.dart\, \utils.dart\, \web\_utils.dart\, \shared.dart\). This includes service-layer components such as the DTD manager, isolate manager, and service extension manager, alongside UI utilities like \SplitPane\, \FlexSplitColumn\, and theme definitions. A new \EmbedMode\ enum is introduced to support multi-tab embedded views, allowing DevTools to adapt its interface (e.g., hiding the top-level tab bar) based on query parameters from the embedding IDE.

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

The Memory screen now includes a Diff pane that allows users to compare two heap snapshots to identify memory allocation changes. This new UI component presents a list of available snapshots on the left and displays the diff details or documentation on the right, enabling developers to detect unexpected memory usage by analyzing retaining paths and class differences between snapshot states.

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

A new shared console component and its backing service have been added to the application. The \Console\ widget renders a scrollable list of output lines (text or structured Dart objects) with automatic scrolling and text selection support, while the \ConsoleService\ manages the state of these lines, handling both standard I/O text and browsable instance references. This provides a unified way to display console output and variable inspection results across different DevTools screens.

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

This change consolidates shared UI assets and widgets into the \packages/devtools\_app/lib/src/shared/ui\ directory, establishing a common foundation for the DevTools interface. It introduces a centralized \colors.dart\ file defining theme-aware color constants (such as \ThemedColorPair\ for light/dark mode support) and extensions on \ColorScheme\ for syntax highlighting and UI elements. Additionally, it adds a suite of reusable widgets including \AnalyticsDropDownButton\ for tracking selection changes, \EditableList\ for managing dynamic entry lists, \OpenSaveButtonGroup\ for file import/export operations, and \FilterControllerMixin\ to standardize data filtering logic across screens. These components provide the building blocks for consistent styling, analytics integration, and interactive controls throughout the application.

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

The console pane now uses a new set of shared widgets for displaying variable values, evaluating expressions, and managing console output. This includes the ConsolePane for the main tab, ExpressionEvalField for input with autocomplete, DisplayProvider for rendering variable details, and ExpandableVariable for tree-like inspection, improving consistency and reusability across DevTools screens.

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

The console subsystem now includes a new \primitives\ folder containing independent, reusable libraries for core console functionality. This adds \ConsoleVariableAssignment\ to parse and manage variable bindings (e.g., \var x=$2\), \EvalHistory\ to handle expression evaluation history with navigation support, \EvalScope\ to manage variable references and refresh logic for the debugger, and \FlutterTreeType\ to define tree types for console output. These components provide the foundational data structures and logic for the console interface.

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

The memory screen now includes a new \primitives\ folder containing reusable, independent libraries for memory analysis. This adds a context menu widget for instance views, a serializable timeline model for managing heap samples and extension events, utility functions for fetching heap snapshot graphs, and UI helpers for drawing chart lines and defining size types (shallow vs. retained).

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

The diagnostics subsystem now includes a new \primitives\ folder containing independent utility classes that do not depend on other libraries within the diagnostics package. This adds \InspectorInstanceRef\ for stable, non-expiring references to Dart objects, \RecordFields\ to parse and sort positional and named fields from VM service records, and \InspectorSourceLocation\ and \SourcePosition\ to handle source file paths, line numbers, and column offsets. These primitives provide the foundational data structures for the rest of the diagnostics system.

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

The DevTools repository now includes a dedicated command-line interface, 'dt', to manage local development, testing, and release processes. This tool replaces several legacy shell scripts and provides unified commands for building the DevTools web app, running analysis, and updating the local Flutter SDK. It introduces a new mechanism for SDK management, allowing users to either use a local 'tool/flutter-sdk' directory or explicitly opt to use the Flutter SDK found on their system PATH via the '--flutter-from-path' flag. The tool also includes CI integration scripts for running benchmarks, package tests, and customer test registry checks, streamlining the workflow for contributors and release engineers.

tool · high confidence

DevTools now monitors its own memory usage and displays a warning banner when usage exceeds 3GB, offering a "Reduce memory" action that clears data from unused screens to prevent crashes. Additionally, a new disconnect observer automatically detects service connection losses, shows a "Disconnected" overlay with a reconnect button, and provides an option to review recent data offline.

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

Users can now save their captured network requests as a standard HAR file and load previously saved HAR files back into the Network profiler. This is implemented via new \har\_builder.dart\, \har\_data\_entry.dart\, and \har\_network\_data.dart\ modules that serialize \DartIOHttpRequestData\ into the HAR 1.2 JSON format, and an \OfflineNetworkData\ class that handles the deserialization of HAR entries back into internal request models. The \NetworkController\ exposes an \exportAsHarFile\ method to trigger the download, while the \NetworkScreen\ provides the corresponding UI controls for both exporting and importing these files.

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

The DevTools app now includes a dedicated Accessibility screen that provides two main capabilities: an interactive Semantics Tree pane for inspecting the accessibility hierarchy of the connected app, and an Accessibility Overrides pane for simulating settings in real-time. The overrides pane allows users to adjust brightness (system, light, or dark mode), scale text size, and toggle bold text, screen reader debugging, and high contrast modes. The semantics tree pane displays the app's UI structure as a navigable tree, showing node IDs, labels, and widget types, with support for loading, refreshing, and error handling.

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

The Object Inspector now includes two new selectable views accessible via the left-hand dropdown: Class Hierarchy and Object Store. The Class Hierarchy view displays the inheritance structure of all classes in the selected isolate as a navigable tree, allowing you to jump between related classes. The Object Store view presents a table of key-value pairs from the isolate's object store, enabling you to inspect internal VM objects and navigate to them from the store directly.

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

A new DTD Tools screen has been added to DevTools, allowing users to connect to and inspect a Dart Tooling Daemon (DTD) instance. This screen provides a UI to view registered service methods, manually invoke them, and monitor live DTD event streams. It is designed to operate with a local DTD manager instance, enabling inspection without affecting other DevTools screens, and is gated behind the Advanced Developer Mode setting.

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

The Performance page now includes a dedicated Frame Analysis tab that provides detailed breakdowns of individual Flutter frames. This view displays a visual timeline of UI phases (Build, Layout, Paint) and Raster phases (including Shader compilation), allowing users to identify which stage consumed the most time. It also surfaces actionable hints for UI and raster jank, such as excessive save layers or intrinsic operations, and integrates with the widget rebuild count feature to show which widgets were rebuilt during a specific frame.

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

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. The screen displays general information such as the isolate name, start time, uptime, root library, and ID. It also presents memory statistics, including Dart heap size, new space usage, and old space usage. Additionally, it shows tag statistics derived from the CPU profiler (if enabled) 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

The VS Code sidebar now features a dedicated Flutter panel that displays active debug sessions and connected devices. Users can perform Hot Reload and Hot Restart actions directly from the session list, select or switch between connected devices, and enable support for additional platform types (such as Android or iOS) if they are not currently supported. The panel also includes options to open DevTools in a browser, providing a consolidated view for managing the development environment within the editor.

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

The \packages/devtools\_app/benchmark/scripts\ directory now contains a new set of CLI tools for benchmarking DevTools web performance. \run\_benchmarks.dart\ allows users to execute benchmark suites, optionally averaging results over multiple runs (\--average-of\), saving output to JSON (\--save-to-file\), and comparing against a baseline file (\--baseline\). \compare\_benchmarks.dart\ provides a standalone tool to calculate and print delta percentages between two JSON benchmark result files. Additionally, \dart2wasm\_performance\_diff.dart\ automates a full comparison workflow: it runs benchmarks for both dart2js and dart2wasm (with optional averaging), computes the performance delta, and exports the results to a CSV file for spreadsheet analysis. These scripts rely on the \web\_benchmarks\ package for analysis and support flags for browser mode and WASM compilation.

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

The DevTools app now includes dedicated components for displaying connection details and managing app state. The new \ConnectedAppSummary\ widget renders a two-column or single-column layout of connection description entries (such as device type and build mode), utilizing \SelectionArea\ to allow users to select and copy text. Additionally, the \AppState\ class provides a centralized, disposable container for debugging variables, the current frame, and autocomplete caches, while the \ConnectedAppExtension\ offers helper properties to determine if the connected app is a Flutter or Dart application and its specific platform characteristics.

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

A new \devtools\_test\ package has been introduced to centralize test utilities for Dart DevTools. This package provides shared helpers for integration and widget testing, including actions for navigating DevTools screens, finders for locating UI elements, and utilities for managing test lifecycles. It also includes a suite of fake implementations for core DevTools services—such as \IsolateManager\, \ServiceManager\, \ServiceExtensionManager\, and \VmServiceWrapper\—allowing tests to simulate VM service interactions without a live connection. Additionally, the package exports generated mocks and provides integration test utilities for connecting to test apps and verifying screenshots.

_packages/devtools\test · high confidence

DevTools now supports viewing saved data without an active connection to a Dart/Flutter app. This change introduces an \OfflineDataController\ to manage the global offline state and an \OfflineScreenControllerMixin\ that allows individual screen controllers to load and display previously exported JSON data. A dedicated \OfflineScreenBody\ widget renders these screens when offline mode is active, enabling users to inspect historical data even when disconnected.

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

The Performance screen now includes a dedicated controls pane with a 'More debugging options' button that exposes rendering layer toggles (clip, opacity, physical shape) and widget build counts, along with a 'Performance Settings' dialog for Flutter apps to toggle jank detection badges. These controls are only visible for Flutter applications and include offline-aware behavior and responsive layout adjustments.

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

The memory diff screen now includes a dedicated class details pane that visualizes retaining paths for selected classes. This pane presents a sortable table of retaining paths, showing the shortest path, instance count, shallow size, and retained size (or their deltas in diff mode). Users can select a path from the table to view its detailed breakdown, with options to copy the path to the clipboard, hide standard libraries, and invert the path direction.

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

The Network tab now includes a new shared HTTP library (\packages/devtools\_app/lib/src/shared/http\) that provides core utilities for handling HTTP request data. This includes a custom \Cookie\ parser for \Set-Cookie\ headers, HTTP date parsing utilities, and a \CurlCommand\ generator that allows users to export requests as cURL strings. The \DartIOHttpRequestData\ class centralizes the logic for fetching full request/response bodies from the VM service and handling cancellation states, while \http\_service.dart\ exposes controls to toggle HTTP timeline logging across isolates.

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

This change introduces a new \devtools\_app\_shared\ UI module that centralizes common DevTools interface elements. It provides standardized widgets for buttons (\DevToolsButton\, \DevToolsToggleButtonGroup\), layout panes (\DevToolsAreaPane\, \AreaPaneHeader\, \FlexSplitColumn\), dialogs (\DevToolsDialog\, \StateUpdateDialog\), and input fields (\DevToolsTextField\, \DevToolsClearableTextField\). It also includes a resizable \SplitPane\ widget, icon rendering utilities (\DevToolsIcon\), and helper utilities for embedded IDE themes and color parsing, ensuring a consistent look and feel across the DevTools application.

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

The \packages/devtools\_app/lib/src/shared/primitives\ directory now contains a collection of independent, reusable utility libraries. This includes an ANSI text parser for terminal output, byte size formatting and conversion utilities, a ring buffer for binary data, and mixins for managing blocking actions and collapsible animations. It also introduces custom scrollable widgets with pointer signal handling, a history manager for navigation stacks, and encoding/decoding helpers for VM service types like heap snapshots and isolate references.

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

This change introduces a new \devtools\_app\_shared\ utility package containing core helpers for building and managing DevTools extensions. It adds \auto\_dispose.dart\ to simplify resource cleanup (listeners, streams, focus nodes) in widgets and controllers, \list.dart\ with \ListValueNotifier\ for reactive list state, and \utils.dart\ with helpers for string formatting, CSS color parsing, and fuzzy matching. It also includes \web\_utils.dart\ to support the \package:web\ migration by providing extensions for JavaScript interop, alongside \enum\_utils.dart\ for enum ordering and \globals.dart\ for simple global state storage.

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

The Layout Explorer UI now renders visual overlays to help developers understand widget sizing and layout behavior. Bidirectional arrows display the actual width and height of widgets, while additional indicators show the constraints passed to the widget and highlight overflow conditions with a distinct patterned background. A new theming system assigns specific colors and icons to different widget categories (such as text, images, animations, and layout containers) to make the widget tree easier to scan and identify.

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

The Property Editor now displays widget documentation with improved formatting. A new utility class parses DartDoc text to strip template markers and applies distinct styles to code snippets (wrapped in backticks or brackets) versus regular text, allowing users to read property descriptions and default values with clearer visual hierarchy.

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

DevTools now supports embedding extensions directly within the application using HTML iframes on web platforms. This change introduces platform-specific controllers and views that manage the iframe lifecycle, handle secure sandboxing, and facilitate two-way communication between DevTools and the extension. On desktop platforms, where web views are not supported, the interface displays a placeholder message indicating that extensions cannot be displayed. The implementation also includes logic to show a specific error state when an extension requires a connected application but none is available.

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

The memory screen now supports persisting its internal state, allowing users to save and reload the configuration of the diff, profile, chart, and tracing panes along with the active tab selection and class filters. This enables users to resume their memory analysis work later without needing to reconfigure the view or re-run the initial profiling steps.

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

The core framework logic for the DevTools application has been restructured into a new \packages/devtools\_app/lib/src/framework\ directory. This change consolidates previously scattered files into a single location, introducing a \README.md\ to clarify that this folder contains code not used by specific screens. The refactored code includes \framework\_core.dart\ for global initialization and service management, \home\_screen.dart\ for the landing and connection UI, \initializer.dart\ for connection-waiting logic, \notifications\_view.dart\ for the overlay notification system, \release\_notes.dart\ for fetching and displaying version updates, and \theme\_manager.dart\ for handling IDE theme synchronization. This reorganization improves code maintainability and separation of concerns without altering the user-facing features.

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

A new \shared\ folder has been created to house code common across DevTools screens, establishing a clear separation between shared logic and framework-specific code. This location now contains core infrastructure including a global service manager (\globals.dart\), a feature flag system (\feature\_flags.dart\) for managing experimental features like DevTools extensions and DAP debugging, development helpers for local debugging (\development\_helpers.dart\), and utility modules for logging storage (\log\_storage.dart\) and application title generation (\title.dart\).

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

The diagnostics and inspector data models have been reorganized into the \packages/devtools\_app/lib/src/shared/diagnostics\ directory. This change introduces new core classes such as \DartObjectNode\ and \DapObjectNode\ to represent variable and object trees, a unified \GenericInstanceRef\ to handle references from both the Inspector Service and the Dart Debug Adapter Protocol (DAP), and a dedicated \references.dart\ module to manage live and static object references. The \InspectorService\ and \RemoteDiagnosticsNode\ classes have been updated to support this new structure, enabling consistent variable inspection across different debugging contexts.

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

The service-related code in \packages/devtools\_app/lib/src/service\ has been reorganized into a dedicated folder structure. This change introduces several new components: \JsonToServiceCache\ for converting JSON strings to fake VM service response objects to reuse data structures, \ServiceExtensionButtonGroup\ and \ServiceExtensionButton\ widgets for toggling VM service extensions with state management, \ServiceExtensionInterface\ and description classes (\ToggleableServiceExtensionDescription\, \ServiceExtensionDescription\) for defining and displaying service extensions in the UI, \ServiceManager\ for managing VM service connections and lifecycle, \ServiceRegistrations\ for defining service extension constants, \TimelineStreamManager\ for managing VM timeline streams, \VmFlagManager\ for managing VM flags, \VmServiceTrafficLogger\ for logging VM service protocol traffic, and \VmServiceWrapper\ as a wrapper around the VM service with support for DDS protocols and fake service caching.

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

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

The debugger screen logic has been reorganized into distinct, focused files to improve maintainability and separation of concerns. A new \BreakpointManager\ class now handles the lifecycle and state of breakpoints, including switching isolates and re-establishing breakpoints after hot restarts. The UI has been split into dedicated widgets: \Breakpoints\ for the breakpoint list, \CallStack\ for the stack frame view, and \CodeView\ for source code display with syntax highlighting and search. \CodeViewController\ manages the code view's state, including script history, navigation, and file search. \DebuggerController\ acts as the central screen controller, coordinating these components and managing the overall debug state. This refactoring isolates specific debugger functionalities into their own modules while maintaining the existing debugging capabilities.

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

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

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

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

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 change introduces a new theming layer in \devtools\_app\_shared\ that reads query parameters from the IDE (such as \theme\, \backgroundColor\, and \foregroundColor\) and applies them to the DevTools UI, ensuring visual consistency between the IDE and the DevTools panels.

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

The Inspector screen in DevTools has been refactored to use a dedicated \InspectorController\ and \InspectorScreenController\ to manage the widget tree, selection state, and error tracking. This change introduces a new \InspectorScreenBody\ that splits the view into the tree and details panes, and adds a \FlutterInspectorSettingsDialog\ for configuring options like hover inspection and package directories. The update also includes a new \WidgetCreationLocationTrailing\ component that displays the source file path for the selected widget and allows navigation to that location in the IDE.

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

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

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

The memory chart pane now supports configurable time intervals for data visualization, allowing users to view memory statistics over the default view, 1, 5, or 10 minutes, or all available data. This change introduces the \ChartInterval\ enum to manage these display options and includes a 500ms update delay for chart rendering. Additionally, it establishes structured definitions for Android and VM trace names (such as Java Heap, Native Heap, and RSS) and standardizes event data keys (like snapshots and GC events) to ensure consistent data handling and legend rendering in the memory profiler.

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

The DevTools application now supports distinct configuration profiles via a new \DevToolsEnvironmentParameters\ abstraction. This change adds an \ExternalDevToolsEnvironmentParameters\ implementation that tailors the user experience for third-party integrations: it disables internal username and source-map links, provides a generic loading message, and recommends external IDEs (VS Code, IntelliJ) as debuggers instead of the built-in debugger panel. It also includes logic to safely truncate GitHub issue report URLs to prevent length errors.

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

The Performance timeline pane now uses a dedicated embedded Perfetto trace viewer on web platforms, implemented via platform-specific controller and UI files (\\_perfetto\_controller\_web.dart\, \\_perfetto\_web.dart\) that register and manage an iFrame using \dart:ui\_web\ and \package:web\. On desktop platforms, the viewer is replaced by a placeholder indicating that iFrames are not supported (\\_perfetto\_desktop.dart\), and a shared \PerfettoController\ abstraction (\perfetto\_controller.dart\) coordinates trace loading, time-range scrolling, and theme changes across platforms.

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

The Logging screen has been restructured to use a new split-pane layout with a dedicated logs table and log details view. The logs table now displays metadata chips for log kind, level, isolate, and zone directly in the message column. The log details view supports both text and JSON formats, includes a search field for text logs, and allows copying filtered logs to the clipboard. A new logging settings dialog lets users configure the log retention limit.

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

The memory screen's control pane has been refactored into dedicated widgets (control\_pane, primary\_controls, secondary\_controls, settings\_dialog). Users now see a dedicated settings button that opens a Memory Settings dialog, allowing them to toggle the Android memory chart visibility and adjust the reference limit for live reference exploration. Additionally, the save/load controls are conditionally displayed based on the memorySaveLoad feature flag, and the GC button is hidden when viewing offline data.

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

The Memory screen's internal architecture has been restructured to use the new \ScreenControllers\ lifecycle management system. A new \MemoryController\ now handles the initialization, disposal, and offline data serialization for the screen's panes (Diff, Profile, Trace, and Chart). This change centralizes state management, ensuring that pane controllers are properly disposed and that offline data is saved and loaded consistently. The UI components (\MemoryScreen\, \MemoryScreenBody\, \MemoryTabView\) have been updated to interact with this new controller, improving reliability and maintainability of the memory debugging experience.

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

The DevTools app now primarily communicates with the backend via a new HTTP-based server API, replacing the legacy Server-Sent Events (SSE) connection for most operations. This change introduces dedicated API modules for analytics, deep links, extensions, preferences, surveys, and DTD URI retrieval, all of which now check \isDevToolsServerAvailable\ before making requests. Crucially, the \isDevToolsServerAvailable\ check no longer depends on the SSE connection status, allowing the app to correctly detect server availability even when running in embedded modes where the SSE API is intentionally disabled. The legacy SSE connection is now only established for non-embedded scenarios to avoid tying up limited server connections.

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

The analytics subsystem in the DevTools app has been restructured to support WebAssembly (Wasm) builds by replacing the previous \dart:js\_interop\-based web implementation with a new \package:web\-based one (\\_analytics\_web.dart\). This change introduces a conditional import strategy (\analytics.dart\) that selects the appropriate platform-specific implementation (stub for desktop/VM, web for browser) and consolidates shared logic (constants, metrics, common utilities) into dedicated files. The web implementation now integrates with \package:unified\_analytics\ to send events, including optimized stack traces and screen-specific metrics, while the stub ensures the desktop app functions without analytics calls.

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

The service management logic previously located in the main application package has been moved to the shared \devtools\_app\_shared\ package. This change centralizes the handling of VM service connections, isolate state, and service extensions, making these capabilities available for reuse across other DevTools components. Users benefit from a more consistent and robust connection lifecycle, including improved automatic reconnection to the Dart Tooling Daemon (DTD) and better handling of isolate state during hot restarts.

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

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

The Timeline Events pane now uses a new Perfetto-based architecture to process and display trace data. This change introduces a ring buffer to store incoming trace binaries, preventing Out-Of-Memory issues by trimming oldest data when the buffer exceeds the WebAssembly size limit (2^31 - 1 bytes). A new \FlutterTimelineEventProcessor\ handles the conversion of Perfetto track events into the internal timeline event model. The UI now includes a 'Include CPU samples' toggle in the controls, allowing users to opt-in to more detailed CPU trace data (with a warning about performance impact). Additionally, a loading overlay is displayed while the timeline is refreshing, and the refresh button is disabled during processing to prevent duplicate requests.

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

The VS Code DevTools extension now features a dedicated sidebar interface that lists available DevTools screens and installed extensions. This new layout organizes tools into a two-column grid on wider screens and a single column on narrower ones, while explicitly hiding legacy screens (Home, Debugger, VM Tools, Provider, Simple) from the main list. The sidebar also dynamically detects and displays DevTools extensions, managing their lifecycle based on active debug sessions and workspace roots, and provides an option to open DevTools externally in a browser when supported by the editor.

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

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

The deep link validation screen now features a dedicated project root selection view that allows users to choose a Flutter project via a text input field or a dropdown list of available roots. This view handles platform-specific path formatting (including Windows file URIs) and validates the selected project by checking for Android build variants and iOS build options, displaying informative dialogs if the project is not configured correctly or is not a Flutter project.

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

The shared framework layer has been restructured to introduce dedicated modules for core application concerns. Error handling is now centralized in \app\_error\_handling.dart\, which hooks into Flutter and platform error zones to report errors to analytics and display user notifications, including source-map-aware stack traces for web builds. Routing is managed by new \routing.dart\ components (\DevToolsRouteInformationParser\ and \DevToolsRouterDelegate\) that translate between internal page IDs and URL states, supporting query parameters and navigation state. Screen lifecycle and connectivity are handled by \framework\_controller.dart\, which exposes streams for page changes, VM connection events, and device disconnects. Additionally, \screen.dart\ defines the metadata for all DevTools screens (including new entries like DTD Tools and updated tutorial links), and \screen\_controllers.dart\ introduces a \ScreenControllers\ manager that handles lazy initialization, registration, and disposal of screen-specific controllers for both live and offline modes.

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

The memory analysis subsystem now uses a new set of shared data models and utilities located in \packages/devtools\_app/lib/src/shared/memory\. This includes \HeapData\ for managing snapshot calculations, \HeapClassName\ for class identification and filtering, \ObjectSet\/\ObjectSetStats\ for statistical size information, and \GCStats\ for garbage collection metrics. The diff also introduces \HeapGraphLoader\ variants for loading snapshots from runtime, files, or direct graph instances, and implements \PathFromRoot\ for representing retaining paths. These components provide the foundational data structures and loading logic for the memory screen's heap analysis features.

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

The Performance screen now displays specific instructions for web apps (both Flutter and Dart) instead of attempting to connect to a VM service, and it detects and displays whether the connected Flutter app is using the Impeller rendering engine. Additionally, the screen now persists the selected feature tab when exporting and loading offline performance data, ensuring users return to the same view they were analyzing.

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

The devtools app now includes concrete, platform-specific implementations for drag-and-drop file importing and host platform detection. On the web, drag-and-drop is fully implemented to handle JSON file imports (including validation and error notifications) via the \package:web\ library, while the desktop implementation remains a stub. Additionally, host platform detection (specifically macOS identification) is now implemented using native APIs on desktop and user-agent parsing on the web, replacing previous generic or missing logic.

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

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

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

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

The Provider screen in the DevTools app no longer displays performance data; instead, it shows a message informing users that the feature has been moved to a standalone DevTools extension. Users are instructed to upgrade their package:provider dependency to the latest version and re-open DevTools to access the tool.

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

The DevTools application shell has been refactored to provide a more structured and responsive user interface. The new scaffold introduces a tabbed app bar that intelligently handles overflow via a dedicated overflow button when screen tabs exceed available width. A new bottom pane widget has been added to host tabbed views such as the console and AI Assistant. The settings dialog now includes controls for dark mode, analytics, advanced developer mode, and a WebAssembly performance experiment, along with verbose logging tools. The about dialog has been updated to display the DevTools version, provide direct links to release notes, the contributing guide, and Discord, and includes a dedicated button to view open-source licenses. Additionally, the status line now dynamically highlights when connected to an app and supports video tutorial links for specific screens.

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

The CPU Profiler controls pane has been reorganized into two new, dedicated widget files: \cpu\_profiler\_controls.dart\ and \profiler\_screen\_controls.dart\. This change extracts the user tag filtering and view mode dropdowns into a \UserTagDropdown\ and \ModeDropdown\ widget, and consolidates the primary recording/clear actions and secondary refresh/export actions into \ProfilerScreenControls\. This improves code modularity and maintainability for the profiler's control UI without altering the visible behavior for users.

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

The DevTools app now uses a new set of managers in the shared layer to handle user-facing messages and state. Banner messages are now managed by BannerMessagesController, which supports universal and screen-specific banners and automatically dismisses messages on connection changes. Error badges are tracked by ErrorBadgeManager, which provides a generic counter for screens like Inspector, Performance, Network, and Logging, while allowing specific screens to manage their own unread states. Notifications are handled by NotificationService, which supports dismissible messages, error reporting actions, and duplicate suppression. Additionally, DTDManager extensions now centralize analytics consent and telemetry interactions, and ScriptManager improves script caching and retrieval.

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

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\ (visual key for traces), and \MemoryChart\ (the chart rendering wrapper). This change improves code modularity and maintainability of the memory profiling view without altering the visible features.

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

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

The memory pane's charting logic has been restructured by extracting platform-specific controllers into dedicated files: \android\_chart\_controller.dart\ for Android memory traces (stack, Java heap, native heap, etc.), \vm\_chart\_controller.dart\ for VM memory metrics (used, capacity, RSS, raster cache), and \event\_chart\_controller.dart\ for event visualization (GCs, snapshots, extensions). This change improves code organization and maintainability by separating concerns for each platform's memory data visualization within the memory pane's chart controller layer.

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

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

The shared table implementation in \packages/devtools\_app/lib/src/shared/table\ has been rewritten to use a controller-based architecture for better state management. This introduces \FlatTable\ and \TreeTable\ widgets that rely on \FlatTableController\ and \TreeTableController\ to handle data, sorting, and UI state. The new design adds support for column pinning (\FlatTablePinBehavior\), configurable column sizing (fit-to-content vs. fit-to-view), and search integration via \SearchableFlatTable\. It also includes new data structures like \ColumnData\ and \ColumnGroup\ to define column behavior, headers, and grouping, replacing the previous monolithic \DevToolsTable\ implementation.

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

The DevTools app now supports embedding specific screens (such as the Property Editor and Editor Sidebar) directly in IDEs via standalone routes. These screens automatically manage their connection to the Dart Tooling Daemon (DTD), displaying a progress indicator while connecting and a 'Retry' button if the connection fails, ensuring a seamless experience when the connection drops.

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

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

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

The VM Tools screen in DevTools has been restructured into a tabbed layout using a NavigationRail and IndexedStack, allowing users to switch between VM Statistics, Isolate Statistics, Object Inspector, Process Memory, and a new Queued Microtasks tab (which appears only if the --profile-microtasks VM flag is enabled). This change also introduces a dedicated screen controller (VMDeveloperToolsController) to manage the active tab selection and the Object Inspector view lifecycle, and adds support for inspecting internal VM types such as ICData, ObjectPool, SubtypeTestCache, and WeakArray via new private extensions on vm\_service types.

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

Adds platform-specific utilities to resolve an issue where text fields retain focus when DevTools is embedded in an IFRAME. On web, a blur listener is now attached to the window to detect when the view loses focus and explicitly blur active elements within the Flutter view; desktop platforms receive a no-op implementation. This ensures that input fields do not remain focused when the user navigates away or switches context in the host application.

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

The macOS build workspace configuration has been restored by adding the \contents.xcworkspacedata\ and \IDEWorkspaceChecks.plist\ files. This ensures that the Xcode workspace is correctly recognized and configured for building the application on macOS, resolving issues where the workspace structure was missing or incomplete.

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

Add DevTools web benchmark test infrastructure; Add benchmark automation for CPU Profiler and Performance screens; Added CPU profiler test fixtures; Added Perfetto timeline test data for performance testing; Added app size analysis test fixtures; Added benchmark and webdriver tests for DevTools performance, size, and compiler selection; Added comprehensive test coverage for the CPU Profiler screen and its components; Added debugger test data for VM service object trees; Added fixture source files for debugger and autocomplete integration 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 offline memory data and Perfetto trace viewer; Added live-connection integration tests for DevTools screens and features; Added macOS Runner test scaffold; Added memory\_app test fixture for DevTools integration tests; Added networking test fixture app; Added offline memory screen test data; Added simulated editor for testing editor service interactions; Added syntax highlighting test data for Dart language features; Added test fixture applications for console output and debugging scenarios; Added test fixture for debugger panel integration tests; 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 application scenes; Added test infrastructure for memory heap snapshot analysis; Added test infrastructure for platform-aware golden file matching; Added test infrastructure for standalone editor and property editor sidebars; Added test infrastructure scene for Performance page; Added test infrastructure scene for the CPU Profiler default state; 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 DTD Tools screen components; Added tests for Deep Links screen and settings models; Added tests for DevTools extension analytics, screen, service, and settings; Added tests for DevTools framework components; 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; 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 Network screen HAR data, controller logic, and hot restart behavior; Added tests for Perfetto tracing model and timeline event processing; Added tests for Property Editor and DartDoc utility components; Added tests for TestFileArgs parsing logic; Added tests for VM Developer object inspector components; Added tests for VS Code sidebar debug sessions and DevTools options; Added tests for analytics consent prompt and stack trace optimization; Added tests for banner messages, error badge management, 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 memory chart and settings dialog; Added tests for memory diff pane and heap analysis logic; Added tests for network request curl command generation; Added tests for performance controls UI; 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 Memory screen controller and screen UI; Added unit and widget tests for memory tracing components; Added unit and widget tests for the Logging screen; Added unit tests for CPU flame chart and treemap chart components; Added unit tests for DevTools app framework components; 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 unit tests for diagnostics node handling and inspector service logic; Added unit tests for the shared FlatTable widget; Added widget tests for DevTools scaffold components; New test infrastructure for running DevTools against live Flutter apps.

The \devtools\_app\ package now requires the Dart SDK ^3.11.0 and Flutter ^3.41.0, reflecting a significant platform upgrade. Key dependency updates include \vm\_service\ to ^15.3.0, \dtd\ to ^4.0.0, \unified\_analytics\ to ^7.0.0, and \web\ to ^1.0.0, while \flutter\_lints\ is updated to ^6.0.0. The \devtools\_app\_shared\ package has also been updated to require Dart ^3.11.0 and Flutter ^3.41.0, with its \vm\_service\ constraint broadened to '\>=13.0.0 \<16.0.0'.

(dependencies) · high confidence

DevTools 2.61.0 release notes published; DevTools app version updated to 2.61.0-dev.0.

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

• First survey — no prior run to compare against. CAI 69.

• Code Health 100
• Architecture 97
• Maturity 64
• Readiness 60
• Security 80
• Domain Modelling 100

• 300 commits — 245 feature/other, 55 fixes

• packages/devtools_app — 175 commits
• (root) — 36 commits
• packages/devtools_shared — 19 commits
• .github/workflows — 15 commits
• packages/devtools_app_shared — 11 commits
• (repo) — 10 commits
• tool/lib — 9 commits
• .agents/skills — 8 commits
• tool/RELEASE_INSTRUCTIONS.md — 5 commits
• tool/bin — 4 commits
• packages/devtools_extensions — 3 commits
• tool/ci — 2 commits
• .agents/scripts — 1 commit
• .github/PULL_REQUEST_TEMPLATE.md — 1 commit
• packages/devtools_test — 1 commit

• fix: Add compiler=js escape hatch to revert to dart2js compilation (#9406)
• fix: Attempt to fix flaky tests caused by modifying the same test apps. (#9929)
• fix: Correct units and cumulative bug in GC times (#9890)
• fix: Fix "gclient sync" call in "dt serve" for Windows (#9976)
• fix: Fix CPU Profiler when "advanced developer mode" is enabled (#9528)
• fix: Fix Flutter frames chart freeze after switching screens (#9960)
• fix: Fix HoverCard tooltip clipping in the Flutter Inspector (#9823)
• fix: Fix Network tab not capturing requests after hot restart and clear (#9856)
• fix: Fix RenderFlex overflow in debugging controls at narrow widths (#9949)
• fix: Fix SplitPane RangeError when child count changes between rebuilds (#9822)
• fix: Fix ?compiler=js escape hatch for wasm-compiled DevTools (#9615)
• fix: Fix ?compiler=js escape hatch for wasm-compiled DevTools (#9615)
• fix: Fix debugger_panel integration test (#9647)
• fix: Fix dt serve command as part of the release process (#9603)
• fix: Fix a TODO to use String utilities and remove stale TODOs (#9695)
• fix: Fix a bug in the benchmark script and enhance CSV output (#9955)
• fix: Fix alignment of icons and links in DevTools footer (#9432)
• fix: Fix bad contrast for highlighted search results in tables (#9863)
• fix: Fix benchmark test failures erroneously passing on CI (#9403)
• fix: Fix benchmark test failures erroneously passing on CI (again) (#9469)
• …and 280 more

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

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.