Printable field manual
This route gathers the web manual into one continuous document. Read it straight through, or print it as a desk reference while operating the kernel.
Reading order
| Order | Route | Use |
|---|---|---|
| 1 | Index | Establish the machine identity: x86-32 kernel, causal graph, timelines, federation, and operator shell. |
| 2 | Manual | Read the subsystem inventory and command tables before operating the kernel. |
| 3 | Subsystem chapters | Study each subsystem in turn with a stated role, source files, and a command that makes the idea visible. |
| 4 | Guided concept trails | Follow short operator routes across single boundaries: boot, syscall, packet, note, and actor message. |
| 5 | Execution walks | Trace ordinary commands from prompt to device, program, or graph record with transcript and event path. |
| 6 | Operator labs | Run hands-on QEMU exercises with expected observations and cleanup notes after cloning the kernel. |
| 7 | Causality laboratory | Study event records, Lamport time, parent edges, timeline replay, and federation hooks. |
| 8 | Reading room | Place the design beside Lamport clocks, event sourcing, provenance, Plan 9, Barrelfish, time-travel debugging, and actor systems. |
| 9 | Glossary and source atlas | Look up a term, then follow the source files that implement it through a subsystem reading map. |
| 10 | Source plates | Inspect representative code listings for the event record, bounded ring, syscall context, actors, and notes snapshots. |
| 11 | Showcase | Watch the captured machine sessions and compare the display with the command notes. |
| 12 | Showcase notes | Read chapter study notes that map each clip to subsystems, commands, and source files. |
| 13 | Field manual | Print or save this route as the continuous reading document. |
Section 1
SlOS is a small operating system presented as a causal machine. It boots, runs drivers, schedules tasks, accepts shell commands, serves files, and records significant activity as events.
This field manual gathers the learning route into one continuous document. It is meant for reading on paper or in a long browser session.
Section 2
Begin with the machine in front of you. Build the kernel, enter QEMU, issue commands, and keep the event list open. Treat each command as an experiment with a recorded result.
The core operator questions are stable: what happened, which subsystem emitted it, what were its parents, and which current view was derived from it.
Section 3
An event receives an ID, a subsystem label, a description, time fields, optional payload material, and parent event IDs. Parent edges turn a flat stream into a directed explanation graph.
Lamport time supplies causal ordering. Wall ticks and local counter fragments help the human operator line up logs, captures, and command output.
Section 4
Applications that benefit from history use named timelines. Notes, mail, editor buffers, and scheduled commands are represented as application events with replay callbacks.
The timeline cursor is the manual control. Rewind moves the selected state backward. Forward moves it ahead. Export and snapshots carry selected state into SlFS.
Section 5
Use the source plates after the behaviour is familiar. Follow the event structure, the bounded ring, syscall context, actor registration, and notes persistence.
The implementation favours small structures and direct transitions. This makes it suitable for manual tracing from shell command to kernel event to application state.
Section 6
The reading room supplies the design ancestry. Lamport clocks teach logical order. Event sourcing teaches state from facts. Provenance teaches origin tracking. Plan 9 teaches clear names and simple service surfaces.
Barrelfish teaches explicit communication inside the machine. Time-travel debugging teaches recorded state movement. Actor systems teach isolated entities and message delivery.
Section 7
SlOS uses bounded buffers, fixed tables, compact payloads, and a recent-history causal ring. These limits keep the system readable and make resource decisions visible.
Durable state belongs to SlFS, timeline exports, and application snapshots. Recent explanation belongs to the causal graph. The operator should know which structure is carrying which responsibility.
Command card
| events 10 | List the recent causal record. |
| why <event-id> | Print direct parents and children for one event. |
| trace <event-id> | Walk the ancestry chain backward. |
| graph | Draw a compact recent DAG. |
| tl show notes | Display the notes timeline. |
| tl rewind notes 20 | Move the notes cursor backward. |
| actors | List registered actor endpoints. |
| mesh | Inspect mesh and federation status. |
Print notes
The page uses existing manual sections, tables, and chapter blocks so browser print mode produces a stable operator packet. Keep the links visible in a saved PDF for cross-reference to the web routes.
Follow the reading order above from top to bottom for a full pass, or jump to any single route as a desk reference while operating the kernel. The subsystem chapters, guided trails, execution walks, and operator labs are the hands-on additions for readers who want to run the kernel alongside the text.
Field rule: read one section, boot the system, issue the matching command, then inspect the resulting causal record. The printed manual is a route map; the running kernel is the text.