Vector World is a small generative model that writes geography the way a cartographer would — as terrain, roads, rivers and land cover, one connected 500 m square at a time — and a browser that turns each square into an explorable 3D world.
Modern image models paint gorgeous terrain in seconds. But a world you can walk through, build on and keep extending has obligations a picture never has: the road that leaves this square must arrive in the next one, the river must stay downhill, and the ground must never crack along a seam. And it all has to happen on demand, on modest hardware, with no world map planned in advance.
Every new square borders up to four existing ones. Heights, slopes, roads, rails, rivers and forest boundaries must agree with all of them at once — exactly, not approximately.
A road must remain a road — an object with a centreline, a width and a class — so it can be validated, edited, rerouted and rendered in any style. Pixels bury that information.
The world must grow only where someone explores it. No global seed, no planet-scale simulation, no precomputed map — the frontier is the only plan.
There is no invented training world. The state of Victoria, Australia — its actual roads, rivers, coastline, forests and elevation — is compiled into compact tile programs. The model never sees an image; it learns the notation of geography.
Cut the state into stable 500 m × 500 m squares on a metric grid.
Replace the height raster with a few shared edge profiles plus Gaussian hills — a ~50-parameter surface per tile.
Clip, repair, sort and quantise every feature by deterministic rules, so identical geography always spells identically.
Write each tile as a variable-length DSL program and tokenize it — simple country is short, dense suburbs are long.
An autoregressive transformer learns to complete a tile given its neighbours and their edge contracts.
Each pair links a target tile to one existing neighbour and its shared edge; multi-edge training then composes random subsets of a tile's neighbours afresh every epoch, so the 302k stored pairs unfold into a far larger example space. Held-out splits are geographic, never random — whole regions are withheld, so validation measures genuine generalisation to unseen country.
This miniature runs the real division of labour. Click any dashed square touching the map: every existing neighbour contributes an edge contract — road ports, river ports, forest intervals, terrain heights — which is copied exactly. The generator is free only in the interior. Watch roads and rivers carry on across every seam.
Awaiting a click. Contracts extracted
from existing neighbours will be
itemised here.
Every tile is written in a compact domain-specific language: a terrain header, then polygons, then linear features, then an explicit end token. Hover either side — each statement is a piece of geography, and each piece of geography is a statement.
The road above is an editable object with a class and a width — not a ribbon of beige pixels. Everything the renderer, validator and editor need is in the text.
Open grassland compiles to a few statements; a suburb runs long. Across all 108k real tiles the median body is just 272 tokens, the dense urban tail runs to ≈8,900, and <END_TILE> lets each tile decide its own length.
A suburban tile can hold 400–800 footprints — enough to drown the context window. v1 carries settlements as land-use polygons; a second-pass decoder will place buildings later.
Neighbouring tiles don't negotiate their shared border; they reference the same object. Each border's height profile is fitted once, from the global elevation model, and both tiles inherit it. A Coons patch stretches a surface between the four profiles, and interior hills are multiplied by a window that falls to exactly zero at every edge. Drag the slider — the interior can do what it likes; the seams cannot move.
The generator is a deliberately small GPT-style transformer — an 8-layer, 512-dimension, 8-head design totalling 33.7M parameters, not billions — because the representation, not the model, carries most of the intelligence. It reads the neighbours and their contracts as context, then emits the new tile's program one token at a time.
Every existing neighbour's program, tagged with its edge, plus the extracted contracts — rotated to a canonical orientation so one network serves all configurations.
Causal attention lets each new statement consult every neighbour and everything already drawn. A KV cache keeps repeated decoding cheap.
Statements stream to the browser as they are sampled — terrain first, so ground appears in under a second — then the validator enforces every contract before the tile is accepted.
The context window is 8,192 tokens, and it was sized from the corpus rather than guessed. Measured across all 108,173 serialised tiles, the median tile is 270 tokens and the 95th percentile 1,648 — but the densest runs to 8,914, so four crowded neighbours plus their contracts can still overflow the window. That measurement is also why buildings are deferred to v2: hundreds of footprints per urban tile would spend the whole budget on the least interesting continuity problem.
Three epochs of single-edge training (56 min each, 2.8 h in total), then ten epochs of fine-tuning on the full multi-edge task (5.6 h more). Validation is a geographically held-out region. The gap that opens at epoch 3 and then closes is the model absorbing the harder 2–4-edge examples — it settles at 1.572 by epoch 9 and holds there, below the single-edge floor of 1.587 — a better score on the harder task.
Before serious training, a tiny model was asked to memorise 125 tiles. Train loss collapses while validation rises — textbook memorisation. That is the point: it proves the DSL is learnable and the pipeline is sound, and that generalisation is a data problem, not a representation problem.
Measured browser-to-server, three runs, local checkpoint. Honestly noted: the current single-edge checkpoint sometimes runs to its 4,500-token cap instead of emitting <END_TILE>, and road fidelity remains an open training problem — see the ledger below.
The strongest claim in this project is quiet: the language is lossless enough to matter. Below, real Victorian geography goes into the DSL and is redrawn from the text alone. Drag the divider — everything on the right survives in a few kilobytes of program.
Freeways, rail, the river, the lake, land-use blocks and the street hierarchy all round-trip. Fine local streets are simplified — deliberately: canonicalisation trades microscopic fidelity for a language small enough to learn.
The representation, the continuity mathematics, the renderer and the end-to-end loop are demonstrated. The central open risk is exactly the one you'd expect: generation quality when several contracts bind at once.
No global seed, no planet simulation. Cost scales with explored frontier, so an infinite world runs on a laptop — and any saved world can keep growing from any edge, forever.
Neural networks are probabilistic; borders are not. By moving continuity into deterministic contracts and validators, the creative component is structurally unable to crack the world.
Every road, river and forest is a named, editable statement. Select it, reroute it, re-render it in any style, or hand the same program to a different engine entirely.
Data pipeline, model, validator and renderer are separate contracts too. A better checkpoint drops in without touching the renderer; buildings can arrive later as a specialist decoder.
When this road crosses a generated seam, nothing should announce it — no ridge in the asphalt, no jump in the creek, no change in the country's character. Vector World is the bet that a small model writing honest notation, inside hard constraints, is how you get there.