Flutter Desktop Windowing API: Multi-Window Support Arrives in 2026

For years, Flutter desktop apps lived with a mobile limitation: they could only draw to a single window. Popups, tooltips, and dialogs were rendered as overlays on top of the main window—not as true native windows.

That changes in 2026. The Desktop Windowing API, a multi-year collaboration between Google and Canonical, brings true multi-window support to Flutter desktop applications.

Why This Matters

Flutter was released in 2018 for mobile, where single-window is natural—you don’t need multiple windows on a small screen. But desktop applications need to:

• Use screen real estate across large monitors
• Show native tooltips and popups that function correctly
• Support dockable toolboxes like in GIMP or Photoshop
• Display modal dialogs that block the parent window
• Create satellite windows that follow the main window

Multi-window support was the 6th most requested feature in Flutter’s GitHub issues. Now it’s here.

The Five Window Types

The API centers around five cross-platform window types, each with specific behavior:

1. Regular Windows

Standard application windows with toolbar, resizable, maximizable, and fullscreenable. Applications typically have one or more regular windows.

2. Popup Windows

Child windows for dropdown menus and autocomplete boxes. They can receive input focus (e.g., navigate a dropdown with arrow keys) and automatically stay visible on screen by translating or shrinking.

3. Tooltip Windows

Like popups but without input focus. Used for small, fleeting information like CVV explanations on credit card forms.

4. Dialog Windows

Child windows that prompt user action. Come in modal (blocks parent) and modeless varieties. Material’s showDialog now creates true native dialog windows on supported platforms.

5. Satellite Windows

Ancillary windows for toolboxes and helpers. They maintain position relative to their parent window and can be shared across multiple main windows. Often dockable—transitioning from floating to embedded.

Window Hierarchy

Windows form a shallow hierarchy. An application might have:

Regular Window (main app)
├── Popup (dropdown menu)
├── Dialog (confirmation)
│   └── Tooltip (info icon)
└── Satellite (tool palette)

The hierarchy should be shallow in practice, but no performance cost is incurred for deeper nesting.

API Usage

Creating a Window

final controller = WindowController(
  title: 'My Application',
  size: const Size(800, 600),
);

Creating a Dialog

final dialogController = DialogWindowController(
  title: 'My Dialog',
  size: const Size(400, 300),
  parent: parentController,
);

Rendering Content

Widget build(BuildContext context) {
  return Window(
    controller: controller,
    child: MyPage(),
  );
}

All windows share a single widget tree—state management with Riverpod or Bloc works out of the box across windows.

Listening to Events

class MyWindowDelegate with WindowControllerDelegate {
  @override
  void onWindowDestroyed() {
    super.onWindowDestroyed();
    ServicesBinding.instance.exitApplication(AppExitType.required);
  }
}

final controller = WindowController(
  title: 'My Application',
  size: const Size(800, 600),
  delegate: MyWindowDelegate(),
);

Accessing Window Scope

class MyWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final title = WindowScope.titleOf(context);
    // Rebuilds when title changes
    return Text(title);
  }
}

Hello Window Example

A complete, self-contained multi-window app:

import 'dart:ui';
import 'package:flutter/services.dart';
import 'package:flutter/src/widgets/_window.dart';
import 'package:flutter/widgets.dart';

class ExitOnCloseDelegate with WindowControllerDelegate {
  @override
  void onWindowCloseRequested(WindowController controller) {
    ServicesBinding.instance.exitApplication(AppExitType.required);
  }
}

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  runWidget(const HelloWindow());
}

class HelloWindow extends StatefulWidget {
  const HelloWindow({super.key});

  @override
  State<HelloWindow> createState() => _HelloWindowState();
}

class _HelloWindowState extends State<HelloWindow> {
  final WindowController _controller = WindowController(
    size: const Size(600, 400),
    title: 'MyApp',
    delegate: ExitOnCloseDelegate(),
  );

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Window(
      controller: _controller,
      child: const Directionality(
        textDirection: TextDirection.ltr,
        child: ColoredBox(
          color: Color(0xFFFFFFFF),
          child: Center(
            child: Text(
              'Hello, Window',
              style: TextStyle(color: Color(0xFF000000), fontSize: 24),
            ),
          ),
        ),
      ),
    );
  }
}

Note: This uses runWidget instead of runApp, because we provide our own Window view.

Enabling the API

The windowing API is on the Flutter main channel, behind an experimental feature flag:

flutter channel main
flutter upgrade
flutter config --enable-windowing

Design System Integration

Most developers won’t use the windowing API directly. It integrates under the hood into Material design:

• showDialog → true native dialog window
• showMenu → true native popup window
• Tooltip → true native tooltip window

When the windowing API is unavailable (e.g., mobile), it falls back to the existing overlay implementation.

Platform Support

Platform	Status
Linux	Full support (X11 and Wayland)
macOS	Tooltips, popups, dialogs
Windows	Tooltips, popups, dialogs

Canonical serves as the lead maintainer and Strategic Steward for Flutter Desktop, overseeing Linux, Windows, and macOS embedders.

What This Means for Flutter Desktop

1. Native feel — Dialogs, tooltips, and popups behave like platform-native windows
2. Multi-window apps — True support for complex desktop applications
3. Dockable interfaces — Tool palettes and sidebars that can float or embed
4. Cross-platform consistency — Same API, same behavior on all desktop platforms
5. Design system integration — Material widgets get native windowing for free

The Canonical Partnership

Canonical’s involvement is significant. They’ve spent two decades shipping Ubuntu Desktop with complex applications. Their research identified the five fundamental window types that should have first-class support.

Canonical is already using Flutter across mission-critical parts of their stack, including the Ubuntu Desktop Installer and App Center.

Conclusion

The Desktop Windowing API is the culmination of a multi-year effort to make Flutter a true desktop-first framework. With Canonical leading maintenance and Google providing design reviews, Flutter desktop apps can now compete with native applications on windowing capabilities.

The era of Flutter desktop apps feeling “like stretched mobile ports” is over. True multi-window support is here.

---

Sources:

• Introducing the Desktop Windowing API for Flutter
• What’s New in Flutter 3.44
• Flutter Desktop Canonical Partnership