How we built the Lisa desktop, and why
The Lisa desktop is three programs: a compositor that owns the screen, an Embedder that runs Flutter, and the Shell that draws everything shared. Everything you see is Dart, end to end. There is no GTK anywhere on the path from the person to the pixel.
It did not start that way. This post covers how we got here, and why each piece is the way it is.
Where we started
In August, Lisa’s desktop was built on GNOME: GTK components driven from JavaScript, with a growing catalogue of components and green pipelines. We had already asked whether to replace all of it with Flutter, and the first answer was not yet. Flutter gives you a UI framework, but no compositor, no session, no input methods and no accessibility stack. GNOME gave us all of those.
What we did keep from that first answer was an escape hatch. Our component dialect, its golden tests and the interface guidelines were written so that they never touched GTK directly. The exit test was simple: could a second backend mount the same catalogue?
It could. Once the M1 iMac ran Fedora and passed the platform contract, the question changed from can we leave GNOME to what would we have to own if we did. The answer was three things, and we decided to own all three.
The compositor: one process owns the display
The compositor is Rust, derived from Smithay. It holds the display, composites every surface, and reaches the rest of the system over the bus like any other daemon.
We wrote our own instead of using an existing one because of what we wanted it to guarantee. Every window stacks in one list of layers: desktop, documents, utilities, dialogs, summoned surfaces, consent. One window has keyboard focus, and focus moves only because the person acted, never because a window appeared. A window declares a role, and the compositor applies that role’s rules and refuses parameters the role does not define. On a stock desktop, none of that is a promise; here, all of it is.
Glass is part of that list. The frosted material behind the menu bar, the Dock and the sidebars is computed by the compositor, per declared region, from what is actually below the surface. An application asks for glass; it never fakes it by blurring a screenshot of itself. That keeps glass consistent across every application, and impossible to spoof.
The machine decides how it draws once. At seat start, the compositor picks hardware Vulkan, else hardware GL, else software, and every renderer follows that one answer. An earlier page said Vulkan only. That would have pushed the older Macs we want Lisa to keep running on onto a software renderer. So we changed the rule instead of the hardware list.
The Embedder: hosting Flutter ourselves
Flutter’s own Linux support runs inside GTK. We wanted none of that, so Lisa
hosts the engine itself through lisa-embedder. It is a private fork of a
mature, GTK-free embedded-Linux embedder, with Wayland and DRM back ends, in
C++, because the engine’s embedding API is a C interface.
We changed embedders once. We began on one lineage and moved, in
mid-September, to the one that Lisa ships today. We gave it a single name:
the Embedder, process lisa-embedder, bus name dev.lisaos.Embedder. Then
we removed the old tree in the same release that switched. Carrying two hosts
“just in case” is how a project ends up maintaining both forever.
The engine itself is built once per SDK pin, in release mode, by automation: never by hand, never on someone’s laptop. It is consumed as a pinned binary, with its digest recorded.
The Shell: not an application
The Shell is the one resident process that draws everything shared: the menu bar, the Dock, notifications, the window switcher, and Beacon, which finds applications, files and settings as you type. It starts at login, lives until logout, and nothing opens or quits it. It renders what applications publish, like their menus, and never lets one draw into it.
The rule that decides where a thing lives is who opens and closes it:
| kind | opened and closed by | examples |
|---|---|---|
| core surface | the system, for the life of the session | the menu bar, the Dock, the desktop, notifications |
| summoned surface | a person’s key or gesture, and the same to leave | Beacon, the switcher, Screenshot |
| application | a person launches it and quits it | Files, Settings, Monitor |
That one rule settled arguments that would otherwise have come back every week. Is Beacon an app? No: a person summons it with a key and dismisses it the same way, so it belongs to the Shell. Does it get a Dock tile? No, because nobody launches it.
One contract for every seam
Three languages meet at the bus. The dev.lisaos.* interfaces between the
Rust daemons and the Dart applications used to be written twice, once on each
side, with nothing but review to keep them in agreement. Now one contract
generates both sides, and the documentation pages with them. If the
compositor and the Shell disagree about a message, the build fails before
anyone sees it on a screen.
The applications get the same treatment. Each of Lisa’s fourteen frameworks is its own package, and an application imports only their public packs. The system’s own applications live by the same rule as everyone else’s. Settings cannot reach into a private corner that a third-party app could not.
Fedora underneath, unchanged
Below the desktop, Lisa does not pretend. The base is a Fedora system on real hardware that meets a written platform contract. logind, NetworkManager, BlueZ and PipeWire are used as they are and are not renamed. Lisa’s part is the layer above them: its own daemons, the compositor, the Embedder, the frameworks and the desktop, shipped as one signed image that updates whole.
That line is deliberate. Everything above it is ours to get right. Everything below it is Fedora’s, and we would rather follow Fedora than fork it.
What is not done
The desktop runs every day on an Intel iMac and an M1 iMac. These are not finished yet:
- Logging in as yourself. The pieces for one person per session are built and reviewed: the installer asks for the first person, and the login window is written. The compositor’s side of handing the screen to that person’s session is not finished yet.
- Rounded glass everywhere. The compositor and the SDK carry the rounded shapes, and the Embedder side is waiting for its first build.
All of this is listed, page by page, at docs.lisaos.dev/gaps. The desktop is built the way the rest of Lisa is: written down first, tested against the page, proven on a real machine, and only then called done.
← All posts