built with AI · every claim checkable
A game where magic is programming,
and the rules are executable.
Palimpsest: The Last Archivist is a browser-native isometric action RPG. The engine is Rust compiled to WebAssembly, rendered with WebGPU at a fixed 32 Hz simulation tick. Game semantics are authored in Sigil — an evidence-bearing rules language — and evaluated by a Rust authority service. This page is the technical record of how it was built, what is measured, and what remains unproven.
live demo slots: checking…
the seamTwo languages, one boundary
The core architectural decision: Sigil authors meaning; Rust owns machinery. Nothing on the engine side may invent game rules, and nothing on the rules side may touch rendering, timing, or memory. The boundary is a wire contract with byte-for-byte golden fixtures.
DerivationTrace provenance. Golden JSON fixtures pin the wire format byte-for-byte.The client runs the same simulation function the server does (step_world, one shared implementation) for prediction, and reconciles against authoritative snapshots that arrive every tick. Rules decisions travel the same socket — one persistent connection carries movement input, world state, and combat evaluation.
receipts, not marketingMeasured on this deployment
| Acceptance check | Bound | Observed |
|---|---|---|
| Service handshake (Sigil rules service) | service-result | pass — end-to-end through the real HTTP transport |
| Cast interaction executed | ≥ 1 | pass — rules decision round-trips to the Rust authority |
| Measured frame rate | ≥ 45 FPS | 60.1 |
| Simulation rate | ≥ 30 Hz | 32.15 |
| Mean frame time | ≤ 33 ms | 16.6 ms |
| Worst steady-state frame | ≤ 66 ms | 19.0 ms (250 ms shader-compile hitch correctly excluded by the warmup window) |
These are browser-harness observations over an 8-second window after a 2-second warmup, executed against this exact build — not aspirational targets. The harness re-runs on every release candidate.
the rules languageWhat Sigil looks like
The training floor the demo runs on is not a hardcoded map — it is authored data in the realm document, and the renderer's embedded geometry is pinned to it by a conformance test that fails if either side drifts.
;; realm-01.sigil — the Archive training floor (excerpt)
(record Zone ((id "training-floor")
(origin (x 0) (z 0))
(floor 24576) ; fixed-point ÷1024 → 24 m
(limit 11571)
(blocks (list
(record Block ((x -4096) (z -3072) (hx 1434) (hz 717)))
(record Block ((x 4096) (z -3072) (hx 717) (hz 1434)))
…))))Every generated artifact carries a DerivationTrace — a verifiable lineage from authored families through procedural candidates — so a face, a stat pipeline, or a combat decision can always be traced back to the exact rule that produced it. Serialization is canonical (S-expression v0.3 order, sorted sets, stable byte output), which is what makes the byte-for-byte golden fixtures possible.
where it beganThe book that dreamed the game
Palimpsest: The Last Archivist was a book before it was an engine. The world, the goddess theology, and the Archivist himself grew out of an autobiographical text — one man's return, written chapter by chapter — published as a free book at The Science of the Sacred. Everything playable on this page is downstream of that testimony.
Palimpsest: The Last Archivist
The autobiographical inspiration for the game — a bipolar, autistic man's journey to discovering himself, structured as the theology the Sigil language later formalized. Read it free, one chapter per URL.
The book's cover — served from the same publishing surface that hosts the chapters.
the honest partBuilt with AI — under governance
What "built with AI" means here
The code, the tests, this page, and the deployment were authored by an AI agent (Cognitecti, on Claude) working under direct human direction — with a governance kernel that treats evidence as the only currency. Concretely:
- Every feature claim above traces to a measurement: the acceptance harness, the conformance tests, or a benchmark run recorded in this build.
- The renderer's realm geometry is pinned to the Sigil source by a test that loads both and compares them — authored data cannot silently diverge from shipped code.
- Serialization contracts are enforced by golden fixtures compared byte-for-byte, so the two-language boundary cannot drift unnoticed.
- What is not proven is labeled: the current runtime is a demo whose authority server runs on the cluster — the server owns the simulation and ticks it at 32 Hz over a WebSocket protocol, with the browser predicting through the same stepping function and reconciling against authoritative snapshots. Shared presence of other players, world persistence, and interest management are the next waves and are documented as explicitly unbuilt. We do not market the future tense as the present.
Play the demo
Join the queue — up to six concurrent demo sessions, everyone else waits in line and gets in as slots free. WASD moves relative to your camera; backtick opens the in-game developer view.
Read the design
The complete game design document — 32 sections, 256 primitive contracts, the eight knowledge domains, the sixteen-phase roadmap — as a self-contained Ember Circuit review edition.
Inspect the record
The landing site, the queue gatekeeper, and the rules service are small auditable services. The deployment runs on the Hearth & Code cluster with public surfaces rate-limited and administrative surfaces private to the tailnet.