Omarchy: When Linux Stops Being Just an Operating System

It has been a while since I wrote something here.

Long enough that I almost feel I owe Zeda.in an explanation.

I didn’t really plan to stop writing. There wasn’t a particular day when I decided that I was going to take a break from the site. Life simply became busy, work changed, priorities moved around, and somewhere in between all of that, Zeda.in became quieter than I would have liked.

So, first of all, a small apology to anyone who was still checking in here.

And perhaps the nicest way I could think of coming back was to write about something that genuinely made me curious again.

Something I came across recently and kept thinking about even after I had closed the browser.

It’s called Omarchy.

If you spend any amount of time around Linux, you have probably heard the name by now. And if you haven’t, that’s perfectly fine. In fact, that might make this more interesting.

Because Omarchy isn’t just another Linux distribution that gives you a slightly different wallpaper, another package manager and a new collection of icons.

There is something different about the way it approaches the desktop.

And increasingly, it seems to be asking a question that I find much more interesting:

What should an operating system feel like when AI becomes part of the way we actually use a computer?

That’s a much bigger question than whether Linux is better than Windows or macOS.

And that is where Omarchy gets interesting.

So, what exactly is Omarchy?

Omarchy describes itself as a “beautiful, modern & opinionated Linux distribution by DHH.”

The DHH in that sentence is David Heinemeier Hansson, the Danish programmer and entrepreneur best known as the creator of Ruby on Rails and co-founder and CTO of 37signals, the company behind Basecamp and HEY.

If you’ve been around software development for a while, Rails is probably familiar territory. It became one of those technologies that didn’t merely provide another way of writing software; it influenced how developers thought about building web applications.

DHH’s approach has often been about reducing unnecessary complexity and making computers work for people rather than forcing people to constantly work around computers.

Omarchy feels like an extension of that philosophy into the Linux desktop.

It is built on Arch Linux and uses Hyprland as its compositor/window manager, but rather than handing you a relatively empty system and expecting you to spend days assembling your own desktop, Omarchy comes with a strong opinion about how the whole environment should work.

And I actually think the word “opinionated” is important here.

Linux has always been incredibly good at giving you choices.

Sometimes perhaps too good.

You can spend an afternoon choosing a desktop environment, a terminal, a shell, a launcher, a notification system, a status bar, a screenshot utility, a clipboard manager, a theme and another dozen things you didn’t know existed when you started.

There is something wonderfully geeky about that.

I’ve done it.

Many of us have.

But sometimes you don’t want to build the operating system.

You just want to use it.

That’s the space Omarchy is trying to occupy.

The interesting part isn’t actually Linux

This is where I think the conversation around Omarchy can become a little misleading.

Calling it an “AI operating system” sounds exciting, but it isn’t really accurate.

Omarchy is still Linux. More specifically, it is an Arch-based distribution with Hyprland and a highly integrated desktop environment.

What makes it unusual is what is being built on top of that foundation.

AI agents are no longer treated as some completely separate thing you open in a browser.

They are becoming part of the workstation itself.

The current Omarchy 4 release, known as Quattro, lets you choose a default coding agent from several options, including Claude Code, Codex, OpenCode, Pi, Gemini, Grok and GitHub Copilot, and gives you a keyboard shortcut to launch it. The agent is lazy-installed when you first use it and opens as its own application.

That sounds like a small convenience.

It isn’t.

Think about how we normally use AI today.

We open a browser.

We open ChatGPT or Claude or another tool.

We copy some code.

We paste an error.

We explain what happened.

Then we copy the answer back into our editor.

That workflow already feels surprisingly primitive.

The computer knows what happened.

The AI knows what happened.

The developer knows what happened.

And yet we’re still manually moving information between all three.

An agent running inside the development environment changes that relationship.

The AI can work with the repository.

It can understand the files.

It can inspect the terminal.

It can run commands.

It can investigate errors.

It can make changes.

And, importantly, it can do all of that while operating within the context of the project rather than having to be spoon-fed every piece of information.

That is a much more interesting form of AI assistance.

What happens when the operating system notices that something crashed?

This is probably the feature that caught my attention the most.

We have all seen applications crash.

Sometimes you get a useful error.

More often you get something that looks like the computer has suddenly decided to communicate with you in ancient Greek.

Logs.

Stack traces.

Core dumps.

System messages.

A wall of text that tells you that something went wrong without necessarily telling you why.

Omarchy’s newer workflow takes a rather different approach.

When a process crashes, the system can surface a notification offering AI diagnosis. Clicking it briefs the configured agent with information about the crash and gives it a dedicated diagnostic workflow.

Now, this is where I think the idea becomes genuinely clever.

The AI isn’t being asked:

“Why does Linux crash?”

It is being given information about an actual event that just happened on the machine.

That’s a huge difference.

The agent can work with the crash information, investigate the backtrace and reason about what might have caused the problem.

And the current Omarchy implementation goes even further: the crash-diagnosis workflow can, with the user’s agreement and after checking for duplicates, prepare the reporting of a confirmed Omarchy bug upstream.

That last part is particularly interesting.

Because now we’re not just talking about AI helping you understand your computer.

We’re talking about the computer helping you participate in the development of the operating system itself.

Imagine the old way

Something crashes.

You stare at it.

You search Google.

You search GitHub.

You find three issues that look vaguely similar.

You try to work out which logs the maintainer needs.

You copy them.

You write a description.

You upload screenshots.

You wonder whether somebody else has already reported it.

Eventually, you submit an issue.

And then you wait.

Omarchy’s direction is much closer to:

Something crashes.

The system notices.

You ask the AI to investigate.

It gathers the relevant information.

It checks whether the problem has already been reported.

It helps determine whether this is actually an Omarchy bug.

And, with your approval, it can help prepare the upstream report.

That’s not AI replacing the user.

That’s AI removing a lot of the boring work that prevents users from becoming useful contributors.

And that distinction matters enormously to me.

What about pull requests?

This is where I want to be a little careful because there is a tendency to oversell what AI agents can currently do.

Omarchy isn’t some magical operating system where every bug automatically turns into a perfect pull request while you sit back and drink coffee.

We’re not there.

But the building blocks are already here.

Modern coding agents can inspect repositories, modify files, run tests and prepare changes. Omarchy itself has project-specific instructions and agent-oriented documentation that help an AI understand how the project is structured and how changes should be approached. The repository includes files such as AGENTS.md and CLAUDE.md alongside its own AI development tooling.

And once you combine that with an operating system that can diagnose its own crashes and connect those problems to an agent, the natural workflow starts to look very different.

A user reports a problem.

An agent investigates it.

The agent proposes a fix.

The user reviews it.

Tests run.

A commit is created.

A pull request can be prepared.

And a human still decides whether that contribution should actually go upstream.

That’s the part I find exciting.

The AI doesn’t have to become the maintainer.

It just has to make it dramatically easier for ordinary users to become contributors.

Open source has always depended on people caring enough to report problems and fix them.

AI can potentially lower the cost of caring.

Quattro is much more than an AI update

There is another reason I think Omarchy deserves attention.

The latest major release, Omarchy 4 — or Quattro — is not simply a collection of AI integrations.

The desktop itself has been substantially reworked.

The entire shell has been rebuilt around Quickshell, bringing the bar, launcher, menus, notifications, on-screen displays, control panels, lock screen and authentication interface into a unified shell architecture.

That sounds like infrastructure work, but you notice the result in the everyday experience.

The launcher and menu are unified.

The bar is configurable.

Themes are deeply integrated.

Notifications have history.

There is a native clipboard manager.

There are control panels for things such as audio, Bluetooth, networking, display and power.

There is a plugin system.

There are visual theme and background switchers.

Even the desktop itself becomes more programmable.

And that’s important because an AI-friendly computer needs an environment that is itself reasonably coherent.

If every little part of the desktop is a completely separate project glued together with shell scripts and hope, it becomes harder for an agent to understand what is happening.

Omarchy is moving toward something much more unified.

Your AI usage becomes a system resource

Here’s another little feature that I really like.

Omarchy can show AI model usage information directly in the desktop, including usage statistics for tools such as Claude Code and Codex.

At first glance, that might seem like a gimmick.

But think about it.

For decades, our operating systems have shown us CPU usage.

Memory usage.

Disk usage.

Network usage.

Battery usage.

Now we’re starting to care about another resource:

AI usage.

How many tokens are we consuming?

Which model are we using?

How much of our available quota have we burned through?

That tells us something about the future of computing.

AI isn’t just an application anymore.

For some workflows, it is becoming a resource of the workstation.

And then there is the smaller stuff

One of the things I like about Omarchy is that it isn’t only trying to solve the grand philosophical problems.

There are plenty of little things that make the environment feel deliberately designed.

The new release has a unified command palette, native notification handling, clipboard history, emoji selection, media controls, configurable menu-bar placement, themes, plugins and even simple first-party applications such as Omawrite, Omacut and Omacalc.

There is also a much more interesting theme system where colours can propagate into applications such as Neovim, VS Code and btop rather than leaving you to manually configure each application.

Again, none of these things individually changes computing.

Together, they create something important:

coherence.

The machine starts to feel like one environment rather than a collection of applications.

And I’ve always believed that good technology is often about these small details.

But there is a price for being opinionated

Of course there is.

Omarchy is not going to be for everyone.

If you want a completely predictable, enterprise-style desktop where nothing changes unless someone has spent six months validating it, this probably isn’t where I’d start.

If you have a very specific workflow that depends on a particular desktop environment, you may find Omarchy restrictive.

And because it is based on Arch and embraces newer technologies, there will inevitably be situations where hardware or software doesn’t behave exactly as expected.

The project’s own GitHub issues make that very clear. There are real-world reports around hardware, NVIDIA systems, suspend/resume behaviour and other edge cases.

That’s the trade-off.

You get a much more modern and adventurous desktop.

But you also accept that you’re closer to the edge.

Personally, I don’t see that as a flaw.

I see it as part of the proposition.

Why I find Omarchy particularly interesting

Perhaps this is where the article stops being a Linux review and becomes a little more personal.

I’ve spent a large part of my professional life around technology, product management, fintech, payments and systems where software isn’t allowed to simply “sort of work.”

A payment authorization system has to work.

A settlement system has to work.

A card transaction can’t decide to hallucinate.

There are very real consequences when software gets things wrong.

And that makes the current AI evolution fascinating to me.

I’m not particularly interested in the idea of AI simply writing more code.

I’m interested in what happens when AI becomes part of the engineering system itself.

Can an AI investigate a production problem?

Can it understand a complicated architecture?

Can it reason about dependencies?

Can it propose a safe change?

Can another agent review it?

Can humans remain accountable?

And, perhaps most importantly, can we build all of this without sacrificing the reliability and trust that serious systems require?

Those are questions that matter enormously in fintech.

And they are exactly the sort of questions I expect to keep exploring here on Zeda.in.

Linux has always been about control

This is perhaps the biggest irony of Omarchy for me.

Linux has always represented control.

You can see what’s happening.

You can change things.

You can inspect the system.

You can replace components.

You can build your own environment.

AI, on the other hand, introduces delegation.

You tell the machine what you want.

The machine figures out how to get there.

Those ideas might initially sound contradictory.

I don’t think they are.

Maybe the future looks less like giving control away and more like delegating without surrendering control.

You tell the machine what you want.

The agent does the tedious work.

You inspect what it did.

You approve the important decisions.

And you remain responsible for the result.

That feels like a much healthier model for AI.

So, should you try Omarchy?

If you are perfectly happy with your current computer, probably don’t install it just because someone on the internet told you it’s cool.

But if you’re a developer, Linux enthusiast, tinkerer, technology obsessive, or simply someone who likes understanding where computing is heading, Omarchy is absolutely worth watching.

Maybe even worth installing on a spare machine.

The interesting thing isn’t that Omarchy has a pretty desktop.

It isn’t even that it has Hyprland.

It’s not the themes.

It’s not the keyboard shortcuts.

And it isn’t AI by itself.

It’s the combination.

A modern Linux foundation.

A deliberately designed desktop.

A strong developer environment.

AI agents that can actually interact with the workstation.

Crash diagnosis.

AI usage visibility.

A plugin architecture.

And an open-source project where the distance between “I found a bug” and “I helped fix the bug” is potentially becoming much shorter.

That is the experiment.

And I think it’s a pretty fascinating one.

Perhaps we’re finally asking the right question

For a long time, the operating-system conversation was mostly about interfaces.

Which desktop looks nicer?

Which one is faster?

Which one uses less memory?

Which one has better hardware support?

Those questions still matter.

But AI changes the conversation.

If an agent can see the filesystem, understand the project, execute commands, inspect logs, modify code and interact with the tools on your machine, then the operating system becomes more than a platform underneath your applications.

It becomes the environment in which human and machine intelligence work together.

And that is what makes Omarchy interesting to me.

It isn’t perfect.

It isn’t finished.

It isn’t going to replace Windows or macOS tomorrow.

And I don’t think it needs to.

It is an experiment.

A fairly ambitious one.

And perhaps the most interesting thing about experiments like this is that they give us a glimpse of something before we have a good name for it.

Maybe Omarchy isn’t the future of Linux.

Maybe it is simply one of the first interesting attempts at building a desktop for the AI-native computer.

Either way, I’m going to be watching.

And after being away from Zeda.in for a while, it feels good to have something genuinely interesting to write about again.

So, hello again.

I’m back.

And apparently, so is the signal.

Welcome back to Zeda.in.

DE VU2JDC

Technology. Fintech. Amateur Radio. Creativity. And things worth exploring.