Case file · Systems / OS
LociOS is a from-scratch, bare-metal Rust operating system built for one workload: autonomous intelligence. Every OS in production treats intelligence as an application — installed, scheduled, killed like any other process. LociOS inverts that and makes cognition a kernel primitive. The unit of work is the Locus: a small autonomous unit with its own capability set and budget, and no direct channel to its peers. Loci coordinate by stigmergy — each leaves traces in a shared field, and others change course by reading them.
Beneath the mesh runs a bytecode VM at the lowest level that profiles its own hot paths, emits replacement bytecode, verifies it against capability constraints, and swaps it in while running. Self-modification behind a verifier and a capability wall becomes an optimisation loop the system runs on itself.
Why it exists
Day jobs are about shipping what the market wants. This is about understanding what the stack is actually made of. You can read about page tables, or write a loader that crashes until you respect them — only one of those changes how you think. The lowest layer is the best teacher, and an operator should know what the machine does when no framework is watching.
Shape of the system
┌──────────────┐
│ uefi boot │ custom loader, no inherited bootchain
└──────┬───────┘
│ hands off a sealed, capability-scoped core
┌──────▼───────┐
│ kernel vm │ bytecode interpreter at ring 0
│ (rewrites │ profiles hot paths, verifies +
│ itself) │ swaps replacement code at runtime
└──────┬───────┘
│ spawns
┌──────▼───────────────────┐
│ loci mesh │
│ o───o o───o │ units coordinate by trace,
│ \ \ / / │ not by command —
│ o───o─o───o │ stigmergy as the scheduler
└──────────────────────────┘
Three hard lessons
1. The bootchain owes you nothing. Without an inherited loader, every assumption a normal OS gets for free has to be earned by hand. Most of the early work is making the machine agree to run your code at all.
2. Coordination without a coordinator scales, but debugs hard. Stigmergy removes the central bottleneck and the single blast radius — at the cost of emergent behaviour you cannot read off any one unit. You debug the field, not the node.
3. Self-modifying code needs a burden of proof. The VM only swaps in bytecode it can verify as safe and measure as faster. Without that wall, self-improvement is just a crash with extra steps.
Stack