Dev Loop & DevTools

Hot reload injects changed Dart code and rebuilds widgets while keeping state; hot restart reloads the code and reruns main(), losing state; a full restart rebuilds native code too and is needed after Kotlin, Swift or plugin changes.

Turn on Select Widget Mode in the DevTools Flutter inspector and tap the element in the running debug app; the inspector selects that widget, scrolls the widget tree to it, and shows its size, constraints and properties in the Widget Explorer.

print() writes each message straight to the console. debugPrint() is Flutter's throttled wrapper: it queues lines and releases about 12 KB of text, then pauses a second, so Android does not drop log lines. Both still print in release builds.

Debug builds run JIT-compiled code with assertions and debug-only work on every frame, so their timings are unrepresentative and unevenly distorted. Reproduce the jank with flutter run --profile on a physical device, then measure and optimize there.

FlutterError.onError receives errors the framework catches inside its own callbacks: build, layout, paint, gesture handlers. PlatformDispatcher.instance.onError receives uncaught errors with no Flutter callback on the stack, such as a failed await in an async onPressed. Reporting needs both.

Hot reload swaps in new code but only reruns build methods. main() and existing initState() calls already ran, and global and static fields keep their stored values as state, so those edits need a hot restart, a const field or a getter.

They leak when something longer-lived still reaches them: a subscription on a service's stream, a listener added to a global ChangeNotifier, a running AnimationController's ticker or a periodic Timer. Their callbacks capture the State, so the closed screen's State and subtree stay alive.

The red screen is an ErrorWidget built in place of a widget whose build threw. Debug builds show the exception in yellow on red; profile and release builds, with asserts off, show a plain grey box with no text.

Profile Memory lists current allocation by class; Diff Snapshots compares heap snapshots taken before and after an interaction to show which classes grew and what retains them; Trace Instances records the call stacks that allocate the classes you select.

They are const booleans from package:flutter/foundation.dart telling which mode the app was compiled in, so gated code is removed elsewhere. Prefer kDebugMode for debug-only code and assert for invariants; asserts run only in debug.

FlutterError.onError defaults to presentError, which prints the error and is the hook the IDE's structured error view replaces. A custom handler that skips presentError loses that output. FlutterErrorDetails carries the exception, stack, library, context, an information collector and a silent flag.

Hot reload rejects turning an enum into a class or back and changing a class's generic type parameters, so hot restart. It cannot see native Kotlin or Swift edits or new platform plugins, which need a full restart, and it waits for compile errors to be fixed.

debugDumpApp() prints the widget-level tree from the root element, with dirty flags, dependencies and state; debugDumpRenderTree() prints each render tree with constraints, sizes and parent data. Use the first for what was built, the second for why something has its size.

debugPaintSizeEnabled, a top-level bool in package:flutter/rendering.dart that defaults to false, makes every RenderBox paint its bounds, with padding shaded and alignment offsets drawn as arrows. Set it before runApp, press p in flutter run, or use the inspector's Show guidelines.

Selecting a Row, Column or Flex, or a direct child, shows the flex explorer: axes, alignments, flex factors and constraints, with overflow in yellow-and-black tape. Edits to alignment or flex apply live, never touch source and revert on hot reload.

Click the line-number gutter in the DevTools Debugger or your IDE to set a breakpoint, then read the call stack and variables and step in, over or out. dart:developer's debugger(when: condition) is a code-level breakpoint that pauses only when true.

log() from dart:developer emits a structured event with a name, a severity level (0-2000, default 0) and an optional error and stack trace, sent to attached tools. The DevTools Logging view lists and filters these events.

The Dart VM service is the tooling protocol a debug or profile Flutter app exposes; flutter run prints its URL. Through it, the DevTools network view records HTTP, HTTPS and WebSocket traffic from dart:io (dio included) and http_profile clients.

A BuildContext is the widget's Element, which reaches its State and subtree. A closure capturing it, handed to a longer-lived object, keeps that whole subtree alive. Read what you need first (final theme = Theme.of(context)) and capture that value, or unregister the closure in dispose.

Check what differs in release: the Android template declares INTERNET only in the debug and profile manifests, asserts and kDebugMode code are compiled out, service extensions are gone, and code is AOT-compiled. Reproducing in profile narrows which difference it is.

The grey box means the framework caught a build exception and sent it to FlutterError.onError, whose default only prints. Reporting wired only to uncaught errors never sees it; forward FlutterError.onError to the reporter, then fix the build.

Hot reload runs new code on state created by old code, so objects, statics and initState setup can be impossible combinations. Hot restart and reproduce from launch: if the bug is gone, it was a reload artefact; if it persists, it is real.

Turn on Show guidelines to see the padding, tap the gap in Select Widget Mode, enable Show implementation widgets to reveal the ListTile's internal Padding, then fix the value where it is owned: the tile, ListTileThemeData or an ancestor.

Log each call with a name and sequence number, pause on the second call with a conditional breakpoint or debugger(when:) and compare its call stack with the first, and count requests in the network view. Usually a listener was registered twice.

Snapshot at the chat list, open and close the chat N times, snapshot again and diff; classes growing by N, such as the chat State, are the leak. Their retaining path names the long-lived holder, typically an uncancelled subscription or listener. Fix it and re-diff.

leak_tracker watches instrumented disposables and reports not-disposed leaks (collected without dispose), plus experimental not-GCed and GCed-late leaks. Add leak_tracker_flutter_testing as a dev dependency and call LeakTesting.enable() in test/flutter_test_config.dart; testWidgets then fails the file on leaks.

Service extensions are named hooks the app registers with the Dart VM service so DevTools and the flutter tool can query or toggle it. Debug registers all, profile keeps measurement ones such as the performance overlay, and release registers none.

Since Flutter 3.35 hot reload is on by default for web debug builds, alongside hot restart. It loads updated DDC-compiled JavaScript into the page instead of a Dart VM, keeps state, and does not apply to Wasm or release builds.

The Widget Previewer renders single widgets outside the app, in the IDE or a browser. Annotate a public top-level function, static method or no-argument constructor with @Preview; it runs on Flutter web, so native plugins, dart:io and dart:ffi calls fail.