The desktop, in public

For most of its life LeivOS has been something we looked at through a serial console. This week we put it somewhere other people can see it. We opened r/leivos and a Discord server, and our first post there is a set of screenshots of the desktop, taken on an HP Spectre laptop rather than in an emulator.

The short version from that post: the desktop is rendered entirely in software, the USB mouse works, the network runs over Wi-Fi with WPA3, and applications run on multiple threads. The Activity Monitor and the Calculator are fully working. The Terminal is, in our own words, heavily work in progress.

Here is a little more of what sits behind those screenshots.

Every pixel from the CPU

There is no GPU driver in LeivOS yet, and the desktop does not wait for one. The compositor draws everything itself: the wallpaper, the top bar, the dock, window frames, shadows and text. Shapes are filled with anti-aliasing from their outlines, and text comes from real TrueType fonts, rasterized and cached as glyphs.

Doing it all on the CPU means being careful about how much is drawn. The compositor keeps track of which parts of the screen changed, called damage rectangles, and redraws only those. Moving the mouse repaints the patch under the pointer, not the screen, and that keeps it smooth without hardware help. It also means that when GPU support arrives it can speed up a model that already works, rather than being the thing the desktop is built around.

A mouse, the hard way

On a modern laptop the mouse is a USB device, and “the mouse works” means the kernel talks to the USB controller (xHCI) directly: it brings the controller up, enumerates what is plugged in, and reads keyboard and mouse reports as they arrive. The same driver carries a USB stick’s bulk transfers, which is how LeivOS reads and writes the stick it boots from.

Wi-Fi, WPA3 included

Wi-Fi was the piece we most wanted in these screenshots, because a laptop without it is a desk ornament. The laptop’s Intel wireless card is driven by an ordinary program, not by kernel code. That program loads the card’s firmware, scans, and joins the network. Joining a WPA3 network means SAE, the handshake built on elliptic-curve cryptography that replaced the older password exchange. That is implemented too, along with the 4-way handshake that follows it.

On top of the link runs our own TCP/IP stack: DHCP, DNS, sockets for applications, and TLS 1.3 for fetching pages over HTTPS. It is the same stack whether the frames go to a virtual network card in QEMU or through the Wi-Fi card on real hardware. That is a large part of why it works on the laptop at all: most of it was already tested before the radio came into the picture.

Applications with threads

The applications in the screenshots are built on the LeivOS toolkit, and several of them do their work on threads: the Activity Monitor samples processes, CPU time and memory once a second while its window stays responsive. Under it the kernel offers threads, futexes and event handles. The Tape language, which LeivOS is written in, maps its own thread declarations and worker pools straight onto those kernel threads.

That last point matters to us. Applications for LeivOS are written in the same language as the kernel, and they can be developed and run on Windows or macOS before they ever touch LeivOS. The Calculator in the screenshots is the same program on all three.

What is still rough

Plenty. The Terminal can fetch a page, ping a host, list and write files, and scan and join Wi-Fi networks, but it is a long way from a shell you would want to live in. There is no hardware acceleration, no audio, and only a handful of applications. The kernel still keeps itself simple in places where it will need to grow up; spreading threads across every core of the laptop is the work in front of us now.

But it boots on a real laptop, joins a real network and draws a real desktop, and it is the first time we have been comfortable showing that to anyone outside the team.

What the community said

The response to the screenshots was warmer than we expected. Most of it was about the look of the desktop: people called it clean, and some said they would take inspiration from it for their own hobby projects. That is our favourite kind of compliment. The look of LeivOS was designed before the code was written. Every window, widget and shadow started as a mockup, and the toolkit is built to draw those designs faithfully. Seeing other developers want to borrow from it is the best sign that the effort shows.

The community also appreciated that we are open about using AI. We use it heavily in building LeivOS and Tape, and we say so. It writes a lot of code, tests and boilerplate quickly. What it does not do is decide what the system is: the architecture, the constraints, the design and the responsibility for what ships are ours. Being plain about that seems to matter to people, and it matters to us too. The fairest way to judge LeivOS is by what it does on a real machine, and that is exactly what the screenshots are for.

Thank you to everyone who took the time to comment.

Come and talk to us

If you are curious about any of this, how the compositor decides what to redraw, what it took to get SAE working, or why the kernel is written in its own language, ask us. r/leivos is where we will post progress and screenshots, and the Discord server is the place to talk with the people building it. We would rather answer a hard question than a polite one.