Is This the Year of the Linux Desktop?

The manual for Omarchy, DHH’s opinionated Linux desktop, has one sentence set in capitals. Everything in Omarchy happens via the keyboard, it says, and then, in case the first everything read too quietly, once more with the caps lock on: “EVERYTHING!” A few lines later it warns that when the system first starts, “you literally can’t do a thing with the mouse alone.”

I installed it this week as a virtual machine on my Proxmox host, and I have been living in it through the Proxmox web console, which is a VNC client running inside a browser tab. So the arrangement, all week, has been a mouse in my hand, and in a browser window on my Mac, a desktop built on the premise that the mouse should not exist.

It does what the manual says. My week has gone into learning which key does what, and into the small shock of windows arriving already placed, with nothing to drag. It feels the way Linux has always felt to me: capable, and uninterested in whether I am comfortable. Nobody would call it user-friendly in the ordinary sense of the phrase.

Which sits oddly beside how the project describes itself. The site calls it agentic Linux, “the malleable OS for the age of agents.” A desktop that makes a human relearn how to open a window is being sold on its readiness for software that has never opened a window at all.

For a few days I held those two facts apart. Then I noticed they were the same fact.

The desktop was built for a body

The mouse is older than most people who use one. Douglas Engelbart showed it in 1968, moving a pointer around a screen in front of an audience that had never seen a computer respond to a hand. The desktop that grew around it at Xerox PARC, and reached the rest of us through the Macintosh in 1984, took the idea all the way: make the machine’s state visible as objects, and let the hand act on the objects directly.

Every piece of that design is a translation. A file becomes an icon because eyes recognize a picture faster than they parse a name, and the pointer exists because a hand pointing at a thing is older than language. The translation is why computers spread from the people who ran them to everyone else, and it fixed the meaning of a phrase we still use without hearing it. For forty years, user-friendly has meant body-friendly, because eyes and hands were what showed up at the desk.

An agent brings neither.

There are two ways to let one operate a computer today. The first gives it a body. A computer-use agent takes a screenshot, decides where a hand would click, and emits a pair of coordinates. Then another screenshot, to see what happened. Eyes made of a screenshot, a hand made of an x and a y. It works, at a price. Every step costs a picture, every picture costs thousands of tokens, and the model spends them hunting for a button that was drawn to be found by a retina. The second way is the one my coding agent has used all year. It lives in a terminal. It reads and writes files, and it runs commands. Text goes in and text comes out, and at no point does anything have to be drawn and then recognized.

The usual reply is that vision gets cheaper every quarter, so the screenshot loop is a temporary tax. I think the tax is structural. Everything a desktop draws was text before it was drawn: a directory listing became a folder, a process became a window. Handing that picture to a model asks it to reverse the drawing and recover the text it started from, a round trip through a body that is not there. Cheaper vision speeds up the round trip without giving it a reason to exist. When the Agent Browses for You made the point that a model has no separate channel for perceiving and deciding; language is all it has. A screenshot is language too, encoded at a terrible exchange rate. The agent is the first operator in the history of the machine that never needed the translation, and we are still handing it the translated version.

The keyboard is a body device too

Seen from here, Omarchy dropping the mouse looks like the fix. Take away the device only a body can use, and what remains is a machine both operators can share. Sort the desk by who can use each piece and the mouse does come out worst. It produces positions, a position means something only against a picture, so the only operator who can use a mouse is one already looking at a screen. The screen produces pixels for a retina, and an agent has no use for them without the same expensive translation run in reverse. The keyboard produces characters, and a character is the machine’s own unit; the shell receiving one cannot tell whether a finger sent it or a process did.

But my coding agent has never pressed Super and Return. It has never pressed anything. When it wants a terminal it has one already, and when it wants a file it writes the path. The hotkeys I spent the week learning are finger memory, a body trick, as much a prosthetic as the mouse was, only cheaper. So the thing the two operators share is narrower than the keyboard. It is the stream of characters the keyboard emits, and the commands that stream spells. The hotkey is the ramp a human takes to reach the stream; the agent is already standing in it.

That reading changes what Omarchy is. A desktop where everything happens on the keyboard is a desktop where every operation has a spelling, and a spelling can be produced by either operator. The manual’s other word, malleable, points the same way: every setting is a text file, so the door an agent would use to reconfigure the machine is the file I open to do it myself. Read this way, keyboard-everything is a human agreeing to type what the agent already types. The test travels beyond this one desktop. Take any action a piece of software lets you perform and ask whether it has a spelling; the answer is whether an agent can stand beside you and perform it too.

That is why the mouse goes first: it has no spelling.

Friendly to whom

User-friendly has always had a hidden referent, and for forty years the referent never changed: the user was the person at the desk. If an agent does more of the operating, that quietly stops being true. The entity issuing most of the commands to my machine, on a working day, is already software. The person at the desk is doing something else: saying what should happen, and then looking at the result. Once the operator changes, friendly changes with it, and a desktop optimized for the body of someone who has stopped operating starts to look like the wrong optimization, however lovingly it was made.

The evidence for that is a week long, and I should say what it covers. An agent has yet to touch this virtual machine, so the week gave me the human’s side of the arrangement only, and I am wary of how this kind of argument runs ahead of its evidence, because I have watched it do so in my own posts. The argument so far is about devices and who can use them. That much I can check by looking at my desk.

The week could not tell me where the friendliness goes. Omarchy still asks a lot of the person at the keyboard, and the manual says so: it is built for “a modern, savvy computer user.” The people the graphical desktop first let in, the ones who never wanted to learn a command, still need the body-friendly layer as much as they did in 1984, and a keyboard-only Linux does nothing for them. So if the desktop underneath is turning back into text, the layer that translates for a body has to go somewhere.

I think it is moving up. The translation between a person and a machine used to be drawn in pixels, a picture of a folder standing in for a directory. Increasingly it is spoken, to an agent, which then operates a machine that no longer needs to be drawn. The chat window is where that translation lives for now, and for many people it already beats learning a product, because a sentence asks nothing of the eyes and hands that an icon did. Behind the chat window, the actual desktop can go back to being made of text, and only the agent has to live there.

That layer of text is also where Linux already lives. Every server and every container an agent has ever run in is Linux. The desktop was the last place it had never won, and it kept losing there for thirty years because the desktop was where the body sat. The year of the Linux desktop has been one year away for as long as I have used computers. It may finally arrive for a user who was never a person.

Deciding replaces operating

If that is right, the order of building flips for anyone making software. The graphical era taught us to make the picture first, since the picture was the product a person met, and to call the product good when a person could learn it. An AI-native product starts one layer down, at the spellings: what can be asked of it in text, and what an agent could do with it without ever seeing it. The human layer goes on top afterwards, and it can be simpler than anything we have shipped so far, because the person no longer has to learn the product’s operations. The agent learns them, and the person is left holding a sentence.

The person’s side changes just as much. Until now, learning a product meant learning its operations, and expertise meant knowing the shortcuts. That expertise is about to depreciate, because the operations are leaving for the agent. The thing a person has to learn instead is the problem: what they actually want done, stated clearly enough to be carried out by something that will do exactly what was said. The learning curve turns around. You stop exploring the product and start exploring your own intent.

Two things get harder in exchange. Discoverability used to come free with the picture: a menu showed you what was possible before you knew to want it, and a text box shows you nothing. Software will have to learn to say what it can do, in conversation, the way a good colleague does, and almost nothing does this well yet. And mistakes change shape. A wrong click was undone with one key. A wrong decision, carried out completely and well, is undone only by someone reading what happened and deciding again. Reading grows as operating shrinks, and the judgment behind the reading carries more weight than the hands ever did.

Both are reasons the chat box is a beginning. This week I also listened to Ian Silber, who runs product design at OpenAI, argue that chatbots are not the final interface, and the history above says why he is right. A blank text box is this era’s command line: the agent’s native surface, leaked upward to people, and austere in the same way the terminal was before anyone built a desktop on top of it. We are in the late seventies of this, holding the powerful and unfriendly version, and the layer for the body has yet to be built.

I can see its shape only in outline. The picture comes back, drawn by the agent for a single decision and thrown away afterwards, a surface for a person to read rather than a surface for their hands to work. Decisions arrive instead of being typed: the agent brings the choice, with what it found and what it proposes, and the person picks or redirects. And pointing returns, in its older role. The mouse was built so a hand could point at things for the machine. A hand pointing at a thing for someone else is the oldest way of saying this one, and an agent that can see my screen turns the pointer back into that. The hand comes back to communicate rather than to operate.

So the interaction language itself is turning over, underneath the question of which operating system wins. For forty years, using a computer meant learning how to make it do things. It is becoming a matter of deciding what should be done, saying so clearly, and reading whether it was. Every skill in between is moving to the other operator.