SlOS

SlOS is an operating system built around an awkward question: after something goes wrong, can the machine tell you what caused it?

The usual answer is logs, which are text written by whoever remembered to write it and correlated afterwards by timestamp and hope. SlOS puts the causal structure in the kernel instead. Scheduler switches, syscalls, filesystem operations, packets, actor messages, mesh events, shell commands, and application events all enter a typed directed acyclic graph with Lamport time and explicit parent edges. Every significant action knows what it came from.

Keeping the graph

A causal graph is only useful if it outlives the boot. cjournal spills aged events out of the hot ring buffer into SlFS segment files with per-event hashes, Merkle sidecars, epoch roots, and searchable indexes. The system ends up with a past it can read back rather than a ring that quietly overwrites itself.

From there, rewind, replay, scrub, and whatif all read the same event material. The Causal Inspector narrows the DAG to a region, diffs two ticks, and reports the blast radius of a counterfactual: what else would have moved had this event not happened.

The machine underneath it

The graph needed something to run on, so there is a fairly complete system around it.

• wm, a keyboard-driven tiled desktop on the 1024x768 framebuffer, showing CPU, memory, task list, and a live causal tail on one screen
• A userspace httpd serving /causal, an interactive SVG rendering of the DAG with a time-travel scrubber
• Cooperative SMP, where the bootstrap processor hands queued kernel tasks marked ap_offloadable to idle application processors — kernel work only, not general load balancing
• telnetd and a Noise-encrypted shell, with a terminal redirection layer that carries the full-screen editor and ANSI applications over the wire and sizes them from NAWS
• slosh, a shell with functions and recursion, persistent /home, and services that survive a disconnect

History someone else can check

Causal history is worth less if a peer has to take your word for it. Each node holds an Ed25519 key and signs its verified epoch roots. Peers exchange signing keys over the encrypted mesh, and a receiver checks a signed root against the key it has for that node, so a shared slice of history is attributable rather than merely asserted.