# Starling Desktop

Starling is a Linux desktop session — compositor, window manager, Wayland and X11 servers, and a set of first-party apps — published at starling.build as v0.2.1, an early preview. The headline is "the first real desktop written by AI," directed by one person over six months. The desktop is worth taking seriously; the headline needs unpacking, because the page mixes things you can check against things you have to take on faith, and does not always mark the boundary.

## What the page demonstrates

The strongest claim, and the one the site correctly identifies as load-bearing, is that a desktop's job is to host software it did not write. Anything that only runs its own apps has skipped the hard part. Starling's answer is a screenshot of Zoom (an X11 client) and Chrome (a Wayland client) composited into one scene on one GPU path. It talks to DRM/KMS and owns the display, reads raw input devices, and is selectable at the GDM login screen as a session.

That is checkable in the strongest sense available: there is a 53 MB `.deb` for Ubuntu 26.04 amd64, installable with `apt install ./starling_0.2.1-1_amd64.deb`, and both repositories are public — `starling-build/starling` for the desktop and `starling-build/starling-engine` for the framework. Anyone with the hardware can install it and find out. The site says as much: "every number here is yours to check."

The line counts are stated with an unusual amount of self-deflation. Of 335K lines of first-party Swift, C and C++, about 273K is the Flutter-to-Swift framework port that everything else sits on. The desktop itself, its Wayland and X11 servers, and the bundled apps come to roughly 62K. The site volunteers this split rather than letting 335K stand alone, which matters, because a mechanical framework port and a compositor are different kinds of work and only one of them is the interesting claim. Vendored dependencies are excluded from both figures.

The feature list is specific enough to be falsified by anyone who installs it. Floating windows by default with a settings switch that flips the whole session to master-and-stack tiling and back, restoring every window to its previous floating position. Virtual desktops with a Mission Control overview on Ctrl+Up, where anything sent fullscreen becomes its own space. Per-display menu bars, wallpapers, spaces and scale factors, with windows able to straddle a monitor boundary at each screen's own scale, and windows returning home when a monitor is unplugged. Files, Terminal, Settings, Calculator, Text Editor, Image Viewer, and an App Store that installs from the Ubuntu archive, all written in the same framework as the shell. The per-space window handling is worth noting as a feature at all: on macOS it is something people pay for separately — [[toolbox/boringbar]] exists because the stock Dock shows every window from every Space.

Two implementation details are stated concretely enough to check against the source. The dock's glass is a fragment shader that gives each panel a thickness, derives a surface normal from it, and refracts the view ray through that normal with Snell's law, plus a Fresnel rim and a specular highlight; the site's evidence is that text behind the dock bends and compresses toward the rounded ends rather than merely blurring. And there is no interpreter in the session: the UI framework is compiled ahead of time and binds a stable C rendering core, client buffers are shared off the GPU via dmabuf without copying, and each app is its own process so a crash takes one window.

## What is asserted rather than shown

The authorship claim is the one thing the page offers no evidence for. "Written by AI, directed by one person, over six months" is presented as a fact about the process, and nothing on the landing page substantiates it — no commit provenance, no transcripts, no `Co-Authored-By` trail, no per-file breakdown of what was generated versus hand-written. The two public repositories make the *artifact* checkable and say nothing about the *process*. The ~2,000 commits and the six-month span are verifiable from git history; who or what wrote the diffs is not, which is precisely the gap [[a-voice-from-nowhere]] describes as the chain of accountability terminating in nothing while appearing to terminate in a person. Here the direction of the incentive is inverted — the claim is AI authorship, not human authorship — but the unverifiability is the same.

"The first real desktop written by AI" is an ordering claim about everything else in the world, and the page argues for it by describing three weaker categories (browser-tab desktops, mock-ups, from-scratch systems that only run their own apps) without naming any specific project that falls into them.

Several behaviours are asserted with a still image that cannot show them. "Unplug a monitor and its windows come home instead of vanishing" is illustrated by a photo of two monitors with a window across the boundary, which demonstrates the boundary case and not the hot-unplug. The same applies to "survives a monitor being unplugged" in the argument section.

The page's own version numbers disagree. The header says v0.2.1 on Ubuntu, the install block targets Ubuntu 26.04, and the hero screenshot's Settings panel reads "Starling OS, Version 0.1, Ubuntu 25.10" — so at least some of the imagery predates the release being offered. That is ordinary for a project moving this fast, but it does mean "every screenshot here is a running session" is a claim about *some* session, not the one you would install.

Testing breadth is stated honestly and is narrow: verified on AMD graphics under a fresh Ubuntu 26.04, with "expect rough edges, missing settings, and apps that still need work."

## The argument the page is actually making

The desktop is the premise; the conclusion is about cost. Building a Linux desktop has been institutional work for three decades, and GNOME and KDE are cited not as rivals but as the measure of what the job costs. The scarcity of desktops follows from that cost, and so does the difficulty of changing the ones that exist from outside. If one person can now reach this point in six months, the constraint was never imagination or taste; it was labour, and labour got cheap. The line the author cares about is the next one: "the interesting consequence isn't Starling. It's the ten desktops after it."

Two things that argument does not establish. It rests entirely on the authorship claim being true, since a desktop written conventionally by one unusually productive person supports a very different conclusion. And six months is not long enough to speak to the part that historically consumed the institutional effort — maintaining a desktop against a decade of toolkit churn, driver changes, and applications that misbehave in new ways. The compatibility surface Starling has taken on is the one [[win32-stable-abi]] describes as reliably unstable on Linux: hosting other people's binaries across years means absorbing every ABI break underneath you, and no amount of cheap labour at the start removes that.

The long-horizon question also has a measurement now. [[benchmarking-opus-5-slopcodebench]] is an attempt to score exactly what happens to a codebase when a model evolves it across successive rounds of undisclosed requirements, and the answer on a 17-checkpoint scale was that every tested model accumulated complexity and none finished a challenge clean. A 335K-line desktop is that experiment at a scale nobody has instrumented. What Starling would prove or disprove is not visible in a launch page; it is visible in the diff a year from now.

## Where it fits

The method — one person holding the design and directing agents across every layer of a system, reading a small fraction of the resulting code — is the one described in [[claude-is-not-a-compiler]] and named in [[vibe-engineering]]. Bleecher Snyder's version came with a validation ritual (present the system to colleagues, field arbitrary questions about it, go on vacation, count the incidents) that Starling's page has no equivalent of. [[control-the-ideas-not-the-code]] is the same posture argued as a general position. The site's one-sentence version, "a good idea, and AI to build it," is that argument compressed to the point where the interesting parts are missing. At the other end of the scale, [[toolbox/lightroom-cc-on-linux]] is the same method applied to one application — a Wine recipe that Claude debugged and patched unattended — small enough that nothing about it needs to be taken on faith.

## Cross-references

- [[claude-is-not-a-compiler]], [[vibe-engineering]], [[control-the-ideas-not-the-code]] — the direct-the-agents-across-layers method this is a large instance of
- [[benchmarking-opus-5-slopcodebench]] — the long-horizon quality question, with numbers
- [[a-voice-from-nowhere]] — why "written by AI" without a provenance trail is an unanswerable claim
- [[win32-stable-abi]] — the compatibility surface a desktop signs up to maintain
- [[credibility-as-slop-test]] — an artifact whose epistemic status rests on one person's word plus a public repo