Inside

Oblique is the game. Strata is the engine that plays it — a multidimensional rules engine, a from-scratch search and a direct WebGPU renderer, written in strict TypeScript with no game engine, no chess library and no imported camera controls. The constraint was the point, not an obstacle.

The constraint

Every piece of behaviour here had to be built: legality under royal safety in three dimensions, an exact undo, position hashing, a serialisation format, a renderer, a search. Reaching for a library would have answered a question the project exists to ask.

It buys something concrete. Because movement is data — a piece type maps to a primitive and a named direction set, and two primitives interpret every spec — there is no per-piece movement code anywhere, and a variant is a different table rather than a different program. The direction sets themselves are generated and frozen at load, with tests for their counts, their uniqueness and their inverses, because a hand-typed table of 24 signed permutations is a bug waiting for a quiet afternoon.

The rules engine

The domain layer is headless: no DOM, no canvas, no renderer. It runs in Node, in a Web Worker and in the test suite unchanged. State is immutable — applying a move returns a new position, and undo is its exact inverse, tested as such rather than assumed.

Legality is generated the honest way: pseudo-legal moves, applied, then rejected if they leave your own Sovereign attacked. Check, double check and pins fall out of that without special cases — and they are tested anyway, with constructed three-dimensional mating and stalemate nets, because a Sovereign with 26 flight cells makes for mating patterns that intuition from the flat game does not supply.

Position identity is a seeded Zobrist key maintained incrementally and checked against a full recomputation. The move tree is measured against recorded ground truth: 91 legal moves at depth one and 8,113 at depth two.

Two renderers, one game

The Canvas 2D layer view is the complete game and always has been: five level boards painted under a semantic grid of labelled buttons that owns every interaction, pointer and keyboard alike. The canvas is decorative; the meaning lives in the DOM, which is why keyboard play and screen-reader support are properties of the architecture rather than a later retrofit.

The WebGPU spatial projection is an enhancement over the same selection state: five translucent planes whose grid is computed procedurally in a fragment shader, instanced token solids, signed-distance selection marks, rays drawn through the lattice, a constrained orbit camera and 4× MSAA. If WebGPU is missing, fails, or is lost mid-session, the projection degrades to a single line of text and the game continues — enforced by a test that deletes navigator.gpu and plays a move anyway.

A third surface isolates one plane of the lattice — a level, a file-plane or a rank-plane — which is how you read a vertical line of attack without mentally rotating five boards. Below 640 px it stops being an aid and becomes the board itself.

The pieces are drawn from their own rules

A piece's form states its direction set. The Sentinel is two posts at the 2:1 offset it leaps by; the Lancer is a spire whose edges face the body diagonals; the Tower has one arm per planar axis and a finial for up. The flat token is the spatial model seen from above, because a flat board is a plan — so the two renderers show one object rather than two designs.

Height groups pieces by role and never by price: pawn, then minors, then Regent, then Sovereign. What a piece is worth is a research question, and the drawing is not allowed to answer it.

The opponent: Strata

Strata is iterative-deepening negamax with alpha-beta, a Zobrist-keyed transposition table, move ordering by transposition, promotion, captures, killers and history, and a quiescence search — running in a Web Worker at roughly 210,000 nodes per second in a browser tab. It never touches the main thread, and every change to the position cancels it.

Search speed came from a second board representation: a mutable make/unmake structure with packed moves and precomputed ray geometry, which took throughput from about 13,000 to about 145,000 nodes per second headless. It is a duplicate of the domain's semantics, which is dangerous, so a test suite compares the two cell by cell. That suite has already caught two real bugs.

Research, with its caveats attached

A new game has no received wisdom about what its pieces are worth, so the project measures rather than asserts. A headless self-play runner plays deterministic batches — fixed depth, seeded tie-breaking, a fresh engine per game, any single game reproducible in isolation — and records every metric as JSON and CSV.

• Removing the Regent's eight body diagonals takes the draw rate from 8.5% to 44% at depth 2 — but only to 23% at depth 4, so half of that headline was the engine's limitations rather than the game's.
• Every one of 294 decisive self-play games was won by a side still holding a Regent.
• Towers are traded off in essentially every game, because the opening position leaves both outer files open with Towers facing each other from move one. Whether they have a role is still open.
• Every batch used to open the same way — the engine repeats its move whenever only one is close enough to matter — so 200 games were not 200 independent samples, and every interval computed from them claimed more precision than the design could support. Games now open on their own seeded random line, and each batch reports how many distinct openings it really had.
• The fix then produced a sharper negative result of its own. After a random opening, the side that plays the first searched move scores about two thirds — 66.3% with a four-ply opening, 34.7% with a five-ply one — because a random line leaves material hanging and whoever looks first takes it. So the number the fix was meant to pin down, the advantage of moving first, still has no trustworthy value. It now has a measured reason.

The important negative result: symmetric self-play cannot price a piece. When both sides share a material table, a wrong price produces perfectly consistent games. Pricing needs an asymmetric match — two material tables, colours swapped every pair — which is a separate runner. It has so far settled the ordering — the Bishop is worth more than the Lancer, by 131 Elo over 400 games, against a null control that reads 50.3% — and put a floor under the gap: a ladder of matches says it is wider than the 40 centipawns the table currently uses, and cannot tell 120 from 200. Which of the two pieces is mispriced, the ladder cannot say, because it moved both at once.

The published material values remain hypotheses, and are labelled as such everywhere they appear. Presenting them as tuned would be the easiest lie in the project.

Things the tests are allowed to fail over

Some commitments are only real if something checks them, so several are measured rather than claimed:

• Contrast. All four palettes are parsed straight out of the stylesheet and their WCAG ratios computed — text, coordinates, grid lines, marks, and each side's token against both cell shades. Ordinary palettes hold AA; high contrast holds AAA.
• The type scale and the spacing rhythm. Four type steps of one ratio and one 4 px spacing step — and a test that fails if any rule anywhere sets a size or a gap outside them.
• The selection marks. Declared once as proportions of a cell, and the spatial shader's numbers are read back out of its source and compared. No two marks may be the same shape in different colours, which is checked by painting them — the check mark used to be the selection frame in another hue, which is precisely what "never colour alone" forbids.
• Reduced motion. Every animating path honours it, including one that must not even schedule a follow-up frame.

There is also a diagnostics panel, off by default, reporting what a frame costs to build and what the worker boundary costs around a search. It is off by default in a strict sense: with it closed, the call sites do not so much as read a clock.

What is deliberately unfinished

• Piece values. One ordering is measured and one gap has a floor under it; every number in the table is still a hypothesis, and nothing has ever tested the Sentinel, the Tower, or what a Bishop and a Lancer are worth together.
• A screen-reader audit by a person. Everything checkable from the DOM is checked, but no "fully accessible" claim will be made until somebody sits down with VoiceOver.
• Engine strength work — aspiration windows, extensions, late-move reductions. They wait on profiling evidence rather than enthusiasm.