Leenium: When a Theme Slowly Became Home

I've switched themes a lot. Probably more often than I ever really needed to.

Catppuccin, Tokyo Night, Night Owl, Dracula, and a whole bunch of others—some of which I genuinely like and still do. The problem was never that these themes were badly designed or had bad color palettes. In fact, some of them are designed far better than anything I could have come up with from scratch.

The problem was much simpler: none of them were exactly what I wanted.

One had a background that was a little too bright for me. Another leaned too far into gray. Some used colors that looked too similar after I'd been staring at code for a few hours. One distinguished functions from variables in a way I didn't like. Another was almost perfect, except for those two or three little things that, after a while, somehow became the only things I could see.

If it had only been a matter of taste, I probably would've done what I'd always done: find another theme and move on. But there was another factor involved for me: my eyes.

Because of severe astigmatism and keratoconus, reading text for long periods of time isn't always easy for me. It's especially noticeable when several similar colors sit next to each other and my eyes have to keep working to distinguish between them. What might look like a soft, harmonious palette to someone else can, after a few hours, turn into a collection of characters that takes actual effort for me to separate visually.

And I think that's roughly where the story of Leenium began.

Not with the decision that "I'm going to build and publish a theme." Not with the idea of creating a brand. Not even with the thought that one day my bootloader, Firefox, and YouTube would all be using the same colors.

I just wanted to open Neovim and have what I was looking at feel right for me.

There Wasn't Supposed to Be a Project

As far as I remember, it started with Neovim.

I'd been using different themes, and there was almost always something that felt slightly off. Maybe the background was good, but I didn't want functions to be that color. Maybe strings needed to stand out more. Comments were too close to the background. Keywords needed to catch my eye faster. Some colors looked beautiful on their own, but after staring at them for several hours, they didn't feel quite as beautiful anymore.

That's where I realized something I hadn't really thought much about before: a theme isn't just something that should look good in a screenshot.

A coding theme is something you're going to stare at for hours. You're going to use it while hunting down bugs, distinguishing functions from variables, mentally filtering out comments, spotting errors quickly, and trying to understand the structure of a file that's several hundred lines long.

So color isn't just decoration here. It's part of the interface between your eyes and the information in front of you.

That's why I started changing things. Not according to some sophisticated color science theory, and definitely not because I thought I knew what "the best palette for programming" was. I mostly worked from what I could see and what felt easier on my own eyes.

This needs to be darker.

These two need more separation.

I want functions to be recognizable at a glance.

This color disappears too much against this background.

This one starts bothering my eyes after a while.

Little by little, those small changes turned into something that no longer felt like I was adapting myself to somebody else's theme whenever I opened Neovim.

Everything was where I expected it to be.

And that was enough to get things started.

The Test That Wasn't Supposed to Be a Test

One day, after something like twelve or thirteen hours of coding, I noticed something.

I still wasn't tired of the theme.

That was unusual for me because, normally, after a few hours of continuous work, beyond just being tired in general, I'd reach a point where I simply didn't want to look at the editor anymore. My eyes would get tired, the colors would start feeling more irritating, and I'd instinctively want to get away from the screen.

But this time I realized I wasn't feeling that way.

I don't want to draw a medical conclusion from that experience or claim that Leenium is somehow going to solve anyone's eye problems. That wouldn't be scientific, and it's not something I could prove anyway. Maybe part of the experience was simply down to my own preferences, the amount of contrast I personally like, or any number of other factors.

But for me, it was an important confirmation.

What I'd built was working, at least for me.

And that naturally led to another question:

Well, if it works in Neovim, why should it only exist in Neovim?

And This Is Where Things Got Out of Hand

VS Code came next.

I brought the palette over, adjusted the syntax highlighting, matched the interface colors, and tried to recreate what I was seeing in Neovim as closely as VS Code would allow.

Then I remembered that I don't only use VS Code and Neovim.

What about OpenCode?

Well, I made a theme for that too.

Then at some point I was working with Git, and presumably the same defective part of my brain responsible for this entire situation said:

"Well... this could be Leenium too."

Then came Firefox.

Then Hyprland.

Then Omarchy.

And I think it was around the time I implemented Leenium across my Hyprland environment and built an Omarchy theme for it that it became obvious this wasn't going to remain just a color scheme for code editors.

Because now, when I left the editor, the theme didn't end with it.

The same visual language was still there.

If It's Going to Be Everywhere, It Might as Well Be Everywhere

At some point I started looking at the software I use every day and asking pretty much the same question about each one:

"Can this be Leenium too?"

Dangerously often, the answer was "yes."

I changed the CSS on my self-hosted mail server so its interface would match Leenium. Then I moved on to Jellyfin, another service I host myself. And if I control the CSS anyway, why should it look like it belongs to a completely different world?

Then Stylus entered the picture, and that's when the door really opened.

Once you can override the CSS of websites you use every day, your theme is suddenly no longer limited to applications that officially support custom themes.

YouTube can be Leenium.

ChatGPT can be Leenium.

The search engines I use can be Leenium.

The websites I spend hours inside can become part of the same environment as the rest of my system.

Even Firefox itself went beyond being some personal CSS sitting on my machine—I published the theme. A few friends later asked me to make a Chrome version too, and my reaction was basically:

No.

No, no, no.

We're good right here.

Aside from having to pay for a Chrome developer account, I simply wasn't interested in going down that road for a browser I don't even like using. Leenium was never supposed to become a project that had to exist on every possible platform at any cost.

The original idea was still the same: things I actually use myself.

Even Before the Desktop

The funny part is that eventually this whole thing reached a point before the desktop has even fully loaded.

My bootloader has a Leenium theme.

The Plymouth screen I see during boot looks like Leenium.

Omarchy boots into Leenium.

Hyprland continues the same visual language, and then the terminal, editor, browser, and the services I open inside that browser all continue the same world.

So from the moment I turn on my computer to the moment I'm somewhere in the middle of a function in Neovim—or opening Jellyfin late at night—I don't have to feel like I'm stepping into a completely different visual world every time I switch applications.

From the outside, this might look a little obsessive.

And, well...

It probably is.

But there's a reason I still haven't gotten tired of doing it.

A Theme Isn't Just "Colors" to Me

When you use an environment every day, you gradually build a mental model of it. Without consciously thinking about it, you know what an error looks like, where comments fade into the background, how a function distinguishes itself from everything around it, where the borders are, how far a surface sits from the background, and which parts of the interface are supposed to grab your attention.

Each of those things seems tiny on its own. But when you interact with them hundreds of times every day, they're not so tiny anymore.

I think that's where Leenium stopped being just a theme for me.

I was no longer trying to make "everything the same color." What became interesting to me was making the environment predictable.

When I bring Leenium to a new application, the goal isn't simply to give its background the same hex code as everything else. I want to open it and immediately recognize its visual logic. I want to know what's important, what's secondary, what's muted, where the borders are, and which colors are supposed to draw my attention.

It's a kind of visual vocabulary that I don't have to relearn every time.

And maybe that's why the best word I can use to describe Leenium now isn't "theme."

Leenium feels more like home to me.

Not because every part of it is beautiful or because I think it's the best color palette in the world. You don't call your home "home" because it has the best architecture in the world either.

It's home because you know it.

You know where the light switch is. You can find your way around in the dark. You don't have to stop and think about which cabinet the glasses are in. Things are where you expect them to be, and that familiarity removes a little bit of mental overhead.

That's gradually what Leenium became for me.

When Other People Started Coming In

What's interesting is that Leenium wasn't originally made for anyone else, but eventually a few other people started using it too.

Some people I know installed the Omarchy theme. The same thing happened with Plymouth and Limine. I sent the VS Code and Neovim themes to friends, and a few of them told me they're still using them.

And we're not talking about some ridiculous number of users here. This isn't millions of downloads. In some parts of the ecosystem it might be twenty people, maybe fewer, maybe more. Honestly, I don't even know whether everyone who told me they were using it is actually still using it.

But that's exactly what I find interesting.

Something that started from a completely personal problem—"these colors don't work for me"—is now living on a few other people's systems too.

Without ever being intended as a product in the first place.

Why Is It Even Called Leenium?

Maybe the thing I find most interesting about Leenium is the path it took to get here.

At first, it was just a set of colors intended to make my own Neovim more comfortable to use. Then it became a theme. Then it developed a proper palette. Then it moved into VS Code and OpenCode. Then it took over the desktop. Then the browser. Then my self-hosted services, websites, bootloader, and even the few moments before Linux has fully finished booting.

And now it has its own page where the palette and its various implementations are collected.

But when I look at it, I still don't feel like I'm looking at a "product."

It feels more like I've gradually taken the digital environment I spend hours living in every day and shaped it into something I understand better.

Maybe that's the same thing I've always found appealing about Linux, self-hosting, and software that's actually modifiable: you don't always have to accept something exactly the way it was handed to you. Sometimes you change a config. Sometimes you override some CSS. Sometimes you write a plugin. And sometimes the whole thing starts with changing the colors of a few functions in Neovim, only to realize a while later that even your bootloader is using the same palette.

Not because it needed to.

Simply because it could.

And maybe that's the best explanation of Leenium as a whole.

I didn't build a theme because the world needed another dark theme. The world probably has more than enough dark themes already.

I built Leenium because I spend hours every day inside these environments, and I wanted them to feel less like things I merely use and more like places that I know.

Somewhere I can enter without having to familiarize myself with it all over again.

Something a little like home.