Genos is an operating system built for a world where software can write its own interface. Every OS in use today was designed decades before that was possible, so the interface is something a developer hand-builds once and everyone receives identically. Genos inverts that: apps describe what they need, the system renders it for the person in front of the screen, and the kernel meters what any generated code is allowed to cost. It's a new systems language and a new microkernel, written from the hardware abstraction up.
How it works
An app on Genos ships intent rather than pixels - a description of what it needs to show and do - and the system composes the interface from that, which is what makes per-user and per-moment rendering possible at all. Generated code runs against hard metered budgets enforced below the application layer, so adaptive interfaces stay cheap and predictable instead of turning the machine over to whatever a model decided to emit. The language underneath is memory-safe by design and compiles straight to RISC-V machine code, with no Linux, no GNU, and no C anywhere in the stack.
Where the project stands
An operating system is easy to describe and hard to prove, so it is worth being exact about which parts of this actually run.
Running today
- The language compiles and boots on emulated bare metal
- The compiler pipeline is written in the language it compiles, from lexer through native code generation
- It agrees with the reference implementation on every test input
- The OS draws real pixels through a real GPU queue and reacts to live keyboard input
- Between events it sleeps rather than burning cycles
- A window authored by a locally-run AI model has rendered on the metal
- One command compiles and boots every demo, asserts output byte for byte, then runs it twice to confirm determinism
Still ahead
- Moving off the emulator onto real RISC-V silicon
- Intent-based apps as the normal way to write software for the system rather than a demonstration of it
- Kernel metering strong enough to run model-generated interfaces all day without watching the cost
Where I'm taking it
The near-term goal is moving off the emulator onto real RISC-V silicon, and the longer one is making intent-based apps the normal way to write software for the system rather than a demo of it. Past that, I want the metering story to be strong enough that a machine can run interfaces generated by a local model all day without anyone thinking about what that costs. Writing the language and the kernel myself instead of standing on someone else's is deliberate: I spend my working life at the very top of the computing stack, building marketing and AI platforms, and Genos is me wanting the bottom of it as well.