Linux has entered an interesting phase.

For years, the traditional Linux desktop conversation was dominated by distributions: Ubuntu versus Fedora, Arch versus Debian, GNOME versus KDE. Then came the era of ricing, where the operating system became raw material and the user was expected to assemble the experience themselves.

Omarchy and Ryoku represent something different.

Both start from Arch Linux. Both build around Hyprland and Wayland. Both embrace keyboard-driven workflows, terminal-centric development, aggressive theming, and the idea that a Linux desktop can be beautiful without behaving like Windows or macOS.

But they approach the problem from different directions.

Omarchy is an opinionated operating system experience.

Ryoku is closer to a designed desktop system that happens to be distributed as an Arch-based operating system.

That distinction becomes particularly interesting when you look beneath the screenshots.

The End of the Blank Canvas

Traditional Arch Linux gives you an enormous amount of freedom.

That freedom is also the problem.

A fresh Arch installation doesn't tell you what your desktop should be. You choose the compositor, bar, launcher, notification system, terminal, editor, fonts, themes, keybindings, scripts and applications.

The result can be extraordinarily personal.

It can also take days.

The modern generation of Arch-based desktops is essentially asking:

What if the computer already had an opinion?

Omarchy answers that question with an omakase philosophy: the system chooses a coherent collection of tools and defaults so the user can immediately start working. Its current architecture combines Arch, Hyprland and Quickshell, with applications such as Neovim, Chromium, Obsidian, LibreOffice, Kdenlive and OBS Studio included in the broader environment. (Omarchy)

Ryoku is pursuing a similar destination, but with a particularly strong emphasis on reproducibility and a single source of truth. Its project describes the repository itself as the system definition: the live machine is treated as a deployment target rather than the place where configuration is manually accumulated. (GitHub)

This is an important philosophical difference.

Omarchy asks:

"What if Arch came with a great desktop?"

Ryoku asks:

"What if the desktop itself were engineered as a product?"

The Common Foundation

Underneath their different personalities, the two projects have remarkable similarities.

Layer	Ryoku	Omarchy
Base	Arch Linux	Arch Linux
Compositor	Hyprland	Hyprland
Display protocol	Wayland	Wayland
Shell	Quickshell	Quickshell
Philosophy	Designed/reproducible desktop	Opinionated/curated desktop
Configuration	Repository-driven	Integrated system configuration
Primary interaction	Keyboard	Keyboard
Aesthetics	Highly designed	Highly designed
Target	Power users / enthusiasts	Developers / power users
Approach	Build the system as a coherent artifact	Build the experience around strong defaults

So this isn't really a battle between two completely different Linux technologies.

It is a battle between two interpretations of what a Linux distribution should become.

Omarchy: The Omakase Computer

The name gives away much of the philosophy.

Omakase means, roughly, I'll leave it to you.

Instead of presenting the user with a thousand decisions, Omarchy makes many of them on the user's behalf.

That extends beyond choosing packages.

It includes:

keyboard shortcuts
window management
application selection
visual themes
terminal configuration
editor configuration
system utilities
installation
recovery
hardware integration

The result is closer to a finished workstation than to a collection of packages.

And Omarchy has continued moving in that direction.

The Quattro release moved major pieces of the desktop into a unified Quickshell environment, replacing separate components such as Waybar, Walker, Mako, SwayOSD, hyprlock and other utilities with a more integrated shell architecture. (GitHub)

That matters because the traditional Linux desktop is highly modular.

Modularity is powerful.

But modularity also means that the user becomes the integration engineer.

Omarchy is effectively saying:

You shouldn't have to be the person maintaining the integration between fifteen independent desktop components.

Ryoku: The Desktop as an Engineered Object

Ryoku takes this concept even further in another direction.

Its architecture is explicitly built around the idea of one source of truth.

The project describes itself as a hand-built Arch distribution in which the desktop, installer and system definition live together in a repository, and machines are rebuilt from that definition. (GitHub)

This is a very software-engineering-oriented philosophy.

Think of the difference between:

My computer
    ↓
I customized it
    ↓
It works

and:

Repository
    ↓
System definition
    ↓
Deployment
    ↓
Computer

The second model is much closer to infrastructure-as-code.

Your machine isn't the artifact.

The repository is the artifact.

The machine is merely an instance of it.

That is a surprisingly profound shift for a desktop operating system.

Quickshell Changes the Game

Both projects are riding on an important development in the Linux desktop ecosystem: Quickshell.

Historically, a custom Wayland desktop could mean assembling:

Hyprland
    +
Waybar
    +
Walker
    +
Mako
    +
SwayOSD
    +
hyprlock
    +
custom scripts
    +
shell scripts

This works.

But it can also feel like building a car by connecting components from six different manufacturers.

Quickshell makes it possible to build much more of the interface as a coherent application-level shell.

Omarchy's Quattro architecture is an explicit example: the project moved the bar, launcher, menus, notifications, OSDs, control panels, lock screen and related functionality into a single long-running Quickshell environment. (GitHub)

Ryoku follows the same general direction, describing its bar, launcher, lock screen and capture functionality as components of its own shell rather than simply a pile of unrelated widgets. (Ryoku)

This is where the comparison becomes particularly interesting.

Both projects are effectively experimenting with a new Linux desktop stack:

                 APPLICATIONS
                       │
              ┌────────▼────────┐
              │     DESKTOP     │
              │    QUICKSHELL   │
              └────────┬────────┘
                       │
                  HYPRLAND
                       │
                    WAYLAND
                       │
                   LINUX
                       │
                     ARCH

The traditional Linux desktop often feels like the layers were discovered independently.

These systems are attempting to make the layers feel designed together.

Beauty Is Not Decoration

One of the easiest ways to misunderstand Omarchy or Ryoku is to describe them as "pretty Arch."

That misses the interesting part.

The aesthetics are functional.

Omarchy explicitly treats visual coherence as part of the computing experience. Its documentation describes the system as deliberately designed around aesthetics and productivity, with themes capable of propagating across the environment. (Omarchy)

Ryoku pushes a similar idea, with a visual system built around coordinated shell components and dynamic theming. Its current site emphasizes wallpaper-driven theming and multiple visual identities while retaining the same underlying desktop architecture. (Ryoku)

This matters because visual consistency reduces cognitive friction.

If your terminal, editor, launcher, notifications, lock screen and window manager all appear to belong to the same system, the computer feels less like a bag of programs.

It starts to feel like a product.

And Linux has historically been unusually bad at this.

Not because Linux cannot look good.

Because Linux has traditionally celebrated the fact that nothing has to agree with anything else.

Configuration vs. Control

This produces one of the most interesting differences between the philosophies.

The classic Linux power-user mentality says:

"If you don't like it, edit the configuration."

The newer approach says:

"You shouldn't need to edit configuration files for everything."

Ryoku explicitly emphasizes changing the desktop through the system itself rather than requiring users to manually edit files for every adjustment. (Ryoku)

That's a subtle but important evolution.

The ultimate Linux power user may not actually want more configuration.

They may want more control with less configuration.

Those are not the same thing.

The Agent Question

There is another reason projects like these are appearing now.

AI coding agents change the economics of customization.

Historically:

Customization
      ↓
Learn configuration language
      ↓
Research documentation
      ↓
Write scripts
      ↓
Debug
      ↓
Maintain

With an agent:

"I want the launcher to behave like this."
              ↓
             Agent
              ↓
       configuration/code
              ↓
          deployment

Omarchy has explicitly positioned itself around the idea of an operating system for the age of agents, including integrated tooling and an increasingly agent-aware workflow. (Omarchy Guide)

That suggests an interesting future.

The operating system may become less like a static product and more like a programmable environment.

The user specifies intent.

The agent modifies the environment.

The system validates and deploys the modification.

Ryoku's repository-oriented architecture is particularly compatible with this model because the desired state already has a natural home: the source repository.

Reproducibility Becomes More Important

This is where Ryoku's philosophy becomes especially interesting for software engineers.

Imagine spending six months customizing a Linux workstation.

Eventually you have:

~/.config/hypr/
~/.config/waybar/
~/.config/nvim/
~/.config/kitty/
~/scripts/
~/bin/
some-system-service.conf
another-system-service.conf
one mysterious script

Everything works.

You have no idea why.

Then the SSD dies.

The traditional Linux response is:

"Time to rice it again."

The infrastructure-oriented response is:

"Clone the repository."

That distinction is enormous.

The latter treats a desktop as something that should be reconstructible.

This is one of the strongest ideas in Ryoku's design.

But Omarchy Has a Different Strength

Omarchy's advantage is conceptual simplicity.

You don't necessarily need to think about your desktop as infrastructure.

You install it.

You get a coherent environment.

You learn the shortcuts.

You work.

Its current installation experience is explicitly designed around getting from ISO to functioning desktop very quickly, with the project advertising installations that can take well under two minutes on many machines. (Omarchy)

That's a very different user experience from traditional Arch.

And it is arguably the point.

The distribution is supposed to disappear.

Your work should become the foreground.

Ryoku vs. Omarchy Is Really a Philosophical Comparison

The superficial comparison is:

Which one looks better?

That's almost irrelevant.

The deeper comparison is:

Omarchy

Linux
  ↓
Arch
  ↓
Hyprland
  ↓
Curated system
  ↓
Opinionated experience
  ↓
User

Ryoku

Linux
  ↓
Arch
  ↓
Hyprland
  ↓
Engineered desktop system
  ↓
Repository / source of truth
  ↓
Deployment
  ↓
User

Omarchy is emphasizing the experience.

Ryoku is emphasizing the system behind the experience.

The Interesting Convergence

Despite their differences, both projects point toward the same future.

The Linux desktop is moving away from:

"Here are the components. Assemble them yourself."

toward:

"Here is a complete computing environment. Change it when you want."

That sounds like a small distinction.

It isn't.

It represents a philosophical transition from Linux as a toolbox to Linux as a designed computing environment.

And that may be exactly what Linux needs as desktop computers increasingly become development machines, creative machines and AI-agent machines simultaneously.

The operating system doesn't necessarily need to hide its complexity.

It needs to manage that complexity for the user.

Which Philosophy Fits Which User?

There isn't a universal answer.

If you want an immediately coherent Arch-based workstation with strong defaults, integrated applications, keyboard-driven interaction and a deliberately opinionated workflow, Omarchy's model is centered around exactly that. (Omarchy)

If you are attracted to the idea of a desktop whose configuration is itself a reproducible software artifact, and you like the notion that the repository rather than the live machine represents the canonical system, Ryoku's architecture is particularly interesting. (GitHub)

And there is a third possibility.

You might simply steal the ideas.

That is perhaps the most Linux thing imaginable.

The Real Competition Isn't Ryoku vs. Omarchy

The more interesting competition is between the old Linux desktop model and the new one.

Old model:

Distribution
     ↓
Packages
     ↓
Components
     ↓
Configuration
     ↓
Scripts
     ↓
User integration

New model:

Distribution
     ↓
Desktop system
     ↓
Opinionated defaults
     ↓
Unified shell
     ↓
Reproducible configuration
     ↓
Agent-assisted customization
     ↓
User intent

Omarchy and Ryoku are two different experiments within that second model.

One emphasizes omakase.

The other emphasizes engineering and reproducibility.

Both reject the idea that a Linux desktop has to look like an unfinished construction site just because Linux gives you complete control.

And perhaps that is the most interesting thing happening in the Linux desktop right now:

Control is no longer synonymous with configuration.

The next generation of Linux desktops may finally prove that you can have both.

Ryoku · Omarchy

GigasBlade

Search This Blog

Ryoku vs. Omarchy: Two Visions of the Modern Arch Desktop