// systems engineering · from rasterizer to kernel
The Laplace Project
A native operating-system kernel with a dual-build game & graphics engine fused directly into kernel space. Six years of low-level engineering — a software rasterizer, an ECS game server, and finally a zero-copy kernel you can boot right here in your browser.
Boot it in your browser
LplKernel runs locally in your tab via v86 — no install, no backend. Each ISO is ~3 MB and downloads on demand.
Click to download the ISO and start the emulator.
In the text profile you can type commands: help, stats, kbd, layout fr, pci. In the world profile: WASD orbits the camera, Q/E zooms, B cycles the shading (biome, elevation, moisture), N generates a new world and O switches to the endless one (then WASD walks, J/L turns). Click the screen to capture your keyboard. Runs single-threaded (GitHub Pages can't set cross-origin isolation headers), so boot takes a few seconds.
What the emulator shows (text description)
This panel is a full x86 PC emulated in your browser. It is a pixel framebuffer painted by a guest operating system, so a screen reader cannot read its contents — what follows describes what a sighted visitor sees.
In the text console profile, GRUB hands control to LplKernel, which prints its boot sequence line by line as each subsystem comes up — memory management, the interrupt tables, CPU topology, the PS/2 keyboard, then the PCI bus enumeration listing the emulated machine's devices (host bridge, IDE controller, VGA adapter, network card). It then drops to an interactive prompt accepting help, stats, kbd, layout fr and pci.
In the world profile, the kernel switches to a VBE framebuffer and generates a landscape — value noise, thermal and hydraulic erosion, depression filling, drainage and rivers, then a climate and a biome classification. The result is drawn in perspective by the engine's software rasterizer: snow on the peaks, grassland and desert in the interior, rivers cut into the relief, a sea plane at the shoreline, conifers on the wooded cells, and a herd of grazers and hunters walking over it. A heads-up display reports the seed, how many biomes came out, how much vegetation is standing and what the herd has eaten. Pressing N generates an entirely new world.
Nothing there is a recording or a baked asset. There is no userspace and no filesystem in this profile: a freestanding i686 kernel is running the procedural generation, the ecology and the rasterizer itself, between an interrupt handler and a page fault.
Pressing O switches to an endless world. The bounded world above is the one the cartridge describes; this one has no edges at all — terrain is sampled at absolute world coordinates, so the shared border of two pieces is the same position and matches exactly, by construction rather than by stitching. Walking with WASD streams new ground in ahead and releases it behind, and the rivers cross those borders because the drainage is decided at two scales: a coarse level routes where a river runs, a fine level draws it.
What the endless world does not have is the erosion, the town and the roads. Those are relaxations over a whole grid, and a relaxation has no meaning on a piece of a world that continues past its edge — so the endless mode is the raw substrate, and the cartridge remains the authored world.
Both the generated world and the simulation running on it are verified bit-for-bit against a Linux reference run — that determinism result is written up in the papers, in text.
Engineering locks we broke
The interesting parts aren't the features — they're the constraints. Here is what made the architecture hard, and how it's solved.
Kernel-space engine
LplPlugin is compiled natively into LplKernel and runs in ring-0 — no syscall boundary between the engine and the hardware.
Zero-copy data path
UDP packets are injected from the NIC toward the GPU without intermediate copies, collapsing the classic network→render latency chain.
Lock-free concurrency
SPSC ring buffers with acquire/release barriers and generational IDs (ABA-safe) drive the interrupt→main-loop hand-off.
Cache-friendly ECS
Structure-of-Arrays layout keeps hot component data contiguous, and spatial partitioning (Morton / Octree) tames O(N²) at MMO scale.
Key benchmark figures
Figures from stress tests — see the papers for methodology.
The lineage
LplKernel
coreA from-scratch kernel: paging, SMP bring-up, APIC/IOAPIC, PCI, a determinism-first PMM, and LplPlugin running natively in ring-0.
LplPlugin
activeThe dual-build engine — graphics, physics, ECS — that supersedes and unifies the two earlier projects, now embeddable directly into the kernel.
LplAssistant
activeA local model that decides WHAT and lets a deterministic engine decide HOW — constrained at decode time by a grammar generated from the engine's own component declaration.
LplKnowledge
earlyEvery algorithm here traced back to the paper that argued for it and forward to the file that implements it — so the project can say why, not only what.
Engine-3D
legacyThe first graphics engine: hand-rolled 3D math and software rasterization in pure C, with a minimalist physics core. Where it all started.
Flakkari
legacyAn ECS game server with its own protocol, JSON-driven scenes, entity templating, and multi-instance hosting — the networking ancestor of LplPlugin's server build.