LuRiOS
What is LuRiOS ?
LuRiOS is a capability based operating system I built from scratch as solo engineering project demonstrating that you can think rigorously about systems, design coherently, execute solo without external funding, and ship working code at this level. LuRiOS is not based on Linux or any existing operating system it shares no kernel and no drivers with them. The kernel and everything around it were written from the ground up. This isn't reuse or a derivative, it's a clean sheet design.
LuRiOS is not a replacement for the systems people use every day. It doesn't run their software and isn't trying to. Those systems are good at what they were designed for they were simply designed for different problems than the AI era brings, and some problems are better approached with fresh assumptions than inherited ones.
Why I Built LuRiOS ?
After many years of security work, one question kept nagging me: what is a program actually allowed to do, and how do I really know?
On most systems the answer is uncomfortable. A program runs with broad permissions and is trusted to behave. If it turns out to be buggy or hijacked, the system often can't tell the harmful action looks just like a normal one. That was reasonable when programs were written by people you could hold accountable. AI agents change the picture. An agent decides what to do on the fly, based on a model even its creators can't say exactly what it will try, or guarantee it won't be steered into something unintended. So "is this program safe to run?" stops having a clean answer. I built LuRiOS to explore what an operating system would look like if it took that problem seriously from the ground up.
What it does differently ?
Picture a typical system as a building where every program gets a master key and is trusted to open only its own door. Most behave but a copied or misused key can open far more than it should, and the building can't easily tell proper use from misuse.
LuRiOS gives each program a key that opens exactly one door not by rule, but because the key won't turn anywhere else. A program starts able to do nothing, and can only do what it's specifically handed. It can't grant itself more or work around the lock, because enforcement lives in the system itself, beneath the program. So even if an AI agent is steered toward harm, it can't act beyond its limits the ability was never granted, and the system won't create one on its behalf.
The added value
These benefits are hard to achieve by adding security on top of a system after the fact:
- Limits you can state precisely. A program can only do what it was granted, so you can describe exactly what it's capable of a known, finite list, not an open question.
- Safety from the design, not the setup. Hardening a system after the fact takes expertise and stays safe only while every layer is configured correctly. LuRiOS builds the limits into the architecture, so a safe result doesn't depend on getting a long checklist right.
- A boundary simple enough to verify. Understanding what a program can do means reading what it was granted nothing more. When you have to prove that boundary to an auditor, regulator, or customer, a short, clear answer is easier to trust than one assembled from many moving parts.
- A foundation built for safety. A large share of serious security issues trace back to one category of memory related errors. LuRiOS is built in Rust, designed to prevent that category, and runs programs in WebAssembly sandboxes so that whole class of problem is structurally reduced rather than guarded against later.
- Predictable behavior from a small core. The trusted heart of the system is small enough to reason about whole. Failures stay traceable and contained, instead of emerging from an enormous, decades old codebase.
On standing on others' shoulders
The core idea giving programs only the permissions they need, rather than broad default trust isn't new. It's called capability based security, explored since the 1960s in systems like KeyKOS, EROS, and seL4, and long regarded as one of the sounder ways to build a secure system.
I don't claim to invent capability based security. What's mine is the combination and the execution: the established idea, built on a memory safe Rust foundation, running programs in WebAssembly sandboxes, aimed at the AI agent problem, and built as a real, working system by one person rather than a research prototype. The thinking is borrowed and credited. The synthesis, the modern foundation and the working artifact are mine.
Where it fits ?
LuRiOS is built for situations where being certain about what code can do matters more than the breadth of software available: AI agents operating where a mistake could cause real harm, sealed devices that should never be repurposable, security critical equipment, and regulated environments where "what did this code actually do?" needs a confident answer.