Voxel Space lineage · Python + Numba
A combined-arms combat sim built on the per-column raycaster the Comanche games used, with the hot loop JIT-compiled across every core. Fly helicopters and jets, drive armour, take a warship to sea, or stand a hundred-tonne battlemech up out of a tank — over terrain you can dig holes in.
How it’s built: the engine write-up →
Captured from the real render path — terrain, entities and HUD through the same
Session.draw the game runs, stepped at a fixed rate over a pinned world so every rebuild produces
the same clip.
Each class runs its own flight model, and each machine is a sidegrade rather than a rung on a ladder — speed is paid for in armour, payload or reach. The bars are scaled against the fleet’s own range, so full means “the most in the game”.
Not a skin on a tank: a two-segment leg gait with a real knee, a waist that lets the torso train independently of the legs, limbs that come off where you shot them, and a stride whose length is what actually carries the machine forward. Shown walking, because standing still hides all of it.
Damage is resolved as type against armour class, so the best weapon depends on what you are shooting at. A guided round carries a guidance type that decides what defeats it, and a restriction on what it will engage at all.
What a weapon puts in the air is derived from the weapon’s own fields, so an AMRAAM and a Hellfire look different because they ARE different. A lobbed rack round is a small boxy thing; a round that must fly a long way cruises on a wing; an anti-ship round is a sea-skimmer; a radar hunter gets long anti-radiation strakes; anything very fast is an interceptor needle; the rest is a short fat anti-armour round. Each card lists the weapons that fly that shape.
Every unit carries an intent rather than a script: it closes, holds a firing position, works round your flank or breaks contact when it is losing, and how readily it does each of those is what the difficulty dial actually changes.
Multi-stage operations briefed in the cockpit rather than on a cutscene screen, with a spoken controller calling the beats as they happen.
Terrain is generated from scalar dials rather than authored, so a world is a point in parameter space; the streamed presets turn those dials into slow spatial fields, which is what makes one continuous world hold badlands, alpine spine and atoll without repeating.
A biome is ONE registry entry with its palette, climate window and planting density as fields — which is why adding a place touches one table instead of forty. The swatches are that entry’s actual ground, rock and accent colours, and the climate window is the band of temperature, moisture and elevation in which the world decides you are standing in it.
Every one of these is a voxel model you can shoot, crash into or bring down, and each carries four facts as fields on one registry entry: how much damage it takes, whether an aircraft collides with it, what it is MADE of — which decides the sound, the debris colour and the dust — and how it comes apart. The tags on each card are those fields. Within a group every model is rendered at ONE camera distance, so the sizes are their real proportions against each other.
The world is not planted with one oak repeated. Each species is built as a base model plus procedural re-rolls, and every strip is those rolls side by side at ONE camera distance — so the variation you can see is the variation the forest has. Which biome plants which species, and how densely, is a field on the biome entry.
The terrain is a per-column raycast over a heightmap, JIT-compiled with Numba and run across every core; the GPU path casts the same field per pixel, which is what lets you look straight down over a city and see buildings rather than a tilted map. The full story, in plain language, is in the engine write-up.
Every figure here is read out of the game when the data is built — none of it is transcribed.
A dozen of them, sampled across the battery: