The beginning of an operating system where a model makes the apps.
Its kernel is written from nothing in Rust, for x86-64 PCs. The firmware loads it directly — there is no bootloader in between.
Hello from my kernel! I draw my own letters now.
Hello from a Lua script!!!
Kernel: type a line and press Enter.
You: Hello, World!?
Kernel: you said "Hello, World!?"
_
What the kernel paints today, drawn here with its own colours and words. The real thing runs in QEMU. The cursor does not blink there either.
The idea
You do not install apps. You ask for one, and a model writes it.
A small kernel that is always on does the fast, exact work: sharing the processor and the memory, keeping apps apart, talking to devices. A model does the slow, clever work: it writes the app you asked for. It is not part of the kernel; it is reached over the internet.
What the model writes is a script, plain text. It runs locked in a box, where it can ask the kernel for a few things and touch nothing else. A clumsy app — one that never ends, or eats its memory — is stopped, and the kernel carries on.
kernel shares the processor and the memory, talks to devices
└─ the box WebAssembly: keeps everything inside locked in
└─ the interpreter understands Lua
└─ an app a script, as a person would write it
The last step is not built yet: no app is written on request. What is built is the ground under the idea, piece by piece — each piece tested, and explained in plain words.
What it does today
Starts itself. The firmware loads the kernel's file, the kernel asks it for the memory map and the screen, and then tells it to step aside.
Owns the machine. Its own interrupt table, its own page tables, a pile of free frames, a heap, and tasks that take turns under the timer.
Draws everything. Letters drawn by hand as small grids of dots, a panel, a chat box to type in. The word at the top of this page is drawn with those shapes.
Speaks to the world. Its own network driver. It is given an address, looks up a name, and fetches a page over an encrypted link — the site's certificate checked against trusted roots the kernel carries.
Keeps things. Its own disk driver, its own part of a divided disk, and a notebook of named things where nothing already written is ever changed.
Locks apps in. An app is a WebAssembly program in a box: checked against the rules before it runs, with a limit on its memory and a budget of steps. A clumsy app is stopped; the kernel carries on.
Understands Lua. It carries an interpreter that itself runs inside the box, and hands it a script — so a script's mistake stays locked in too.
Asks a model. Type ask in the chat box and one fixed question goes to a model over the encrypted link, with a key you typed that shows as stars. The real provider has answered it: in a run with a real key, the model's answer appeared in the chat box.
How it is written
To be read. Plain words, small files, one topic per file, and a comment above every unusual step saying why. A device "signal" is an interrupt; a "frame" is 4096 bytes of real memory.
Owned. Four pieces of outside code — smoltcp for the network stack, rustls with the arithmetic crates for the encrypted link, wasmi for the box, omnilua for Lua — each one read and trialled before it came in. Everything else is written for this kernel. Building it runs no build script and uses no macro crate.
With notes kept true.docs/ holds what the code cannot say for itself: the order things must happen in, what was tested and what was not, and the known limits.
Run it
Windows, stable Rust, QEMU — and one script:
git clone https://github.com/borisandreipavel-a11y/boos
cd boos
.\run.bat
The README walks through the setup, and says plainly what a run does: the first build fetches the outside crates, every start reaches the internet once, and the first run makes a small disk file next to run.bat.