Describe a tile. Get a working one in your browser. Tiles are file-backed, runtime-state-bindable, and saved as diffable JSON — not SVG, not a hosted product, not locked to any framework.
install
— one script tag, no build step
<!-- 1. load the framework + theme --> <script type="module" src="https://unpkg.com/@runefort/core"></script> <link rel="stylesheet" href="https://unpkg.com/@runefort/core/theme.css"> <!-- 2. declare a floor of rooms --> <rune-floor columns="6" rows="2"> <rune-room id="memory" position="0,0" size="3,2" anchor="lib/memory.ex:24"></rune-room> <rune-room id="deploy" position="3,0" size="3,2" anchor="lib/deploy.ex"></rune-room> </rune-floor>
this is the substrate — not a screenshot. click any tile to open it. refine a rune with an llm. fork the demo fort and start placing your own. local by default; sign in to sync.
where it fits
Most tools in this neighborhood are either AI app builders or hosted dashboards. Runefort is the small open piece that fits beside them — the layout language they all benefit from.
AI UI builders ship full React projects. Runefort ships ~5KB of Web Components plus a portable JSON spec for the grid itself. Drop the result inside whatever those tools (or you) already built.
Tile-grid libraries handle drag and resize. Runefort adds rooms that own files, runtime signals that color tiles, and a typed extension surface so apps add features without forking the protocol.
Hosted dashboard and internal-tools platforms own your data and your auth. Runefort owns nothing — it's a 5KB protocol you ship inside whatever stack you already have. BYO transport, BYO auth, BYO LLM key.
Spatial workspaces are for personal cognition. Runefort is grid-only, deterministic, and diffable in version control — built so a system's place looks the same on every machine and every commit.
built for
The substrate is empty until something moves in. Vocabularies declare what a tile means in a given domain — the dark factory was the original tenant; supervisor floors, atlases, and dashboards were always coming. Yours can move in next; vocabulary unknown means degrade, not fail.
the v2 vision, lifted into the new protocol. tiles are workers. buildings are services in the pipeline — specprompt, agentelic, fleetprompt, runefort. campuses are deployments. corridors carry build status. backwards compatible with anything written against v2.
for [&] supervisors. tiles carry autonomy level, uptime, last action. state class follows the supervisor's health. the room is the supervisor as far as the floor is concerned.
tiles are modules; claims are file globs; signals are coverage, churn, hotness. cold tiles are stable. hot tiles are this week. new contributors stop asking "where do i look?" and start looking.
tiles are widgets; signals push to state classes. cold/warm/hot/fault is enough vocabulary for most boards. when it isn't, you write your own.
Write your own vocabulary at any time — namespace it
freely (com.example.my-vocab.v1), drop it in
meta, ship. The protocol does not require
registration.
the scales
a floor alone is a grid. real systems live at multiple zooms — one campus, many buildings, many floors per building, many tiles per floor. the substrate carries all four; you pick the one you need.
the outermost frame. one campus per fort. holds many buildings, the marquee, the elevator wells. zoom out here to see the whole world at once.
a stack of floors. one building is one slice of the system — a service, a product, a team, a tenant. the elevator runs up and down; each floor is a different concern.
where work happens. a css grid of rooms. neighbors thread the rooms together; state binds them to live signals. this is the page you actually walk.
the atom. one rune, one claim, one state class. click in and the room becomes the page — its content surfaced inline, not in another tab.
names
two words do most of the work in this protocol. one is the workspace. the other is the mark on every tile.
your installation. one fort holds one campus. fork a fort to start your own. share a fort by url and anyone who clicks can fork it. sync forts across machines when signed in. forts can bridge to other forts — the substrate is multi-tenant from day one.
the sigil on every tile. the name that appears in the marquee. the thing you click. the thing an llm refines when you say "rewrite this." ᚲ is itself a rune. every room has one. they are how the place stays legible at a glance.
primitives
v0.1 ships the four primitives that describe a floor. v0.2 grows the substrate to carry the rest of the [&] stack — loops, capabilities, traces, and the cross-fort wiring that lets a system actually run.
position, size, label, body. the unit you place.
inline content or a file anchor. surfaced when you click in.
arrow-key adjacency. structural edges between rooms.
cold, warm, hot, fault, idle — or any class your vocabulary defines.
campus → building → floor → room, lifted from app convention into the protocol. a renderer can show any scale on its own and still be conformant.
a connection between two forts. b2b token flow. nested forts. how an [&] system spans tenants without smearing them into one campus.
[&]tag a room with an [&] capability descriptor. the room is the unit; the descriptor says what it can be composed with. the substrate gets composable.
pulsebind a container to a pulse manifest. phases — retrieve, route, act, learn, consolidate — map to state classes. the floor breathes with the loop.
graphonomoustie a tile to a graphonomous goal. coverage drives the state class. progress is visible spatially — not buried in a status page.
a stream of recent traces attached to a room. the room owns its history, not just its current frame. open it and read what just happened.
for engineers
runefort is a small declarative protocol. the primitives
compile to a css grid via the
@runefort/core web components — ~5kb,
zero build step, embeds inside react, vue, svelte, liveview,
or plain html. three authoring surfaces:
runefort.json,
<rune-*> custom elements, or a
curly-brace .rune dsl. independent of the rest
of the [&] stack — usable by them, never required.
Fork the demo. Place a few rooms. Refine a rune. Give your system a place — whether it's a dark factory, a codebase, or something the substrate hasn't seen yet.