← News  //  2026-09-09  //  v0.13.0

v0.13.0 - The game on screen

v0.12.0 made the editor the star. It could hold a whole mission - ships, range and script under one tree - and save it as a mod. What it had to place was another matter. A hull cell was a cube. A point-defence mount was a cube with a barrel. The one modelled fleet was three ships that had shipped with a campaign. Every rock in every belt was the same rock. And when any of it fired, took a hit, or came apart, it did so in silence, because the game had never had an audio pass.

v0.13.0 is the release that puts the game itself on screen. Every section wears an authored model, and three of them move: a point-defence mount sinks into a housed pit when the guns go cold, a torpedo bay winds its muzzle iris open before a launch, and a railgun - the release's new spinal weapon - walks a charge bolt up its bore before the slug leaves. The base game's ships are now block hulls the game can draw itself, with a grammar that says where a part may stand and an editor button that generates a hull into the ship you are inside. A scenario places a planet by type and seed, and an asteroid names the material it is made of. And all of it makes a sound: a re-recorded set twice the size of the old one, positional in the world and structure-borne through your own hull.

Underneath, every number moved to meters. Content, code, the editor, the wiki and the scopes all read in the unit a pilot would use, and the flight model got a budget worth reading: RCS reaches 100 m/s at 5 G whatever the ship weighs, and GOTO parks off a target's surface measured from your own hull.

The railgun

Every weapon before this one traversed. A turret slewed onto a target and a bay's torpedo steered itself; the pilot's job was to get within reach and let the mount do the aiming. A railgun has no traverse. It fires down the axis of the section it is built into, so the ship is the mount, and aiming it means flying the hull onto the line.

Commit, then release

Tapping the trigger commits. A charge bolt starts walking the bore from the breech, the rails light behind it, and 1.5 seconds later the slug leaves - whether or not the nose is still on the target. There is no cancelling a commit. The tempo that gives a railgun is the whole weapon: you line up, you commit, and for a second and a half you hold the line while the ship you are flying keeps drifting off it.

The gun holds one shell. A spent lance gets it back on a twelve-second idle reload, drawn on the same ammo gauge a turret or a bay carries, in the slug's pierce blue, so a spent shell and its long reload read at a glance.

What a slug takes

A railgun slug does not stop at the first section it meets. It rakes a corridor three cells wide through everything in line, gutting hull sections and crippling the big drives, until the power it carries is spent. Power, not a layer count or the bore, bounds what one shot takes - the same rule that made Pierce rounds a rake in v0.11.0, at a scale where a single shot can open a capital hull from bow to stern.

Two lances ship. The standard one is priced to cross a warship: 300 damage per section, 1,800 power, a 10 m rake. The siege lance is the same gun at capital grade - 500 damage through 360,000 power and a 30 m rake - and the description says what it is for: a scripted capital, not a balanced duel.

With weapons hot, a railgun draws its line of fire: a pierce-blue thread down the bore, ringing every section the shot would destroy, dimmed but still there through the reload. It is the sight a weapon with no traverse has to have. The ring is the promise; the shot keeps it.

The gun shoves the ship

Firing a railgun shoves the ship that fired it. The impulse lands at the muzzle, not at the centre of mass, so a lance mounted off the ship's axis yaws the hull as well as pushing it back. A generated ship seats its bow gun on the keel for that reason, and a hand-built one that bolts a lance to a flank gets what it asked for.

The bore and the wake

A charging railgun lights its own bore, and a fired slug leaves an ionized wake: cyan haze along its path, violet filaments through it, gone in half a second. A blue light rides the slug and lights the hulls it passes. Low draws neither. The wake was tuned on a bench of its own - three slug speeds under three lifetime policies, every knob live and in slow motion - because a half-second effect that reads at 1.5 km is not something you get right by guessing.

Cover breaks a lock

A lock is a radio link, and rock stops radio. A contact behind an asteroid or a planetoid cannot be locked, and cover drifting across a held lock breaks it. Hostiles lose you the same way - the AI's acquisition asks the same question of the same world, so a hostile cannot pick a ship it has no line to either.

Combined with a weapon that reaches 18 km and needs a second and a half of held line, cover becomes a thing to fly for. A belt is somewhere to fight from now, not a backdrop to fight in front of.

Every section is a machine

Until this release the thruster was the only section with an authored model. The rest - the hull cells, the controller core, the point-defence mounts and the torpedo bay - were placeholder cubes with the right sockets and a greeble skin closed over them. The skin did a lot of work. It could not do the work of a part that moves.

Every section now wears a model at the thruster's standard, and the cubes are gone.

The PDC stows

A point-defence mount out of combat sinks into a housed pit and two lids slide shut over it. It deploys on weapons hot, a tracked target or a point-defence assignment, and it cannot track or fire until it is fully up. A ship at rest is a ship with its guns put away - and the beat between the threat and the first round is now a beat you can see, and hear.

A twin PDC mount ships in kinetic and pierce beside the gatling: two muzzles, each at half the single mount's rate, so either choice spends ammo at the same total rate. What the twin buys is coverage - two offset streams instead of one

• not damage.

The bay has doors

A torpedo leaves through the bay's muzzle iris. The petals wind open before ejection, the round slides its whole length out of the tube, and held fire keeps the doors gaping. The v0.12.0 cold launch - a torpedo dropped inert and lit clear of the hull - now starts with a machine opening.

The bay is a 1x1x2 tube now, with an unlinkable muzzle face; an authored ship seats one with a half-cell shift so it sits on the section grid. This is a format break, and the compatibility notes say how to move a bay.

Three hulls, one stat line

The hull ships in three same-stat builds - personnel, cargo and tank - so a flank can say what the ship carries. Nothing about the numbers changes between them; what changes is whether a hauler reads as a hauler.

Cladding flies

Cladding shot off a hull flies. A spent skin plate comes away where it stood, takes its greebles with it and tumbles clear on the ship's own motion, instead of vanishing the frame it died. The hull underneath is what is left, which is what an armour skin was always supposed to mean.

The game builds its own ships

The base game shipped three modelled ships for eleven releases - the Racer, CargoA and CargoB - and they were the reason every menu backdrop, every scenario and every wiki figure needed a fleet that had come with a campaign mod. That fleet has moved into The Ledger, which now carries its meshes itself, and the base game ships BLOCK hulls only: ships built from the sections above, that the game can draw for itself.

Eleven block ships join the catalog - a cutter, a hauler, a gunship, a raider, an industrial carrier, a stolen warship and five cleanup craft - plus four wreck fragments of the carrier. Every main-menu backdrop flies them now, and no backdrop needs a modelled ship.

A grammar says where a part stands

The hull generator collapses a hull from a grammar - a draw table of parts, weights and aims. It could say which way a part pointed. It could not say where on the hull it stood, so a generated warship could carry its drive at the bow and its gun on the stern and be, by every rule the collapse knew, correct.

A grammar now pins a prototype to a zone - the bow, amidships, stern, dorsal, ventral or flank third of a hull - for every cell of it. And it seats a spinal gun with bow_gun: the lance stands on the bow of the keel and the mirror makes a pair, so the gun the arena used to bolt on after the collapse is a role the grammar asks for. The collapse also places multi-cell parts whole - a torpedo bay or a 5x5x3 capital drive as one block of tiles, mated and cleared together - instead of skipping anything wider than a cell.

A grammar the collapse cannot run - a grid too big, too thin, or too small for its own seeds, a negative weight, nothing priced above zero - is refused by id at lint AND at load. A grammar is content now, and a new id adds a hull line the editor picks; standard_hull retunes the shipped one.

Generate a hull into the ship you are in

The editor generates a HULL into the ship you are inside. Name a seed, tick which sections the collapse draws from, and it replaces what that ship holds. The biggest drive you tick is seeded as the generated hull's main engine and the biggest railgun as its bow gun, and the grid grows to hold both. A HULL PLAN line names what the ticks chose. A ticked row carries a zone chip: press it to cycle where the collapse may stand that section. The Generate block picks a HULL LINE - a row per grammar in the merged content - and the draw list re-ticks to the picked one.

A hull the game's lint refuses never lands. And a weapon takes its own key when it is placed or generated - Space thrusts, LMB the PDCs, F the torpedoes, R the railgun - so a generated ship set to Player flies without rebinding a thing.

The world has bodies

A planet is a planet

A scenario places a Planet: a type and a seed draw a world with terrain, biomes and a cap. Six types ship - barren rock, dust world, ice world, volcanic, greenhouse and one temperate - as archetypes rather than places, because the fiction is not the Solar System. A type says what a world is made of and the scenario says what it is called.

A planetoid used to be a big Asteroid, and it was as destructible as a small one, which meant a patient pilot could carve a crater into a world. A Planet must author invulnerable: true. A destructible one is a lint error and refuses to load: nothing carves a planet, so it would sit there taking hits and never break.

Rock is a material

An asteroid's material names its KIND: rock, metal, ice, carbon or plain. Each gets its own palette, strata and specular over a triplanar surface, so a belt reads as several materials instead of one repeated rock. ScatterObjects takes asteroid_kinds, a weighted mix drawn from the scatter's own seed, so one field is mostly rock with a little metal, and the weights are relative counts - [("rock", 24), ("carbon", 5), ("metal", 1)] - not percentages that have to add up.

The material is required and there is no default. A rock without one fails to load, and an id nobody ships is a lint error.

Shooting a rock throws rock. An asteroid states its material on the body while a crater is cut into the mesh beneath it, so every chip used to come off as the white-hot ship plate a hull sheds. Now stone spalls stone, and a slug landing on ice sounds like a slug landing on ice.

The game has a voice

This is the first dedicated audio pass. The sound set is re-recorded and twice the size: guns, ordnance, impacts, destruction, drives, cockpit, menus and editor, all synthesised from scratch. Only the ship computer's family is untouched.

Where a sound is

Sound is positional. A cue out in the world falls off with distance and pans with bearing, so the menu backdrop's traffic is heard passing the camera instead of sitting mute behind it. Your own ship is the exception, and it is an exception by routing rather than by special case: its guns, its drives and the damage landing on it are structure-borne through the hull you are sitting in, so they never attenuate and never pan. Everything else is out there across the gap.

What a hit sounds like

A hit is named by the round as well as by what it struck. A slug, a penetrator and a warhead each land differently, and each lands differently again on stone. Machinery has a voice: a PDC's housing rising and folding away, a bay's iris winding open and shut, a railgun's capacitor bank filling, discharging and re-chambering. A ship coming apart has its own sound, separate from the last section on it failing.

Every cue below is the file the game plays, drawn as its own waveform. Press a key and it plays through this page's speakers - a board per family, in the order a fight would meet them. Sixteen rows carry a second, amber key: the v0.12.0 recording of the same event, the file this release replaced, so the two sets can be heard against each other.

The drives are told apart by pitch: 34, 52 and 78 Hz from capital to basic to vector, because pitch is what survives a firefight and a pilot should know what is burning without looking.

The cockpit talks. A lock taken or lost, a denied or retargeted radar, the safety, a dry magazine, a hostile's lock arriving, and the hull dropping past thirty percent each have a cue, so the things the HUD used to say only in text now say themselves.

The menus answer you too: a tick as focus moves, a note for stepping back, and a sound for losing. The editor's four cues and the objective chimes were written to join the NOVA OS terminal's family, which is the one this release left alone.

Four sliders

Four volume sliders - master, interface, world and music - are saved with the rest of the settings. Music is reserved: the bus and its slider exist so the settings format carries it today, and nothing routes to it yet.

Flying it, in meters

Everything is in meters

Content and code are authored in meters through one set of quantity types. World units - one of which is 10 m, and one build-grid cell - appear only at a Bevy, physics, rendering or build-grid boundary, which says so locally and converts. Every player- or creator-facing figure prints in meters: the editor's inspector and gallery read and write lengths and speeds in meters, a section's own mesh rows read in build-grid cells, and every wiki figure, scope and catalog reads the same way.

This is the release's quietest break and its widest. A number in a shipped mod that used to mean world units now means meters, and The Ledger and Gauntlet Run are republished to say so. A portal mod installed on 0.12.0 carries the old numbers, and this build reads them as meters - the compatibility notes say what to update.

One RCS budget

RCS reaches 100 m/s at a mass-independent 5 G: one speed budget and one acceleration budget for every direction. The old RCS was a force, so a heavy hull nudged and a light one leapt; the new one is a true acceleration, so every ship in the game answers a fine adjust the same way, and the cap is a sphere the result is clamped onto rather than a line per axis. At the cap RCS may still TURN your velocity - it just cannot grow it. STOP below that speed brakes on RCS without turning the ship.

The 8 G turn limit is now a limit. Holding the stick pins a ship at the hardest turn its hull survives, and a ship that loses its nose speeds up to the sharper turn its shorter body allows. And a ship's speed cap governs its TOTAL speed, so turning to a fresh heading and burning again no longer stacks a second cap's worth on top of the first.

GOTO parks off the surface

GOTO used to park a fixed distance from a target's centre. A warship and a shuttle sent to the same mark would stop at the same point in space, which put the warship's bow somewhere inside the mark. GOTO now parks a margin off the target's SURFACE, measured from the ship's own hull: a warship and a shuttle sent to one mark stop the same distance clear of it.

To do that, GOTO sizes every target it can. A beacon's orb and another ship's hull push the park point out the way an asteroid's geometry already did; a bare position still has no size. A GOTO that ends at a planetoid arrives on a ring ORBIT accepts, so the parking handoff no longer burns the ship back outward to reach a legal orbit - and it parks itself in orbit only where the ship's computer grants ORBIT, handing the ship back at the standoff where the verb is withheld.

New Game is Basic Training

New Game starts Basic Training: a Fleet gunnery range where Range Control talks a cadet through the helm verbs, GOTO and ORBIT out to a planetoid and back, the gun, five hulks and two drones that go live. It is the game's first proper first hour, and it is built entirely from the release's own parts - the block fleet, the planet, the comms channels and the cinematic actions below.

The game ships no campaign. The nova_protocol campaign and its five chapters are gone, and the story is being rewritten from the ground up; when it comes back it will come back as a mod, on the actions this release added for it. A mod that named one of those chapters has to be retargeted.

Comms have channels

A comms card is drawn in its channel: work traffic in transmission blue, the crew in phosphor, and a guard-channel catch faint, amber and tagged GUARD. The cards are screen-relative with 20 px text and distinct speaker headers, and a new line fades in without growing across the screen edge or the transcript, so objective guidance reads over clutter. Base content ships two portraits - the player's own label and Range Control's face - reachable by any mod as dep://base/portraits/<name>.png.

A completed objective no longer ghosts green down the right of the screen. Its chip leaving the top of the stack, under the completion chime, is the whole cue.

Every main-menu backdrop flies the block fleet now, and a menu duellist that leaves the arena forfeits: it goes neutral, and the survivor drops the chase and comes back to the middle of the shot instead of trading fire past the frame edge.

NOVA OS gets a second shell

Press : anywhere - menu, editor, flight, pause screen - and the ship computer opens on a second shell. One CRT, two languages: commands switches, and each keeps its own transcript and history. The first shell is the NOVA OS you know, the diegetic terminal. The second reads the run and writes your settings.

The command shell holds 27 commands in four classes. Utility commands control the shell or load another scenario. Read-only commands observe and never mutate. Setting commands change the same persisted settings the panel does. Cheat commands change the live world, and are refused until you run cheats enable, which marks the run one way and turns the header amber. A fresh scenario is a fresh run and clears the mark.

help and Tab completion come from one registry, and Tab offers the ship and section ids the world holds NOW - so a cheat that names a section names one that exists.

Settings > Controls also gains a MOUSE group: separate look, RCS and free-camera sensitivity sliders that reach a ship already flying. Mouse look now defaults to two-thirds of its old gain.

A scenario can direct

The modding vocabulary grew more in this cycle than in any before it, and almost all of it is about one thing: a scenario being able to stage a scene. Basic Training is written on it, and so is the story that replaces the campaign.

Cinematics

Cinematic plays a beat chain as a scene the player may leave, reporting OnCinematicFinished on every path out and OnCinematicSkipped first on a skip; CancelCinematic ends one early. A Cinematic filter matches an ending by its scene key, so a scenario with two scenes answers the right one, and an unplayed key is a lint error.

SetCameraAnchor rides the camera on an object at a local or world offset, facing a point or another object, so a cinematic keeps the player's ship in frame; ReleaseCamera hands the view back. SetCamera and SetCameraAnchor take an optional blend - seconds and an easing - that turns a cut into a move that keeps tracking its anchor. CinematicTitle posts a shot's title card in an authored screen corner - location, stamp and one line - and expires on the scenario clock, so no handler has to take it down. SuspendPlayerControl and ResumePlayerControl give a scene explicit, teardown-safe authority over the stick.

Helm orders

Six actions take a ship's helm: MoveShipTo, ForceAlign, StopShip, PatrolShip, OrbitShip and ClearShipOrder. One order at a time, under a named key, on a None- or an AI-controlled ship. An order on an AI ship outranks the bot: the AI stops flying and keeps shooting, and order_interruption lets it break off for contact or damage, then resume the same order where it left it. Five events - OnShipOrderComplete, OnShipOrderInterrupted, OnShipOrderResumed, OnShipOrderCanceled and OnShipOrderFailed - report an order by key, ship and kind through one ShipOrder filter.

SetAILeash, SetAIEngageRange and SetAIPointDefenseRange retune an AI ship's tether, detection reach and point-defence reach at runtime, and an armed AI ship can stand down: non_combatant: true flies its routine and never acquires or fires.

The rest of the vocabulary

NarrativeCue replaces StoryMessage, and every line authors a channel - "comms", "crew" or "guard" - which is how a mod authors a band of its own instead of borrowing the base three. PlaySound plays one authored cue in the cockpit on the Interface or Hull route. SetInfiniteAmmo and RefillAmmo reach a live ship's magazines, which is what replaces a player controller's infinite_ammo field. ForceTorpedoFire names ONE bay and ForceRailgunFire one lance. OnGotoComplete, OnStopComplete and OnOrbitLap let a scenario react to the player's real autopilot. A Railgun is a section kind and a Grammar is content. And a catalog entry can set enabled_by_default, so a fresh install with no saved set switches that mod on.

content lint checks all of it - a helm order's ship and key, an empty patrol route, an orbit's well, an AI constraint's ship, a forced shot's section id and class - and reports each scenario's creative map, the world-injecting actions it runs, as context on the report.

Underneath, one TABLE declares the action vocabulary. A row generates the enum arm, the dispatch, the RON name, the menu label, the id stem and the injection class, so a new action is five edits, not fifteen. That is the reason this cycle could add thirty of them.

The editor writes many mods

The editor writes as many mods as you name ranges, each an editor_-prefixed bundle of its own, instead of the one editor_save slot every save replaced. File > Save As names the file - type a name, and the window says which slot it derives and whether a range you already saved is there. File > Open lists what there is, and a row opens it. A document remembers its file: the first Save asks for a name, every later one writes back to it, and New Scenario forgets it so a fresh range cannot land on the last one.

File > New Scenario also asks which world to start from: the free-flight range, a duelling arena of rock rings around an empty middle, or nothing at all. And the editor places a rock by KIND: the inspector's Material row is a pick list of the shipped kinds, and the body on the stage is rebuilt in whichever one you pick.

Death is an event

A section death used to be a few sparks and the cell cut loose. A death burns now: a white flash, then incandescent fragments that outlive it and keep travelling, and light on the hulls nearby. A section going up is a compartment; a hull letting go covers the wreck. The two are different sizes because they are different events.

A torpedo's detonation is twice the size and burns three times as long: a bigger core, ejecta thrown out past 100 m, and a flash that reaches 1.4 km. And debris turns about its own shape - a piece cut off a hull used to spin about the section's origin until its collider landed, so an off-centre part swung wide and then snapped straight.

An agent flies it

The process channel has driven the game's own tests for several releases. This cycle it got a pilot. bench play seats an agent at the channel - a scripted baseline, pi with any model, or any process on a unix socket - and scores the run from the game's own state.

What the agent reads is a pilot's view, not a census. The bench condenses each snapshot into meters - bearings from the nose, contacts, beacons, mounts - and near and in-the-way bodies carry in full while the rest is one line per band and quarter; observe {"expand"} reopens a group. The manual is five game pages - targeting, weapons, travel, orbit, fighting - read on demand through a page tool instead of riding in every prompt. Every line both ways lands in an audit.jsonl beside the score.json.

The score is honest about what it grades. A run that armed NOVA OS's cheats is scored as cheated. Unparsable wire lines are counted rather than treated as refusals. An objective completed between two samples is credited from the flight log. bench replay feeds an audit's wire lines to a fresh game and grades the end match, close or mismatch.

One turn of a real audit, from a bench play of Basic Training with a hosted model at the keyboard. The view is what the referee condensed for the agent - bearings from the nose, distances in meters, the same things a pilot reads off the HUD. The act is what it sent back, and the frame after is the game's echo of what ninety ticks consumed.

tick 1001   game 16.7 s   Trainer Seven   speed 0 m/s   hull 4240/4240
  beacon     ALPHA            bearing [0.0, 0.0]       900 m
  contact    Range Drone 1    Neutral   [34.5, -4.4]   3895 m   weapons cold
  contact    Range Drone 2    Neutral   [-34.4, 5.0]   4622 m   weapons cold
  contact    Target 1         no controller   [-19.4, 6.3]   1814 m
  comms      RANGE CONTROL    Helm is yours. [W] opens the throttle, the mouse
                              steers. Burn to mark ALPHA, dead ahead.
  objective  burn             Burn to mark ALPHA

agent      ALPHA is dead ahead at 900 m. I'll make a moderate 90-tick burn,
           then coast toward it rather than accelerating continuously.
act        {"gestures": [{"press": "flight.main_drive"}], "ticks": 90}

tick 1091   game 18.2 s   held [flight.main_drive]   position [0, 0, -35.9] m
  beacon     ALPHA            bearing [0.0, 0.0]       864 m

And --record <dir> on a bench play or replay draws every tick offscreen with the full HUD and stitches <dir>.mp4 at 60 frames per second: the agent's run as a real-time movie, however long it thought.

Performance

Four measured wins, and all four are ceilings rather than trims. A ceiling bounds work instead of shaving it, which is the kind of win that survives the next capital hull.

A collapsing hull measures its pre-cut centre of mass once per frame, not once per destroyed section. A siege railgun through a capital hull spent 55 ms of one impact on that walk; now under 1 ms. A frame chips at most 64 craters of a material however many opened in it: a wide crater costs seven chips, so 448 leave at the ceiling and the 65th crater on throws nothing - a capital hull raked open used to throw about 10,000. Wreck pieces go physical two dozen a frame instead of all at once, so a hull shedding 700 sections in one instant no longer grows 700 colliders and their contacts on a single frame. And the editor stops re-walking the document each frame: the duplicate-id scan runs only when an id or a parent moves.

More in v0.13.0

The feature story above is the release, but a great deal else shipped:

• The sandbox's farthest picket mounts a railgun. It wakes like the others, but a shot that lines up on you crosses your whole ship.
• Nav beacons are radar-acquirable within 12 km, up from 6 km.
• A scenario's spawn queue may take a fifth of each frame, so a machine drawing slow frames lands its scatter in a few frames instead of one object a frame.
• Only the pane under the pointer scrolls. Every scrolling pane on screen was moving on one wheel notch, because no viewport reported hover.
• A trigger volume reports a ship LEAVING again. A damaged ship despawns section colliders inside the volume, and the occupancy count that never saw those colliders end held it inside forever.
• A flight computer severed onto a wreck aims at the wreck, instead of the hull it left.
• A COMPLETED helm order gives back the arrival_standoff it staged, as a canceled or interrupted one already did, so tight staging cannot retune every later GOTO the hull flies.
• The Gauntlet's course ship is the base cutter, so the time trial no longer depends on a fleet that shipped with a campaign mod.
• A --features debug build shows the commit it was built from on the status bar, and restamps it on the next commit.
• Every example flies on your saved settings - mouse sensitivity, keybinds, volumes, quality, skin - and only the settings panel can write them back.
• The process channel gains a command lane carrying the exact text a player would type, answered with the same result the screen prints; an input ack is now an ECHO of what a frame consumed, and the snapshot carries beacons, bodies, a mission block and the ship's autopilot, well and radar dwell.
• The wiki reads as a book - Start here, World, Ship sections, Interface, Reference - with a Railgun page carrying a corridor scope, a combat range ladder ranking PDC, railgun and torpedoes, a Commands page for the : shell, and every figure in meters. Every living still and loop is re-shot on the block fleet from a clean install.
• The site gains a lore encyclopedia and a story archive. They are not the subject of this post; the story is being rewritten, and a later post will be theirs.

Modding and compatibility

v0.13.0 breaks more formats than any release before it. Every break has a migration, and content lint names each one:

• Meters. Every length and speed in content is meters now, where it was world units. One world unit is 10 m. Multiply an old figure by ten. The Ledger (1.28.0) and Gauntlet Run (1.12.0) are republished in meters; update both, because a portal mod installed on 0.12.0 carries the old numbers and this build reads them as meters.
• Planet. A planetoid authored as a big Asteroid is now a rock. Re-author it as a Planet with a type and a seed at its true radius, and author invulnerable: true - a destructible planet refuses to load.
• Asteroid material names the KIND and is required: rock, metal, ice, carbon or plain. A rock without one fails to load, and an id nobody ships is a lint error. ScatterObjects takes asteroid_kinds; an asteroid template must author one.
• The torpedo bay is a 1x1x2 tube with an unlinkable muzzle face. An authored ship seats a bay with a half-cell shift to sit on the section grid.
• The base game ships BLOCK hulls only. The modelled Racer, CargoA and CargoB fleet and its part prototypes moved into The Ledger, which carries their meshes itself. A mod that borrowed one through dep://base/ now depends on The Ledger.
• The game ships no campaign. The nova_protocol campaign and its shakedown_run, broadside, broadside_gunship, lifeline and final_tally chapters are gone. Retarget a mod that named one.
• StoryMessage is NarrativeCue, and every line authors a channel id: "comms", "crew" or "guard". Rename and add the field.
• ForceTorpedoLaunch is ForceTorpedoFire and names ONE bay by section id. Rename it, rename id: to ship:, and add section:.
• A player controller's infinite_ammo is gone. Delete the field: a gun that should never run dry omits its ammo_capacity, and content grants the rest with SetInfiniteAmmo.
• An input ack is an ECHO, not a verdict - line, input, phase, tick. Read the effect off the world; schema is 2, which tells the two shapes apart. action is refused for good and points at the command lane.
• A Grammar the collapse cannot run is refused by id at lint and at load.

Run cargo run content lint against each bundle. The current /create/ reference owns the authored vocabulary, and the bundled content shows the migrated forms.

The terse list is in CHANGELOG.md. This post is the visible version: a weapon the ship has to aim, sections that are machines, a fleet the game draws itself, rock that is a material, and a soundtrack for all of it.

Point releases

v0.13.1 - A useful job, and a steadier hand

The cycle's first patch is mostly two things: the comic finally has a whole episode in it, and the ship flies the way the autopilot has always claimed it does.

Episode one, "A useful job", is complete. Eighteen illustrated pages follow Kaveri's crew from a routine replacement pickup through the distress call to the run home, and released Story builds now include all of it instead of stopping at the opening. The art also got cheaper to ship without looking any different - panel art re-exported at the precision its drawn size can actually show, 11.7 MB down to 10.5 MB.

The flying. Four autopilot bugs shared one shape: the leg was reasoning about a point that was not the point the ship parks at. A GOTO engaged while you were already drifting toward the target would flip tail-first and coast with the drive cold, because the leg committed to its brake before it was past the flip point. A STOP would pirouette the hull through the whole 7.5 m/s band it is allowed to accept, instead of handing the ship back at the deadband its own documentation describes. A GOTO at a tumbling, carved rock parked off the rock's centre of mass rather than the origin its size was measured from, so the park point swept around the rock once a turn. And an AI patrol judged its next leg from somewhere the arrival never puts the hull, which stranded tight routes on their first mark.

Damage timing. A spent hull plate comes off in the same step as the round that killed it again, rather than staying visibly bolted on for one more, and the frame that recovers from a long stall no longer sheds sixteen ticks' worth of plating at once - the cap bounds the frame, and the plates it holds back come off on the next one.

Under the site. The comic pipeline got the tests it never had: the reader is covered against a stand-in document (paging, fragments, contents, the panel dialog, and the wheel, keyboard and touch gestures), a balloon with a side tail draws a clean outline at any height, a speaker who is not in the episode's cast fails the build, and lettering that runs off its own panel fails it too instead of overdrawing the neighbour. A web CI job now runs all of that - format, lint, fourteen suites, the released-only build, and the Python illustration and episode-art tests - none of which ran in any workflow before.

v0.13.2 - A sky that fits

The second patch is mostly one number: the sky was costing 384 MB of video memory, and now it costs 24 MB.

The skybox was the most expensive thing in the game. Both skies shipped as six stacked 4096 px faces. Uploaded, that is 384 MB of video memory each - and the browser build paid for it twice, once on the card and once in the page's own memory. On a machine whose card was already busy, the web build never got past loading: it asked for the sky, the card said no, and the game quit at boot. The faces are 1024 px now. There was nothing in them to lose - the source is a near-flat nebula with a couple of hundred bright pixels per face - and the stack was cut into faces first, so no kernel crosses a cube seam, then each face was max-pooled at the reduction factor before the box average, which keeps the single-pixel stars a plain resize would have divided by sixteen into nothing. The sky reads the same and downloads 8.3 MB lighter.

Generate hands back a ship that can move. About one seed in forty, the editor's Generate produced a hull with no thruster on it. The keel, the bow gun, the drive deck and the drive are seeded by hand before the collapse gets a say, exactly because the roll cannot be trusted to place them - but the erosion pass read support off whatever the roll had left AROUND them, and was free to take them off again. The drive deck was the one that went, and the drive it was holding went with it. Seeded cells are marked now, and erosion leaves them standing.

A mod that stops loading says which one. A content file that failed to parse used to report only that "a content asset was not loaded" - not the mod, not the file. It now names both, and says the thing that is almost always true: a downloaded mod that no longer parses was built for an older version of the game, and wants an update from Mods > Explore online.