Documentation

Add Morphic to a Flutter desktop project, initialize the native runner, and run. Three commands and you have a multi-surface app.

1flutter pub add morphic2dart run morphic:init3flutter run -d windows

Then wrap your app with the runtime. A single entrypoint spawns and orchestrates every sovereign surface:

1import class="tok-str">'package:morphic/morphic.dart';2 3void main() {4  class=class="tok-str">"tok-cmt">// One entrypoint. The runtime spawns and5  class=class="tok-str">"tok-cmt">// orchestrates every sovereign surface.6  runMorphicApp(app: MyApp());7}

Morphic introduces a small set of primitives that compose into a full runtime:

Surface

A real native window backed by its own Flutter engine.

Kind

The role of a surface — workspace, inspector, palette, overlay — which drives native shell behavior.

Ownership

Owner chains keep panels raising, minimizing and traveling with their host.

Group / Dock

Surfaces that converge form a group; rigid co-movement follows.

Extraction

A grouped surface can detach mid-interaction into its own session.

Orchestration

A deterministic semantic runtime governs z-order and activation.

The authoring surface is intentionally small. You declare what surfaces exist and what they render; the runtime handles the rest.

1class=class="tok-str">"tok-cmt">// Declare a surface with a kind + content.2runMorphicApp(3  app: MyApp(),4  surfaces: [5    SurfaceSpec(6      kind: SurfaceKind.workspace,7      content: () => EditorScreen(),8    ),9    SurfaceSpec(10      kind: SurfaceKind.inspector,11      content: () => InspectorPanel(),12    ),13  ],14);

Surfaces communicate through a shared app bus, so panels stay in sync while remaining isolated, independently-rendered windows.

Morphic wraps your existing Flutter app — it doesn't replace it. Add the dependency, run the initializer, and adopt surfaces incrementally.

1dependencies:2  morphic: ^0.2.0

dart run morphic:init wires the native multi-surface runner into your windows/ directory. Your widget tree is untouched.

The runtime is layered as a series of clean, swappable boundaries — each stage transforms intent into pixels on screen: