SeurOS: The Operating System I Never Wrote

Last month I published The Framebuffer People, where I cloned every OS posted to r/osdev and found a pile of QEMU-shaped Linux reskins with Patreon buttons. Then I wrote eleven rules for doing it with your dignity attached.

What I left out of both posts is where the venom came from. I knew the framebuffer people from the inside. In 2022 I was the prototype.

This post is the confession.

The Vain Question¶

When ChatGPT was released in November 2022, my first question had nothing to do with code. I asked if it knew Seuros.

ChatGPT was stupid back then. Asked cold, it had no idea what Seuros was, but offered that it would be a cool name for an operating system. SeurOS.

To be fair, it did know me. If you steered it hard enough toward the Ruby ecosystem or webdev deployment, the recognition eventually surfaced. I had to prompt-engineer my own fame. The OS answer came first though, and it was the one that stuck.

A model with no memory and no shame had just named my next project. And because I am Seuros, and because I had real RTOS experience and years of wiggling inside the Linux kernel, I said to myself: let’s build the damn SeurOS.

The Grind¶

Understand the era. Claude Code did not exist. Agentic programming was a fringe activity. MCP was not even a whiteboard sketch. LangChain was trending, and I hated it with the passion it deserved.

So I built my own harness with Ruby on Rails. I called it LevAIthan on Rails. Pretty basic. It did its job: fed prompts to the model and wrote the resulting files straight to disk.

I spent sixteen hours a day with LLMs. Minimum $2,000 a month in API budget. I built a lot of shit, and to be fair, not all of it was waste. I learned constantly, and my documentation finally got reworded into proper English. That side of the ledger was real.

Somewhere in that stretch I released one of the first AI gems, ActiveLLM. Then some people insulted me for it, so I stopped working on it in the open. The gem still sits on RubyGems at version 0.0.0.alpha, a small tombstone from that era.

Here is the part that ages well: those same people are today some of the most lobotomized tokenmaxxers I know. They burn more tokens per week than I do per year. The insults were never about the tool. They were about who got there first.

The Empire¶

Four months later, I had built many operating systems.

Except I hadn’t built any. I just didn’t know it yet.

What I had was a repo with 20,000 commits. A number that means either a decade of honest work or four months of a machine typing while a human nods. I had a bootloader, a scheduler, drivers, a shell. It never ran DOOM, but CRuby and Java ran on it. A hobby OS with two managed runtimes, in four months. That should have been the first red flag.

Every decision had been correct by default, because I was the dictator of my own repo and the only reviewer was the thing that wrote the code. Rule 2 of my own eleven rules, written three years later, exists because of this exact period: you learn nothing from a system that cannot push back.

But in early 2023 there were no rules yet. There was just me, a Rails harness, a five-figure annual API bill, and an operating system with my name on it.

So I decided it was time to show the world the new operating system. It booted on my Lenovo X200, BIOS and all. I was going to be the next Linus TrovAIls.

The Demo¶

Step one: boot it on a second computer.

I plugged the USB stick into my Raptor Lake machine. Nothing. The stick was partitioned for BIOS boot, MBR and all, and my motherboard wanted UEFI. The firmware looked at my revolutionary operating system and declined to acknowledge its existence.

Fine. I went into the firmware setup and switched the board to legacy mode. CSM on, UEFI off. Reboot.

SeurOS barely started booting before it wedged. A few lines of output, then a frozen screen on hardware that had done nothing wrong.

Then it got better. I rebooted to go back to my normal life, and my computer no longer booted at all. Every operating system installed on that machine was UEFI, and the firmware was now in legacy mode, sitting there looking for an MBR that did not exist. My four-month AI project had failed its demo in under a minute and taken my daily driver hostage on the way down.

The fix was flipping the firmware back. The lesson took longer to arrive.

The Forced Reading¶

Back on the X200, I did what I had done for four months: I opened the harness and started prompting for a fix. Why does it only boot on one machine? Make the bootloader UEFI-aware. Add the boot path.

Then I hit the subscription limit.

No tokens left. For the first time since November, the only thing left to do with my operating system was read it.

So I read. A lot of it.

Some of the code looked familiar, and my first instinct was pride. Of course it looks familiar, it’s mine. Then I kept reading, and the familiarity got specific. I had seen this code years before SeurOS existed, in the Linux kernel, right down to the comments with the serial numbers filed off. It had another tell too: it was full of handling for cases I never hit. Workarounds for hardware flaws I could not even name, guards against failure modes my one laptop had never produced. That code carried scar tissue from two decades of broken devices. My project was four months old and had met exactly one ThinkPad.

Fine. I marked that region as Linuxy and moved on to the other code, the civilized code. Consistent style, nothing over-engineered. That part was obviously mine, because that is how I write.

I searched for it.

FreeBSD. OpenBSD. NetBSD. My civilized code was civilized because it came from the BSDs, where consistency is enforced at review and over-engineering gets rejected on sight. The model had assembled my operating system from the codebases it had memorized best, and I had spent four months signing my name to the merge.

The Drivers¶

The drivers were the best part. They were not even stolen generically. They were hardcoded.

Magic values everywhere, and I could not explain a single one. Addresses and timings pinned to the exact silicon inside a 2008 ThinkPad. Nobody designed those drivers. The model transcribed whatever made the X200 boot, and the harness rewarded it every time the screen lit up. The OS never supported the X200. It was married to it. A Catholic marriage, no divorce possible: till power outage do them part.

That is why the Raptor Lake wedged. There was no hardware abstraction to fail gracefully. There was a love letter to one specific laptop, and my new machine was not the addressee.

The funny part is that I knew better. I spent years working on RTOS firmware. ChibiOS ships a HAL, and I knew exactly why, because on microcontrollers hardware abstraction is the price of existing at all. But in the frenzy I had decided a computer OS was a different animal, and the rules from the small machines did not apply to the big ones. I could have taught the model that lesson from memory. I never asked it for a HAL.

One ThinkPad is an emulator made of metal: it pushes back exactly once, and then everything is correct by default again.

The Verdict¶

I am not some new potato in the open source world. I know a tool is a tool. I had generated and reviewed the code, and tested it on real hardware.

I had not authored it. I could not explain why half the values existed. I could not defend a single design decision, because no design decisions had been made. Reviewing 20,000 commits of other people’s code does not make it yours, it makes you the least effective license auditor in history.

The honest changelog for SeurOS read: four months, $8,000, one confirmed compatible laptop, and a GPL violation with my name on it waiting to be discovered by anyone who looked as hard as I finally had.

And “my name” is generous. The model had stamped the files with Copyright 2023 Seuros, The SeurOS Project. It stripped attribution from twenty years of kernel code and reassigned it to an alias and an organization that has never existed, formatted exactly like the BSD headers it was erasing. Not even my legal name. If the lawyers ever came, my defense would be that the plagiarism was signed by someone who does not legally exist.

So I deleted the dream of being Linus TrovAIls and made a new plan: forget the whole OS, build one component, and this time author every line of it myself.

I already knew which component, because the pain had a name.

The Reason¶

LevAIthan had many limitations, and one of them had been quietly torturing me for four months: it had no git implementation.

When the model changed a file, it changed the file. That was the whole transaction. There was no undo. Git only protected whatever I had remembered to commit, and in a sixteen-hour session with a machine that types faster than I read, the distance between commits was where working code went to die. The model would touch a driver that booted, and afterward there was only the new driver, which did not.

The fix everyone would suggest today is obvious: teach the harness git. But I had just spent four months watching abstractions lie to me, and I wanted the guarantee below the tools, below anything that could forget to call it.

A filesystem that snapshots every write. Every version of every file, retained at the block layer. Git, but for the disk, with no one required to remember anything.

Two Weeks¶

I built it in two weeks.

Copy-on-write, so a write never destroyed the block it replaced. Every mutation created a new version, and history was a first-class part of the disk layout. You could ask any file what it looked like an hour ago and the filesystem just answered.

And this time I did it right. I read my own code as I wrote it. I could explain every constant and defend every design decision. No magic values transcribed from a ThinkPad. This one was authored.

I had also learned the other lesson from the autopsy. Before announcing anything, before even thinking the word “revolutionary,” I went searching for prior art. Not because I expected to find any. I had never seen this idea anywhere, and I wanted the search to come up empty so I could say I had checked.

Dillon¶

The search did not come up empty.

Matthew Dillon designed HAMMER for DragonFly BSD. It shipped in 2008, a few months before Satoshi Nakamoto sent the PDF from the future. Fine-grained history retention at the filesystem level, with versions of your files kept as you work. DragonFly even ships a command called undo that pulls old versions of a file out of the disk’s own memory. The tool LevAIthan was missing had been sitting in a niche BSD for fifteen years, named with the exact word, while I invented it from scratch.

Then he did it again. HAMMER2, the successor, became DragonFly’s default filesystem years before ChatGPT could finish a sentence.

I had never heard of any of it. Nobody I knew had. DragonFly BSD is one man’s fork running on a sliver of the world’s machines, and it has been quietly ahead of the industry for two decades. My genuinely novel idea was old enough to have a successor.

The Difference¶

Here is the strange part: this failure felt nothing like the last one.

The OS was plagiarism. I could not explain the code, and the only thing I had authored was the git config. Finding Linux in my repo felt like being caught.

The filesystem was reinvention. Every line was mine, and the idea was still not new. Finding HAMMER felt like being educated. Dillon and I had looked at the same problem and reached for the same shape, except he did it in 2008 without burning $2,000 a month in tokens. Independent reinvention is how you find out your thinking works. It is also how you find out how far behind the reading you are.

That gap had a fix, and the fix was not a bigger model. The prior art was never hiding. It was sitting in manpages and in books that take 200 days to read. The model had memorized all of it and could not tell me it existed, because I never asked what was already built. I only ever asked it to build.

The BSDs showed up at every crime scene in this story. The civilized code in my fake OS was theirs. The filesystem I invented was theirs, twice. Eventually I stopped treating that as coincidence and started reading their code on purpose. That decision is how the rest of this blog happened.

That should have been the end of the story. Four months and a bricked boot order to learn what the eleven rules now say in one line: the reading is the work. The typing at the end is a receipt.

I had learned the lesson. Then I drew one more conclusion from it, and it was the wrong one.

Everything Old¶

Everything old was already invented. That was my takeaway. Linux was prior art. The BSDs were prior art. My best original idea had been shipped by one man in 2008. Digging in the past kept ending at somebody else’s grave marker, so I decided to see the future instead.

I migrated to Android. I wanted to rename the project AIndroid, but for the time being it stayed SeurOS. I had a Fairphone and a Pixel 7 lying around, and I started studying the AOSP codebase for real this time, the way the autopsy had taught me to read.

The new goal: release the first Agentic OS. An operating system where everything is hallucination based. The model would not be an app sitting on top of the system. The model would be the system.

I bought books again too, and the market had changed while I was gone. Authors were in liquidation mode, selling for $49 whatever they could package before the models replaced books entirely. Bundles of 100 books for $29, collections that would have cost over $4,000 a few years earlier. I bought the packs. The people whose knowledge trained the models were holding a going-out-of-business sale, and I was shopping it to build more model.

GaslightOS¶

Google released Gemma 1, then Gemma 1.1 on April 5, 2024. That was the model for SeurOS. Small enough to live on the device, which is where an Agentic OS’s agent has to live.

I wired a lot of the system to it. And the model did a lot of shit. So the project finally earned an honest name, better than SeurOS and better than AIndroid: GaslightOS.

It ran on the phones and on a tablet. It was fun, and it was genuinely crazy. It also wiped itself. Many times. The name kept proving itself: the OS would destroy its own storage, boot fresh, and carry on with no memory that anything had gone wrong, leaving me as the only witness.

The Discipline¶

That is where I leave this story, because the next chapter deserves its own post: how I became a FreeBSD maintainer.

Here is the preview. I did not join FreeBSD for lack of talent. I joined because a project with millions of lines of code teaches discipline, and discipline was the one thing no model ever generated for me. Every system in this story pushed back too late or never. FreeBSD pushes back before your commit lands, and it has been doing that since before I could read.

The reading is the work. I finally moved to where the reading lives.