STARGAZER · DAY 124
StarGazer is a single-player 3D space combat game where you command massive capital warships through procedural roguelike runs — broadsides, voxel hull damage, deterministic simulation, built solo with AI assistants.
Started May 21, 2026 · last activity 6d ago
Activity & Beats
Composite of commits, decisions, and posts per day. Click a bar to filter the timeline below.
Enforce the machine-tell floor on blog prose
The dev diary now has a checklist for the habits that make writing sound machine-made, and a guard that refuses a post carrying the mechanical ones.
An accepted combat contract is an exact targeting writ
Protective contract casts choose a target hostile to the issuer. That
Local combat work keeps its exact target in the encounter pocket
A valid accepted operation can bind a fighter faster than the player's
Wreck-recovery work follows a live local wreck
Strategic claims and replacement needs can identify systems before
Marked salvage grants an exact wreck-target writ
The job explicitly asks the player to cut a marked component from a
The Quiet Lantern fits Halcyon's living logistics
In the natural Core Signal galaxy, Halcyon's production need projection
Earned charters hold one funded chapter choice
A charter presented as ready with funded choices must not lose every
Let captains retire ordinary bay modules at outfitting service
The six-slot module bay can fill through normal contract tools and
Give Measure the Storm a reachable survey window
Its naturally bound hazard appeared 3,887.5 surface units away. Even
First Watch defense gives the player the opening shot
This creates a truthful player engagement window inside the authored
First charters answer every trust-route situation
Contact standing is earned by resolving the issuer's living situations,
Disable work requires a real EMP tool
“Stay the Hand” promises to disable drives and weapons while leaving the core alive. Repeated mass-driver hull hits are not evidence of that outcome; the Arc Projector is the existing player-facing tool that produces the production adrift state. Natural finishability proof must acquire and equip that tool through the same outfitting economy as the player.
Let the player collect wreck drops at the physical hull boundary
The shipping player hull and a fresh fighter wreck establish a measured
Mission cargo comes from its named encounter
A random teaching-fighter wreck could contain the unique cipher before
Outer Crown readiness means every fitted channel is armed
Each Ascendant rack expresses a different combat identity. Applying the
Give each Ascendant warden its canonical hull integrity
The wardens are distinct ships produced by distinct stable destination
Close, match velocity, then turn the broadside
Turning at the first outer-range contact left fast targets pulling away
Regional progression covers the widest authored route
The earlier envelope was measured only on Precision. The natural
Natural survey journeys navigate around the harbor
The home signal is reachable, but the line from Tideline Exchange crosses
Generic survey work avoids encounter-gated signals
A route survey is a promise that the player can complete after accepting
A route contract may answer a player-facing trade link
First Watch deliberately opens Meridian-player route work. Applying the
A newly legal work offer gets one real decision
Player-facing work should be judged at the production decision that can
Progression clocks include the complete escort envelope
Extending escort work to cover its full physical departure route made the previous report ceilings mathematically smaller than the work they claimed to admit. The bands remain budgets, but may not declare a journey invalid for using an authored objective window they themselves permit.
Remote route surveys promise only real destination signals
“Count the Knot Nobody Admits” is travel-bearing route work. Requiring its target to exist in the already-cooked board bubble made the covert contract structurally unreachable, while admitting every remote system would advertise surveys in systems whose generated recipe contains no signal at all.
Accepting work delegates the response
Leaving autonomous resolution enabled after acceptance made the issuer solve ProtectTrade on the next strategic fold, invalidating a convoy contract before the player could reach its authored encounter. Explicit external source resolution remains a valid invalidation path.
Escort work protects a disrupted route
Living-world ProtectTrade goals are created only for non-active links. Treating every later update of that already-disrupted source as fresh abandonment made the authored recovery job fail before the convoy could complete its route.
Keep standing public work and earned private work on distinct clocks
Reposting the same public routes made the board look active while hiding an earned covert survey until its strategic need expired. The player-facing distinction is now real: public work keeps the door open; earned work is a deliberate faction decision.
Let earned work share the board with standing public jobs
The public guarantee and the earned-work decision are separate promises. Counting public rows as earned work made the first promise silently cancel the second.
Give a newly delegated job one observable turn
An offer that is created and withdrawn inside one simulation step is not a meaningful player choice, even if every internal transaction is individually valid.
Let starter assignments coexist with earned faction work
The graduation cohort teaches three kinds of work, while later regional jobs express earned trust. Making unfinished starter assignments suppress earned work turned optional onboarding breadth into a hidden progression prerequisite.
Let newly earned work survive its first decision turn
A player could earn the covert-work threshold after a faction had acted, then lose the qualifying need—or the exact route proving it—at the next refresh before the faction ever had a chance to offer the work.
Regional jobs may arrive in living-world order
Relationship progression should preserve faction agency. Requiring the data-file order would make a lawful alternate offer look like a broken campaign.
Give convoy work the full physical route window
Convoy success is owned by the final protected ship physically departing the production lane. Several contracts expired after 8,400-9,000 ticks while an intact convoy was still flying the same route that already required 18,000 ticks elsewhere.
Budget convoy work for departure, not only linger
The earlier 18,000-tick floor covered the 9,000-tick patrol linger twice, but the production success edge is later: the final protected capital must physically reach the 200-unit jump-vector departure radius. A natural run reached 19,200 ticks with the intact capital already departing but still 288.5 units from the gate. The encounter may stage up to 3,000 units from the player, jump vectors sit 2,500 units out, and the capital's live transit is about 0.28 units per tick; 24,000 covers that complete physical envelope without changing movement or completion semantics.
Give the Knot Survey the full hidden-route window
The normal capital route from the Tideline contract exchange to the bound signal terminal is about 3,900 units. Production movement and scan truth showed the prior 7,800-plus-600 window expiring while the healthy ship was still 2,508 units from the POI surface.
Delivery jobs provide the cargo they assign
Delivery briefs across Meridian, Aurelian, and Cinder describe cargo already owned by the route, account, or refuge. One private mandate could demand three rare-alloy canisters that no normal market or authored source supplied, turning a disclosed handoff into an impossible scavenger hunt.
Recover the signature trophy with the rack the journey earned
The starter capital could not damage an otherwise valid capital carrier, while a late journey had already earned the tools intended to make the trophy hunt playable. The first broadside eligibility rule also admitted a capital attacking an unrelated structure 2,107 units away; that was a live ship, but not a player engagement or a recoverable hunt.
Give Regional progression the measured physical-work envelope
An authoritative precision journey completed the required Regional work at 493,877 ticks with 12 jobs, exactly 10 combats, 9,270 credits, and 570 trust. The former 464,400-tick limit rejected a healthy route after it had met every other progression promise; 540,000 records the measured path with a bounded 46,123-tick margin rather than weakening the work.
Let a wreck hunt boost through the unresolved pursuit
The measured Auto Laser carrier was a valid hostile patrol at 2,107 units, but one ordinary sub-light dismount left it beyond the old 974-unit boost gate. The same-speed pursuit then spent all 7,200 ticks without closing or firing even though the reactor remained full.
Promote empty-board issuance inside the action budget
Factions now post overdue work through the same accountable decision path as every other strategic move.
Escort a route from the accepting board to its opposite endpoint
The player may reach a Meridian board on the partner endpoint. Targeting that same endpoint creates a local encounter after the bubble was cooked, too late to admit the encounter's exact dormant hull reserve. The route itself already supplies the truthful destination: cross from the accepting endpoint to the other one.
Put route protection at the partner endpoint
A board-local escort offer could target the already-cooked board bubble and therefore lack the exact owned encounter reserve that normal destination travel prepares. More importantly, the old rule sent every actor to SystemA, even when that endpoint belonged to its partner.
Give the Sixth Knot time to cross the authored lane
The lane encounter stages at a midpoint between jump vectors. Its capital convoy must survive combat, turn, and physically traverse several kilometers at its real thrust; the former 7,200-tick window expired with both surviving ships correctly in Depart but still two to three kilometers from their exits.
Let an empty work board claim one faction action
A captain naturally reached 470 trust and a fully legal Meridian goal, yet recurring autonomous work consumed both action slots forever and left the board empty. The job now enters through the living faction's real decision instead of a journey-only shortcut.
Reserve one decision candidate for an empty work board
The selection policy was correct only after a work candidate survived generation. In a mature living galaxy, the bounded top-score buffer could discard every IssueContract candidate before empty-board promotion saw it, leaving legal regional work invisible forever.
Refill an emptied work board at its next eligible faction turn
Posting a job used both the board's own suppression window and the much longer general action cooldown. That left a truthful empty board inert after the captain cleared a standing offer, even though a newly unlocked regional job was ready.
Depart when an authored structure objective becomes terminal
Once their objective is gone, the attackers leave; they do not silently pick a new mission.
Keep authored structure attacks exclusive until terminal
A ship ordered to destroy the relay shoots the relay first; once the relay is gone, it can turn on ships again.
Share exact structure-fire range with goal steering
Structure attackers fly into their real gun range before turning broadside.
Version rack-specific trial engagement authority
Every build now says which of its real guns it uses against each trial problem.
Carry whole-hull lethal attribution through publication
If the player's real damage earns the finishing consequence, the normal death event publishes that same tick and still knows it was the player.
Identify autonomous trial fire by the resolved weapon
Only the player's real trigger damage counts, and a replacement enemy never inherits the previous enemy's progress.
Version and hash the Ascendant counter authority
The data says both what ship spawned and how much real player damage defeats it, and replay hashes can see the difference.
Bind progression reports to the shipping FTUE artifact
The endgame report begins where the real tutorial save ended and earns everything after it twice.
End the relay attack when the relay is gone
Objective failure should be legible and final. A silent target switch after failure adds punishment unrelated to the stated mission.
Make relay pressure a committed combat job
The encounter asks the player to race visible objective pressure. Simultaneous objective and player fire turned that choice into hidden damage inflation rather than meaningful prioritization.
Translate the Outer Crown combat frame as one unit
Origin placement overlaps the authored gravity-well clearance. Moving only the relay made the objective unreachable; moving the pulse without the system well would restore continuous-plus-pulse double application.
Restore the authored Outer Crown objective geometry
Relocating only the relay to Z=-800 left every attacker 900-1,000 units from the objective despite 320/600-unit production weapon envelopes. The objective was correctly bound but could not come under pressure before a fast player victory.
Require real weapon range before a structure broadside
The prior stance looked intentional but stopped outside gun range, so the relay objective was never under real pressure despite six correctly bound attackers.
Protect manual trial credit and size Linebreaker from applied damage
A Screen kill cannot satisfy the trial's explicit manual non-Screen attribution, so allowing one before admission permanently removes a required member. The prior Linebreaker value also made the declared positive nonpreferred viability false under real damage authority.
Make structure attackers establish a firing broadside
Bow-first arrival made an attacker look bound to the relay while its broadside could never fire. A single rack-wide steering stance also hid the target-specific counter choices the encounter authors.
Separate trial combat durability from cooked hull integrity
Treating a 18.878-million-point cooked capital asset as its combat health made every counter cosmetic and turned the finale into a hull wall. Hit counts or scripted damage would not prove the player's fitted rack actually solved the encounter.
Measure five earned progression bands
Upgrade lists do not prove pacing, affordability, route clarity, combat pressure, or persistence from the actual new-player boundary.
Keep authored total wars under campaign authority
A strategic cadence should not erase hostility halfway through an encounter and strand the remaining objective targets.
Let authored counters amplify real damage
Precision rounds deliberately stop short of the core and broadside pressure legitimately loses windows to the shared one-trigger power tax. Requiring 180,000 raw hull HP ignored those counter jobs and made both otherwise-correct racks mathematically unable to finish.
Teach flight speed bands inside the starter envelope
The former 120-unit throttle and 180-unit braking thresholds predated class-aware capital flight and could never be reached by the shipping starter hull; an intermediate 15-unit correction still exceeded the real fallback Kraken. The former signal position at 320 began inside its own completion radius, so approach could complete without an approach input.
Give the relay guard an authored opening-fire window
Without an opening window, the hostile frigate's first normal Kinetic volley core-killed the pristine Kraken at tick 340, before the 826-tick bring-arc lesson could complete. Moving it to 650 units preserved the hull but exposed a second truth: the faster guard maintained a 623-to-715-unit standoff outside the starter Broadside's 325-unit physical reach.
Start the relay guard inside weapon reach, outside collision overlap
The prior 110-to-130-unit band overlapped the cooked hulls and let normal collision damage core-kill the pristine Kraken. The previously tested 650-unit band stayed outside the starter Broadside's 325-unit physical reach. The new band satisfies both production boundaries without changing hulls, weapons, or lesson rules.
Give the relay guard an authored combat-durability budget
The cooked guard has roughly 291,000 fine voxels while the starter Mass Driver removes about six per hit. The lesson requires a 35-percent wound followed by a kill, so full physical durability was mathematically incompatible with the authored lesson and practice target.
Let the relay guard land one recoverable answer
A window long enough to prevent all return fire made Restore Readiness impossible in a naturally successful run, while no window let two guard volleys core-kill the starter. The measured production timeline admits exactly the consequence the following station lesson teaches the player to repair.
Guarantee the signature Screen module on an eligible Scourge wreck
The three-rack journey searched dozens of otherwise eligible systems—and previously more than 180—without materializing its required signature fitting. Chance could make an authored progression route take hours or never finish for its canonical seed.
Let the focused mystery own the captain's scan
Guidance could point at Verdant Moon while scan charge silently evaluated an earlier catalog lead. The player flew to the named world and held the taught input, yet the selected mystery could not advance.
Open the First Watch work board without pre-choosing an alliance
The graduation choice is meant to be the player's first step into faction work. Requiring an alliance before accepting that first job makes the invitation circular and hides all three authored choices behind an unexplained locked board.
Keep trust-building public work standing on the board
A valid public job could be starved indefinitely when unrelated faction actions scored above IssueContract, leaving a captain with no production route from trust 20 to the authored 150, 400, and 700 thresholds.
Keep random salvage out of the guaranteed trust ladder
Derelict holds intentionally draw one random commodity per hold, and StarGazer has no cargo-purchase transaction. Requiring eight specific plates made the canonical fresh journey and charter depend on loot luck rather than authored skill.
Show the approach before the scan resolves
The former board photographed the same blocked state three times and mislabeled its middle frame as in-range evidence.
Let protected lane traffic finish the route
A surviving patrol kept the encounter instance active after every ambusher died, so truthful convoy-survival work could never publish its resolved outcome.
Keep contract aggressors hostile to their protected side
Meridian's Open Lane goal named the friendly player as its strategic target, which turned the authored ambushers into player ships and made truthful combat refuse them.
Bind authored trial objectives to opening encounter goals
Trial enemies now attack the relay the player is asked to protect.
Keep endgame trial authority in strict content and durable owners
The trial data says exactly what exists, combat proves who defeated it, the save remembers the reward, and the relay shows whether the cache can actually be used.
Bound recovery replay proof to serialized start authority
The game now proves the recovery journey and its recorded travel honestly, but we will not call it replayed until a fresh game process can rebuild the exact starting recovery state from the file.
Persist the exact Retry return kind
Retry now remembers whether the player actually traveled back or rebuilt the system they were already in, and finishes only when the saved fight is truly ready.
Persist and replay typed campaign recovery disposition
Recovery can now survive a save anywhere in the sequence, replay the same decision, and resume only the exact fight the player left.
Commit graduation cohorts as one reservation transaction
The three starter jobs appear together, and the sealed route case enters the hold only when the whole handoff succeeds.
Reserve encounter capacity by authored class and faction
A scenario reserves the kind and allegiance of ship it needs, and the destination translates that request into its own local slots.
Drive visual combat through semantic player input
The proof now aims and turns like a real player, and completion remains true after the tutorial advances.
Admit visual sequence frames on typed production truth
Combat screenshots now wait for the shot, hit, cooldown phase, or ready return they claim to show instead of guessing when it might happen.
Share one data-driven ballistic intercept owner
The aiming indicator and the projectile now solve the same shot from the same weapon data.
Persist campaign encounter outcomes as exact receipts
The game remembers exactly which named enemy owes which reward or replacement, and it keeps trying safely until the player truly receives it.
Resolve detached training drills from authored scenario ids
Practice now reacts to steering, braking, scanning, locking, arming, firing, cooldowns, damage, and time instead of pretending a button press performed those actions.
Replay application outcomes and the complete host boundary
A replay passes only when the game started from the same world, performed every menu action with the same result, and ended in the same complete state.
Replay paused application requests by host-drain occurrence
Menu actions now replay at the exact moment the game originally accepted them, including two separate menu passes on the same simulation tick.
Give encounter rewards stable authored owners
Rewards now belong to the exact named opponent that earned them, so another ship cannot accidentally pay out in its place.
Freeze First Watch as a strict authored curriculum
The entire first watch is now a checked data contract, and broken or incomplete lessons stop at validation instead of failing during play.
Make First Watch progress deterministic durable authority
The game now remembers what a captain actually learned, survives save and replay exactly, and does not confuse rewritten instructions with changed gameplay rules.
Treat narrative prerequisites as typed consequence consumers
A promise made in one conversation only counts when some later system actually listens for it, and the full opening cast cannot vanish unnoticed.
Publish First Watch completion once and render it from sim truth
The game now knows exactly when a lesson was learned, shows the right live control, and opens real work only after the captain earns it.
Enroll First Watch once and measure time to success locally
Internal testers can measure where a lesson slows down, while normal players stay unenrolled and no report can invent a failure the game did not observe.
Keep progression admission and acquisition on durable owners
Final equipment and the route it opens now use the same ownership and purchase rules as the rest of the game.
Replay guarded application requests at named boundaries
A menu click is now a recorded request that the game applies once at a safe moment, and travel can prove which request started it.
Bind replay to exact host operations and authored durable authority
Replays now repeat the exact screen and jump operations they recorded, old guard victories keep their cipher reward, corrupted reward saves fail safely, and Outer Crown tells the captain exactly what prerequisite is missing.
Bind replay to typed screen state and exact campaign receipts
Replays reopen the exact story and faction views the player saw, guard defeat becomes true when the guard dies, and malformed campaign receipts stop at load instead of becoming hidden future state.
Make resolved narrative identity replay authority
A replayed call must connect to the exact real conversation; a blank or invented channel cannot count as the same screen.
Make First Watch audio expectations explicit
Every important training moment now states whether it should make a sound, so intentional quiet cannot be mistaken for forgotten audio.
Commit graduation cohorts before notification
The first three jobs now arrive as one durable handoff, and a save cannot lose or duplicate part of it.
Rebuild recovery replays from an embedded shipping save
A retry can now be replayed from the exact saved loss in a fresh launch, including whether the return stays local or crosses the map.
Make the Ascendant trial an objective fight, not a health wall
Endgame combat should ask the player to prioritize, position, and protect something under pressure. A single oversized target would test only damage output, while a direct fitting grant would bypass the progression economy.
Retry locally when the tow harbor is the death system
Sending the player to the system they already occupy creates a false journey and can leave recovery waiting for a travel event that can never happen.
Let the player choose Retry or Retreat after campaign death
A debug Reset erases the consequence and a generic respawn hides what the player is choosing. Two explicit dispositions let failure preserve progress while keeping the strategic cost, route, objective, and next action understandable.
Graduate into three equal-status work lanes
Graduation needs a meaningful next direction without making one lane the obvious economic answer or turning the choice into a permanent class selection.
Let tutorial proof follow the fight
Teaching should demonstrate a transferable action against the encounter the player actually receives, not a capture-only spawn bearing or a momentary banner.
Show combat teaching as cause and consequence
A board made from convenient timestamps can show four technically different frames without communicating what the player did or what changed. Event phases make the mechanic legible as a deliberate action followed by a consequence.
Make unguided broadside solutions lead moving ships
Showing an in-range, in-arc solution while repeatedly firing at the target's old position makes correct player input miss and turns the first real broadside fight into unexplained attrition.
Fail forward through the first combat lesson
An unlimited replacement loop blocks progression, while accepting any death teaches no transferable weapon skill. One retry preserves the lesson without holding the campaign hostage.
Treat application postconditions as replayed gameplay truth
A replay that merely queues the same menu request can silently refuse it or remain trapped on a screen while still matching a partial world hash.
Practice is a real drill with no campaign stakes
Rehearsal should build transferable muscle memory without turning a menu into a reward exploit or asking the player to risk a live campaign state.
Teach one deliberate shot before the relay guard
Asking a new player to learn targeting, arming, firing, bearing, cooldowns, and a durable kill on one target overloads the first combat and makes failure hard to diagnose.
Make First Watch one persistent eight-objective journey
Small authoritative checks give precise recovery and measurement, while stable journey goals keep the experience from feeling like a 26-card checklist.
Award training mastery only from authoritative play
A tutorial should measure demonstrated understanding rather than time spent looking at a card. Background credit respects players who discover mechanics early, while source and order rules prevent tests, automation helpers, or coincidental world changes from pretending the captain acted.
Let conversations carry the First Watch instead of tutorial popups
A tutorial earns attention when a character reacts to what the player did and the choice changes a later surface. Detached instruction cards teach controls but cannot establish stakes, relationships, or a reason to care about progression.
Graduate the captain into work, then into the charter
The first hour needs a clear rhythm: learn, prove, get paid, meet the person affected, then accept a larger responsibility. A contract list unlocked from the start cannot communicate growth, and a tutorial reward disconnected from the galaxy feels disposable.
Make endgame entry an earned full-rack commitment
One rare item cannot prove a build or a journey. The final trial should test a complete combat identity whose cost, power reserve, and political prerequisite the player earned through ordinary systems.
Keep Training Log actions real and practice consequence-free
The Training Log should help a captain act on mastery without becoming a hidden simulation writer or an alternate reward economy. A disposable practice surface preserves confidence and accessibility while durable campaign truth still reflects production play only.
Keep First Watch recovery local and hand off to the Crown
A failed lesson should recover where it was taught, and finishing the Core arc should point to earned faction and fitting goals instead of dropping the captain into an unnamed sandbox.
Let the action carry the training sound
A second tutorial chime after every success would flatten distinct actions into one notification language and make sound mandatory for comprehension. Visible text remains the authoritative success cue.
Graduate into three equal First Watch choices
Graduation should open a meaningful choice without one lane becoming the obvious money answer, and missing a starter should preserve the activity without repeating its one-time reward.
Hand contracts-route graduates to the next Core Echo place
A clue chain must start from an action the player can still perform, while route-specific dialogue can preserve the character consequence.
Measure progression as five earned bands
A report that starts after the opening wallet or treats a granted module as earned cannot explain the actual economic and combat journey.
Route weapon-role audio and stage real visual emitters
Torpedoes have their own voice, and the laser screenshots now contain a real laser-equipped ship.
Make objective pressure authored and combat-verifiable
The relay scan waits for a real fight, and the automated journey must win that real fight rather than editing the target's health.
Give screens and heavy ordnance different combat jobs
A loadout becomes meaningful when the player can recognize both the job and commitment of each channel. The Screen should visibly hold space against light craft; ordnance should sound dangerous before an off-camera missile reaches its target.
Teach combat through a three-rung pressure ladder
Progression should add decisions, target texture, and simultaneous pressure before it adds larger numbers. Chorus emphasizes chaining distinct combat powers against threats of different scale; EVERSPACE 2 makes build synergy and loot reconsideration part of combat growth; Rebel Galaxy builds its capital-ship fantasy from maneuver, broadside commitment, and fighter priorities. The StarGazer ladder adopts those useful principles without copying their progression economies.
Admit compiled weapon runtime rows only through executed semantic parity
A generated weapon earns runtime status only by matching something the game can actually target, pay for, fire, and resolve today.
Publish weapon runtime semantics on explicit fitted and unfitted axes
Player weapons use the rules for their actual fitting, while AI and structures get a neutral weapon rule instead of borrowing a player slot.
Compile exact weapon resource tuning before executing new resource verbs
The catalog now says exactly what every weapon resource costs, but heat and lockout still cannot affect a live shot until the game owns and persists those states.
Commit player weapon resources through one fixed five-slot transaction
A weapon shot now either pays all of its costs once and fires, or pays nothing and stays blocked.
Persist the complete five-slot player weapon resource store
Saving and replaying now brings back every weapon cost exactly where it was.
Freeze replay catalogs from the definitions the process actually loaded
Replays are checked against the weapons and world rules the running game truly loaded, not whatever files happen to be on disk later.
Canonicalize durable weapon IDs through catalog-owned aliases
Old weapon names still load, but the restored world immediately speaks only the new canonical names.
Freeze an optional compiled weapon catalog before activation
The game can now remember one valid future arsenal at startup, but it does not use that arsenal to fire anything yet.
Pair the frozen Final catalog with legacy identities before activation
Every weapon the game uses today now has one checked address in the future arsenal, but the game still fires the old weapon records.
Resolve compiled presentation metadata as an inactive host shadow
The future arsenal's look and sound instructions are now checked beside today's game, but today's renderers and speakers still use their existing catalog.
Execute penetration bias from copied projectile traits
A weapon marked for penetration now carries that rule with its projectile and gets one quarter more material-cutting depth, without changing any current shipping weapon.
Execute mount bias through authored target hardpoints
A mount-biased round aims at the first working enemy gun instead of the generic hull, and falls back normally when there is no gun left to favor.
Execute arc-breakable spinal charge through explicit program authority
Future charged spinal weapons must say that losing aim drains their charge; today's spinal weapons keep behaving exactly as before.
Execute split-target swarm volleys in stable threat order
A split-target rack now fans one volley across the nearest valid enemies in a stable order instead of putting every missile on one ship.
Close split-target activation boundaries
A split volley now promises only targets it can launch at, and the UI agrees with the shot even when the player has a structure or asteroid locked.
Keep dropped weapon modules durable until terminal ownership
A weapon floating in space now remains the same recoverable item across a full hold, a save, or a jump away and back.
Make wreck recovery source-stable and lossless
Enemy ships now carry the same recoverable weapon through a reload, and a crowded battlefield cannot erase it.
Fold wreck offer identity into deterministic hashes
Determinism checks now notice the hidden ship identity that decides what a wreck will carry.
Carry wreck-source receipts through replay tick zero
Replays now remember which wrecks have already paid out, without saving the canister index used to find them quickly.
Reserve VFX capacity per priority
A burst of hull wounds can no longer erase every weapon flash, and the overall effect budget is still bounded.
Separate wreck receipts from canister lifetime
The galaxy now remembers that a wreck already paid out even after its module is gone, and a full ledger refuses safely instead of crashing halfway through the kill.
Preserve wreck activation identity through replay
Reloading keeps an enemy's promised module, but a newly spawned enemy in the same slot gets a new identity and cannot replay the old payout.
Reject replay assignment authority that cannot bind to tick zero
Replays now reject a damaged enemy-offer record instead of quietly changing it, and large histories export in one predictable pass.
Keep custom population launches outside shipping saves
Custom battle setups now stay in their own sandbox and cannot replace a real campaign save.
Derive hotbar arc and range from one physical mount
If the hotbar says a mounted weapon has both arc and range, one real surviving hardpoint can actually take the shot.
Publish wreck-offer authority with the travel transaction
Building the next system can no longer change this one, and arriving or continuing keeps every visible carried-weapon offer stable.
Keep population provenance outside replay authority
A custom battle setup can no longer be mislabeled as an ordinary reproducible start just because its final numbers match the defaults.
Make development launch persistence fail closed
Test setups now stay outside real campaign saves, while normal game, campaign, and product choices keep saving as before.
Separate MCP replay authority from shipping persistence
Developer control can record a clean New Game without touching the player's campaign, and a damaged replay cannot invent an impossible weapon lockout.
Sample weapon readiness at dispatch and publish lockouts at the returned tick
Green now predicts the shot being processed, and saving does not make the weapon wait an extra tick.
Enforce spinal power tax at player delivery admission
The last locked tick is really locked, for ship and structure targets alike.
Version replay behavior independently of the extraction oracle
Recorded battles now carry a version that changes whenever their rules change, even when the usual simulation benchmark does not notice.
Preserve restored weapon delivery state across physical rebuilds
Loading a save keeps the charged shot you saved; jumping systems deliberately clears it.
Consume render-frame edges once across accelerated simulation batches
Faster play advances the world more often, but a button press still happens once and every real shot gets one visible flash.
Queue render-frame input edges by simulation generation
A quick button press between simulation ticks happens once in the right world, never zero times or twice.
Freeze replay compatibility at generation start
A recording keeps the exact game era and charged-trigger state it started with, or it does not export.
Freeze replay compatibility around content load
A running game records the exact content it loaded, while broken developer metadata can never stop play or damage a save.
Bound queued camera edges and preserve them across covered ticks
Menu transactions do not eat or fire queued controls, and a burst keeps the eight newest aimed shots in order.
Bind replay compatibility to loaded pack chains
A replay now names the ships the game actually loaded and rejects impossible weapon state before touching the world.
Apply flash accessibility at the weapon snap layer
Flash-reduction settings now cover every weapon burst without hiding the shot, its sound, or its charge status.
Invalidate replay after a runtime pack replacement
Changing a ship during a running session can never produce a replay that falsely claims it started with the original ship.
Rate-limit flash presentation in render time
Reduced means at most three flashes in any real second at every game speed, and changing the safety setting takes effect now without old flashes returning later.
Make flash accessibility one application-wide onset authority
Every bright effect now obeys one safety budget, settings only make an existing effect safer, and dimmed lights also finish sooner instead of lingering.
Settle composite flash onsets at one render phase
One visible event spends once at the moment rendering can actually present it; old sparks never return, but genuinely new later weather can follow the player's current setting.
Coalesce VFX lights only within one accessibility policy
Combining nearby flashes can no longer hide a bright new light inside an already-dimmed one.
Bind terminal signal capacity to the supported resident fleet
Every ship in the largest supported battle can die on the same tick without its death event being dropped.
Dispose caller-owned scene render resources as one aggregate
The game now closes every scene graphics resource exactly once, in dependency order, even when one cleanup operation fails.
Treat direct and ambient ships as one resident budget
Direct enemies and living-world traffic share one fleet, so asking for more of one leaves less room for the other.
Size relays from complete same-step producer envelopes
Event buffers now account for everything that can happen in one tick together, not just the biggest event source in isolation.
Own scene GPU resources from construction through shutdown
Every graphics object has an owner from the instant it is created, and one cleanup failure cannot strand everything that follows it.
Validate resident population before construction work
Invalid fleet sizes fail before the game allocates or changes anything, and every staged battle gets one intentional population budget.
Preserve one complete supported event-log boundary
A huge battle may push out old history, but it cannot erase its own opening events while they are still arriving.
Surface shutdown errors only after framework teardown
Shutdown reports failures only after the engine and window have actually finished closing.
Make GPU construction and disposal transactional at every owner
A graphics bundle now appears all at once or not at all, and cleanup always attempts every piece even if one piece fails.
Derive one ordered weapon runtime program before expanding content
Every weapon now reaches combat through one clear sequence of actions, so a larger arsenal can grow without different systems interpreting the same gun differently.
Keep projectile impact and counterplay orthogonal for the full lifetime
A shell can now keep the damage behavior it was designed for while separately stating whether defenses can shoot it down.
Derive one fixed player weapon binding table per catalog boundary
The player now has one five-slot combat wiring table, rebuilt only when equipment or definitions change.
Resolve weapon presentation through one live catalog boundary
Every visible and audible weapon identity now comes from one live presentation card, refreshed as a complete set whenever the weapon catalog changes.
Compile weapon catalogs as immutable validated artifacts before runtime cutover
We can now build and inspect the whole future arsenal deterministically, but the live game will not use it until each promised behavior has a real executor and proof.
Give non-ship swarm targets fixed guidance points
Missiles now make the same rising, staggered turn toward stations that they make toward ships.
Bind durable replays and impacts to current physical identity
Weapons now keep aiming, damage credit, and effects attached to the same real target and gun even through arrivals, repairs, departures, saves, and replays.
Bind replay starts to the complete world recipe
Replays now refuse unrecorded setup changes and know when any part of their starting world has changed.
Build one thousand weapons as families, not stat rolls
A thousand names and number tweaks would be noise. Each weapon must change play, counterplay, and presentation while its family teaches a logical path from an introductory lesson to an expert decision.
A weapon announces commitment in its own visual language
Families are not meaningfully different if charge is invisible or if every muzzle and impact collapses to the same purple treatment. The pre-fire read is also combat information: it tells the player what is coming and when commitment becomes dangerous.
A full weapon bay refuses without erasing the find
A rare weapon should never disappear because the player approached it with a full rack, and a refusal must not masquerade as an inventory mutation.
A weapon and its fitting answer different questions
Real variety needs families to change firing behavior without turning every installation and progression rule into another weapon special case. Separating the two lets one tactical idea receive coherent fittings and marks while the rack remains understandable.
Every owned weapon is one persistent thing
Ownership decisions only matter when the gun the player found is still the same gun after every boundary. Stable identities also make duplicate fittings meaningful and let future marks merge without guessing which copy changed.
The starter teaches four active roles and one meaningful empty slot
A legal but incomplete rack teaches the role of every baseline channel without pretending the end-game siege slot is free. The empty Spinal is an aspiration and a visible outfitting decision, while separating digit order from firing priority keeps interface familiarity from deciding combat outcomes.
Empty weapon channels are a reversible fitting choice
The empty starter Spinal is only meaningful if the player can make enough reserve room to fit one later. Old full-bay saves need the same recoverable choice without violating the fixed 5+6 rack or trapping the historical Rail Lance forever.
Keep the mouse pointer independent of prompt modality
Last-used input answers which prompt is useful, not whether an attached mouse still exists. Hiding the pointer made mixed-device play feel broken and let controller noise erase a basic desktop control.
Give campaign cargo a distinct data identity
The encrypted reward now stays visibly itself from the wreck to the sale counter, and the game states exactly what will happen before the player commits.
Project one data-owned refit workspace
Refitting now shows what a module does, what it replaces, and what it costs before the player commits, while the story and ship data stay in charge.
Evaluate transaction facts before campaign presentation
A completed refit now updates the ship, wallet, and next story objective as one truthful action before the refreshed screen appears.
Anchor the combat command stack to stable geometry
Target identity, ship status, and combat controls now stay in distinct readable lanes while urgent warnings get the screen to themselves.
Give authored openings first claim on fleet slots
Story-critical arrivals now take the stage before background traffic, so a set-piece cannot quietly begin with part of its cast missing.
Preserve authored structure components independently
Multi-part landmarks keep every authored mass through damage while fresh breakaway pieces still separate normally.
Put the shipping orbit yaw in strict interface data
The opening flight angle now lives in validated presentation data, while purpose-built scenes can still choose their own view.
Separate travel reels from destination sequences
Built-in animation checks can now wait for the destination battle instead of recording only the journey there.
Give the weapon bus one geometry authority
The cards the player sees, clicks, and tests are now the same rectangles.
Compose the left flight instrument from returned geometry
The damage panel reports where it really is, the flight panel docks to it, and every downstream HUD owner sees the same combined rectangle.
Give top-left resources one geometry and state authority
Credits and cargo now share one truthful instrument, and every neighboring HUD owner uses the same rectangle the player sees.
Give target command one geometry and state authority
The target data, its actions, mouse hit areas, automation tree, and tests now agree on one truthful instrument.
Give time rate one control and layout authority
The rate the player sees, clicks, focuses, automates, and tests now comes from one truthful instrument, while the deterministic simulation keeps its existing owner.
Scale ship emission at the shared voxel boundary
All ships now preserve their authored light colors at gameplay exposure without dimming the rest of the universe.
Give asteroids a shared directional-light profile
One shared renderer knows matte rocks take less neutral studio light than capital plating, while combat light can still affect them normally.
Select transient event light once per render frame
Every nearby voxel body sees the same short-lived combat light, selected once, while rocks respond like dark stone instead of glossy armor.
Route laser light through authored VFX data
Two weapon data rows now make blue laser hits cast blue light without adding another combat system.
Carry ship material hierarchy in the scene uniform
One shared material profile gives neutral ship plates a darker range without changing faction paint or adding a second lighting system.
Put capital surface relief under hull-zone ownership
One data value now controls real voxel-readable armor depth, and the structural hull owns the large shapes instead of hoping random detail placement finds room.
Select capital massing inside the existing hull builder
One authored profile now changes the whole capital body at its structural source while every older ship stays unchanged.
Let the hull profile shroud the capital weapon
The bow armor and its biggest gun now fit together without making the weapon rules depend on the ship's appearance.
Bound HUD geometry by visible detail
The cockpit now draws the detail a player can actually see, so busy systems stay clear without hiding damage or targets.
Resolve blocked campaign copy at the presentation boundary
Gameplay decides whether scanning worked; authored data decides what the player reads when it did not.
Project the committed narrative choice from the ledger
A recorded decision now carries its exact promise and known consequences into the reply instead of becoming a generic confirmation.
Project manual UI from one production layout
The cargo screen now tests the exact controls the player sees, including empty holds and confirmation dialogs, instead of trusting a separate approximation.
Share destination identity across navigation and records
Navigation and ship records now use one source for place names, so the same destination cannot appear under two labels.
Resolve location identity at immutable read boundaries
The game keeps efficient numeric coordinates inside, then translates them once into the same names and calendar every screen reads.
Centralize Strategic Table presentation units
Exact simulation numbers stay exact inside, and one tested map layer translates them into readable labels.
Separate cargo command authority from cargo presentation
Exact bookkeeping still protects every sale and jettison; the screen translates it before the player sees it.
Resolve transient exploration identity at event capture
Events keep compact deterministic references; the log turns them into stable words before the world that owned those references can disappear.
Carry authored encounter copy through static system intel
Gameplay keeps its content key; the map receives the words authored for the player.
Keep construction proofs inside current flight-readiness rules
The screenshot fixture now builds a ship the real game will accept, and the exact labels that fit both wide and compact trays are guarded in code.
Translate target range and disable time at the HUD boundary
The game keeps deterministic numbers inside, and one tested combat panel translates them into readable range and recovery time.
Centralize render-tier distance and speed units
Exact simulation values stay unchanged; one small HUD utility makes every screen speak the same physical language.
Separate returning home from decoding the cipher
Opening station services in hostile space was premature and could lead directly to a refusal. One truthful verb per location keeps the combat payoff moving into the next playable choice.
Guide the Meridian approach before exposing station services
Arrival at the right system is not arrival at the dock. The former unconditional U prompt directed the player into a refusal from roughly 3.5 km away, while two compact MERIDIAN labels made the named destination ambiguous.
Name irreversible cargo decisions before commitment
The former Rare Alloy row and Sell 1 from the selected lot? prompt hid both narrative identity and commercial consequence at the campaign's first dockside handoff.
Turn refits into explicit decisions
A refit should feel like choosing how the ship changes, not decoding a parts spreadsheet or guessing which generic weapon fulfills the story objective.
Close refits with visible success
Automatically throwing the player back into flight interrupts shopping, while resetting to another weapon or retaining the old objective makes a successful purchase look lost or unfinished.
Make the final relay readable under pressure
Pressure only works when the player can identify the threat and the required action at a glance. Ambient chatter, clipped geometry, ambiguous contacts, or overlapping controls turn urgency into interface noise.
Preserve the authored relic silhouette
Damage should make a signature location feel wounded, not erase the authored masses that give it identity and reduce the finale to a flat blue slab.
Frame the player capital from the stern quarter
The former straight-astern view reduced a long voxel warship to an engine wall. The quarter view makes the ship itself the visual identity while preserving open flight space ahead of the bow.
Make every ship death leave a warm combat beat
The baseline battle turned six destroyed fighters into tiny white sparks that vanished behind the cold beams. Destruction needs a warm, persistent counterpoint that remains readable without hiding the hero hull or washing out the void.
Keep the campaign battle line inside the command view
The first temporal capture proved real damage but let both ships drift behind the target panel and local radar, turning active combat into lines entering from off-screen.
Make weapon impacts light the armor they strike
The old light lost most of its energy while entering the selected-light set, leaving a bright particle pasted over armor whose surface did not react.
Keep graphite readable beside faction paint
At campaign distance the graphite entered the dark filmic toe before the violet plating and disappeared into the void, even though both materials read correctly in the authored ship.
Stage campaign battles across three asteroid depths
Ten large inner bodies produced one edge rock in the real Core Signal battle; simply enlarging the quota created HUD-sized slabs before the smaller scale band produced separated depth.
Break asteroids into real voxel shelves
Radial noise made middle-distance rocks read as repeated rounded pebbles, while unrelated per-cell shades turned their surfaces into checkerboard speckle.
Keep asteroid facets readable in shadow
The edge rim preserved an asteroid's outline but could not reveal broad shelves turned away from every directional light. Raising the whole rig would brighten ships and weaken the void.
Keep cold beams visible at command distance
World-unit widths collapsed into one-pixel lines as range increased. Raising collision radius or global bloom would change combat truth or wash the whole frame.
Let campaign encounters own the command corridor
BORDER CLASH and local radio were accurate but lower priority than BREAK THE GUARD, and all three competed for the same glance corridor.
Let the Local radar label what matters now
Collision-free words were still not a readable instrument when dozens of equally loud names crossed contacts, service rings, the player marker, and one another.
Make the weapon bus state its whole command
The old 56px cards clipped MACHINE and SWARM, reduced authored names to one word, and forced the key, AUTO, and x250 into one ambiguous row.
Make flight command and hull load one instrument
The old floating THR strip and lower damage silhouette nearly collided at 1280, separated by a large gap at 1920, and left ownership, units, assist, and recovery to player memory.
Make ship stores state the limiting resource
Separate abbreviation pills hid capacity context and forced the player to memorize which unlabeled track meant volume or mass. A dense load could show fewer than its nominal units while silently hitting the mass ceiling.
Show target command only when it can act
The old TARGET / NO LOCK frame spent a prime corner on one low-value line, the action rows had separate geometry owners, and the auto-fire row advertised the wrong key.
Make time control a complete instrument
The old frame permanently occupied the command corridor but made the decision itself tiny, hid controller access, and could advertise flight-rate keys inside a map context where they did something else.
Make built-in screenshots tell the visual truth
A large lower-right slab consumed the world view only when a screenshot was saved, so the evidence misrepresented the game and duplicated facts already stored in its state sidecar.
Let representative proofs use the shipping camera
Wide 44 to 46 unit proof cameras reduced the capital to a distant test subject and could pass while the shipping view drifted. A partial "default" that retained case yaw had the same problem.
Keep the planet behind the hero event
The default crescent had become a broad clipped-white wall that rivaled the violet capital, cyan weapons, and warm impacts in normal flight and combat.
Keep ship emission below the white point
The Kraken's three blue engine materials reached display white across their entire nozzle faces, erasing the concentric core, cyan identity, and separation from the violet transom.
Keep the asteroid belt below the hero lights
The capital-calibrated key, fill, and rim pushed broad sun-facing shelves toward white, making collidable rocks look like pale props and compete with faction paint, beams, impacts, and the planet limb.
Let combat events illuminate collidable rocks
Impacts could glow and carve the target while the surrounding rock stayed neutrally lit, making the VFX read like a layer pasted over the physical scene. Full capital-plating response solved that relationship but bleached a sustained-fire target white.
Make beam color affect the hull it strikes
The beam looked cyan but cast the warm kinetic light used by projectiles, breaking the promised cold-energy and warm-consequence relationship.
Separate graphite, gunmetal, and faction paint
The authored slate entered the bright diffuse shoulder and became a pale blue-gray slab, flattening material hierarchy even though metallic and roughness data were present.
Give capitals three readable surface scales
Kraken already contained hundreds of detail objects, but most relief was smaller than one fine voxel and the normal gameplay camera reduced the ship to broad violet and grey slabs. More texture could not create readable physical depth.
Give the hero capital one continuous armored body
The old linear taper and high outboard nacelles split the ship into a narrow center keel plus detached wide plates, while the target reads as one long armored machine.
Wrap the spinal driver in violet bow armor
The exposed black battery and long separate prow pulled the first glance away from the connected cruiser body, while the target carries its forward weapons inside the same armored silhouette.
Let the capital carry the battle frame
The more-astern angle enlarged the stern and compressed the hull into the left half while the planet and empty right field carried too much weight. The broader eye makes the ship the composition without losing forward combat space.
Let every ship death leave a battle-scale fireball
The authored white-to-amber-to-ember lifecycle was already correct, but the broad shipping camera reduced a fighter death to a small isolated pop. A proportional one-third lift makes the warm event carry background battle weight without changing global exposure or hiding the capital and cold beam lane.
Keep the visible sun behind the battle
The legacy sun's broad stacked halo remained after the beams cleared and could fuse cold endpoints, a target, and the nearby planet limb into the brightest featureless mass in the frame.
Concentrate the galaxy instead of filling the void
The previous sky technically had dark space and noise, but one saturated magenta island occupied most of its bright half and the normal battle camera saw a broad rose gradient instead of environmental depth.
Let a few asteroids carry the depth
Uniform scale sampling made the belt read like same-sized wallpaper. Hard near-to-far strata improved one battle frame but moved proven campaign anchors and put large rocks across the clean hero ship, while shaping the same random roll preserves the established spatial sequence and clear corridor.
Let small rocks fall back into the void
The real collidable layout already preserves the hero, firing corridor, and campaign anchors, but giving every scale the same light value turns the small depth layer into pale clutter.
Put the structure behind the paint
The target identity depends on near-black machinery carrying the mass beneath luminous faction paint, but Kraken's largest neutral surfaces still read as pale blue slabs in the shipping battle.
Keep fleet lasers thin under overlapping fire
Several parallel shots stayed blue but occupied too much of the firing lane as one bright wedge, while removing the floor entirely made distant campaign fire collapse into hairlines.
Summarize sensor density instead of painting clutter
A tactical display should preserve decisions, not turn a populated system into a luminous knot of duplicated marks.
Give the opening command view room to breathe
The tighter view made the ship feel massive but let it run into the minimum-viewport instruments, while the old opening proof pushed it out to escort scale. The new middle distance keeps the Kraken complete, dominant, and flyable.
Give completed objectives their own voice
Major progress was visually clear but shared no audio punctuation, so an important campaign transition could feel like another line of interface text.
Replace a blocked action hint with the recovery
The campaign already authored recovery copy but the live HUD never used it. A toast was also too fragile because critical dispatch priority and slow cold starts could remove it before the player read it.
Keep the chosen position visible after commitment
The old response confirmed persistence but emptied the decision column, so the most important moment asked the player to remember what they had just accepted instead of turning it into a clear commitment.
Keep controller reach after screen entry
Reaching a screen with a controller is not real access if the screen becomes inert once it opens, and mixed-device prompts make a working route look broken.
Make the Event Log a consequence inspector
Returning players need to reconstruct what changed, when it changed, and what it means without memorizing a toast or decoding clipped rows.
Put the player's standing first
A returning player needs to understand what a faction means for their fleet now, not search a wall of equal-weight records for the relationship that changes play.
Make station work inspectable on every input
A docked player should not have to guess how to reach available work, and accessibility tools should describe the same service row the player sees and clicks.
Make contract consequences reachable on the active device
A funded offer is not a fair narrative decision if the player can read its consequence but cannot tell how to inspect or act on it with the controls already in hand.
Make actionable dispatches end in a clear player action
A world event only becomes useful narrative communication when the player can understand its cause and consequence, decide what to inspect next, and leave without guessing at hidden controls.
Carry every mystery into Dispatch
A returning player should be able to reconstruct an investigation and act on it after Continue instead of depending on a missed toast or remembering one HUD line.
Keep every named rival on the command board
A returning player should recognize who is hunting them and how the grudge escalated instead of depending on an expired hail or a render-session journal.
Report operational time, not engine time
Simulation ticks and strategic ticks are different technical domains, and neither tells a captain what can be acted on now.
Keep only interpretable battle records
A report that says UNKNOWN FORCE fought UNKNOWN FORCE preserves no consequence and makes the command board feel unfinished, while partial uncertainty can still be honest and useful.
Name every Dispatch location as a place
A returning captain should recognize a place from the strategic map without translating an internal system index.
Speak one galaxy language across every command surface
A captain should recognize the same destination across navigation, politics, work, and history without translating an implementation ID or knowing the simulation clock.
Show strategic meaning instead of storage scale
Strategic intel should answer who is present, what traffic does, and which hazards matter without requiring the player to reverse-engineer x1000 storage or world-unit conventions.
Treat cargo as custody, not database state
Exact-lot identity matters because selling or jettisoning the wrong stack is irreversible, but version counters and mixed-domain clocks do not help the player make that decision.
Describe paused time as a player state
The player needs to know that time is stopped and what changing the rate will do. The simulation clock architecture does not help that decision.
Record exploration by what the captain found
The Event Log should help the player remember which wreck paid out and what they mined. Array positions only describe how this runtime happened to store those objects.
Name arrival threats as expected contacts
A captain deciding whether to jump needs to know what contact to expect and how quickly it will arrive. A content key such as border-clash is neither fiction nor operational guidance.
Describe construction as a physical placement task
SELECT #, GHOST, and ORIENT expose editor implementation language and make an already spatial task harder to parse. The player needs to know which physical part is selected, where the next part will go, and which rotation is active.
Make target telemetry answer the combat decision
DIST, PD, bare world-unit numbers, and tick suffixes require the player to translate engine shorthand during combat. Cause, recovery time, range scale, and the specific defense being suppressed are the actionable facts.
Use physical units across ship operations
These instruments are read together while flying, fighting, and comparing upgrades. A shared physical vocabulary lets the player compare distance and speed without learning storage units or compressed developer shorthand.
Call every weapon mount a hardpoint
The detail pane and title already teach HARDPOINT; introducing a second abbreviation at the exact placement target makes the player decode two names for one object.
Let the local radar speak in complete operational terms
A tactical radar may be compact, but it cannot require the player to reverse-engineer its private counters and units while flying.
Give the Galaxy glance layer an uncontested berth
Three partially occluded instruments are less informative than one complete strategic answer. The scoreboard is a deliberate glance action, so ambient and routine status can safely return when the player closes it.
Render the unreachable voxel globe at background resolution
The distant voxel planet keeps its real materials, lighting, scale, and atmosphere, but the game no longer ray marches every background voxel at the same resolution as the player's ship.
One writer owns performance telemetry
Performance tools can no longer erase one another's measurements while the game is running.
Preserve the test-fixture namespace in build output
Developer tests now find their own test data, while players still do not receive that data.
Budget derived ship-system recomputes instead of synchronizing damage bursts
When several capital ships are damaged together, the game no longer insists on recalculating every broad ship stat in the same frame.
Spend post-process cost where players can see it
The game keeps its glowy cinematic look, but a fresh install no longer spends frame time on a nearly invisible background blur.
Keep one previous-good galaxy generation
If the newest save is damaged, Continue now recovers the previous good galaxy instead of throwing away the whole campaign.
Capture crashes before startup
If the game fails, it now leaves a small local report from startup onward so the failure can be diagnosed instead of disappearing.
Aggregate activation evidence without identifying sessions
A playtest folder now becomes one readable local scorecard showing where players reached and stopped, without listing who played or which file was theirs.
Finalize signatures as a new exact package
I made the release pipeline prove that the exact files players receive are signed and trusted without putting private signing credentials into the game project.
Keep development metadata out of promotion-ready builds
A development build with placeholder store information can no longer be mistaken for the version intended for players.
Author size-adaptive camera framing as presentation data
Capital ships now stay large and complete on screen during normal combat instead of shrinking into the background or spilling past the frame.
Preserve bloom pyramid levels during additive reconstruction
Bloom now makes beams and impacts glow without bleaching the ship, planet, and sky out of the picture.
Make in-game capture the only visual proof path
Visual reviews use the game's screenshot feature. They do not wait for desktop capture access.
Show one active control vocabulary at a time
P / RS and D-PAD / ARROWS are technically complete but force every player to decode irrelevant controls at the moment they need a clear instruction. A release interface should answer “what do I press now?” in one vocabulary.
Required campaign actions explain the route the player can actually take
A controller being technically capable is not enough if the objective goes silent after the opening or the next mandatory screen teaches keyboard controls. The prompt must tell the truth at the moment of need, including when the action is spatial or reached through another screen.
Controller players can inspect and change their own ship controls
“Full controller” is false when a player can fly but cannot open the Controls page, discover Scan, change a button, or recover from a conflict without reaching for a keyboard. It is also false when the UI hides analog ownership or silently restores an intentionally unbound default after restart.
Core Signal is completable and recoverable with one controller
Controller support is a release promise across the whole mandatory journey, not a title-screen badge or an opening tutorial claim. Completion and Continue are where input, UI, simulation, content, and persistence finally meet.
Pause safely when the active controller disappears
A controller player must never be stranded mid-combat or inside a menu, but an attached device must not steal focus from someone who is not using it.
Mandatory campaign kills belong to authored encounters
The objective named a relay guard, but the old reward accepted the first player kill of any non-player ship. That let ambient combat counterfeit a mandatory narrative decision.
Achievements mark remembered stories, not routine labor
The system should reinforce StarGazer's promise—discovery, consequence, rivalry, and recoverable loss—rather than turn normal play into a checklist. The first two achievements also create useful first-session progression markers without exposing internal campaign facts to the player.
A player's world and authored ships follow the player, not the machine
Continue, achievements earned offline, and ships built in the Shipyard are player value. Losing any of them on a second computer breaks trust. Conversely, importing another machine's graphics or controller setup can make the game unreadable or unplayable, and shipping crash/activation evidence is a privacy error rather than a convenience.
Account value gets one previous-good recovery generation
A readable previous account state is better than silently showing zero credits after corruption. This matches the recovery promise already made for the galaxy and achievements without turning device settings into portable account data.
The Steam demo is isolated unless a later transfer rule says otherwise
A trial should be safe to install before or after the paid game. Valve permits deliberate save sharing between associated products, but an implicit shared directory turns demo iteration, schema changes, and content limits into risks for paid progress.
End the Steam demo with the cipher aboard and the answer still outside
The cutoff delivers the game's travel, decision, capital-ship combat, destruction, and reward promises before stopping on a concrete unanswered question. Ending before the cipher is decoded preserves a specific desire to continue instead of exhausting the complete first arc or cutting off before its first payoff.
The standalone demo names itself and leads with its complete promise
A separately installed trial must never make a player wonder whether they launched the demo, the paid game, or a development build. Its first action should also state the playable slice in eight words instead of relying on store copy the player has already left behind.
Ship the first standalone demo without Cloud or a divergent content fork
Separate application identity and mandatory launch arguments enforce the player boundary already implemented in game. With no transfer promise, synchronizing isolated trial progress has little player value and adds conflict/support risk. Reusing one exact package pair makes the trial mechanically representative and avoids a second build graph before download size or content exposure proves that cost worthwhile.
Sell one demonstrable capital-ship fantasy in five frames
StarGazer's strongest market promise is the combination of capital-ship command, consequence, strategic travel, and voxel damage. A generic gallery or cinematic-first trailer would make the product look broader but less distinct. Five ordered gameplay proofs communicate the actual loop in seconds and give the demo page enough truthful material to stand alone.
Make the first Steam trailer a 48-second gameplay argument
StarGazer's differentiator is not a generic space vista. The conversion argument is capital-ship command plus destructible voxel matter plus streamlined space-opera decisions. Front-loading impact and structural change makes that argument survive mute autoplay and Steam's short microtrailer window, while the middle establishes that combat sits inside an authored command loop.
Claim only English and disclose the broad AI-assisted surface
A broad market ambition does not justify false language reach or a narrow disclosure. Steam separates store translation from in-game support, and its pre-release review compares survey answers with the build and marketing. Exact English copy now gives the owner a clean portal source; future languages should follow real traffic, wishlist, community, vendor, and QA evidence rather than speculative checkbox coverage.
Test the whole conversion promise with twelve observed strangers
Store art, trailer metrics, and automated routes can prove integrity but cannot tell us whether a stranger understands the fantasy or wants it. Twelve is intentionally a lean qualitative matrix: enough to expose repeated breakdowns across three experience bands, small enough to iterate before broad market testing. It does not estimate 250,000-copy demand.
Make achievement state readable before Steam names it
A Steam thumbnail has to identify the accomplishment before its surrounding text is read, and locked versus unlocked must survive grayscale and 64px presentation. Five unrelated illustrations would create more art but less product identity.
A named rival interrupts; ambient traffic does not
The simulation already remembered escape, observed the real cooldown, and returned with a larger authored wing, but the decisive beat looked like one more 14-pixel chatter line. A grudge is valuable only if the player recognizes ownership and escalation at the moment it becomes actionable. One concise alert preserves combat flow better than opening a modal conversation or adding another persistent HUD panel.
Make luminous voxel space opera the visual target
StarGazer already has distinctive voxel ships and systemic destruction, but too many playable frames spend that identity on distant subjects, flat black space, evenly lit hulls, or effects that do not light their surroundings. A concrete target lets every rendering choice answer the same question instead of accumulating unrelated polish.
Make authored materials visible on voxel ships
The voxel geometry already carried strong deck, armor, machinery, and aperture rhythm, but a single diffuse response flattened those masses into one material. The approved visual target depends on luminous color cutting through a dark machine, which requires the machine itself to read as more than one surface class.
Keep energy color visible around every hot core
The approved target depends on cold capability meeting warm consequence. The previous beams read as hairlines, crossed drive cards stacked into white rods, and the capital-death proof landed after its strongest warm phase.
Build environmental depth from real collision bodies
The approved visual target needs near, playable, and far scales in one frame. The old 350 to 850 unit belt left normal hero cameras empty, while fake foreground dressing would make the pixels disagree with navigation and weapons.
Stage authored confrontations inside the player command view
The guard had been displaced roughly 1.7 kilometers by ambient world-origin keepout, the authored class could silently resolve to another hull, and the single-line objective ran beneath the target panel. That made a pivotal confrontation look empty and its command text harder to read even though the encounter technically existed.
Present the Core Relay finale as an actionable three-subject climax
The old proof booted the destination outside the campaign, hid both ships, displayed NO LOCK, and let a flat relay slab dominate the frame. It verified debug slot counts instead of the climax a player actually sees.
Make a rival return interrupt the battle, not the HUD
The prior frame said RETURN 2 but showed NO LOCK, no rival hull, a flat stern, and two equal-weight diplomacy notices. It announced escalation without making the threat playable.
Let a rival's witnesses arrive as a hunting party
The old proof killed the rival before arrival and reduced this distinct encounter to the same DIRECT HAIL notice as an ordinary return. The data said hunting party while the playable frame said generic contact.
Make wide tactical frames prove a living world
The stale proof pointed at empty sky, exposed the developer panel, and described ships that had moved out of frame. A wide exception to the hero-ship law still has to show playable subjects.
Make the final rival return a capital showdown
The authored third rung already existed, but no live route or permanent frame proved it. A larger fleet hidden beyond marker scale is escalation in data only, not a climax the player can read and act on.
Announce an authored system opening at first contact
The border clash was present in simulation state but invisible from the normal arrival camera. An unlabelled distant battle becomes background noise even when its encounter data is correct.
Make the home opening read as a convoy ambush
The home opening already had a distinctive cast, but it appeared only as distant incidental flashes inside the traffic proof. Its capital-versus-frigates shape deserved an actionable introduction rather than anonymous background combat.
Give the Kraken a legible hero drive bank
The old repeated white circles read as a placeholder matrix and hid the ship's scale. A few framed cores match the approved capital-ship target and give the stern one strong visual idea.
Make capital wreck scars read as aftermath
Immediate additive scar cards competed with the blast and appeared as large soft pink blobs, obscuring the brighter hull breakup without reading as damage or debris.
Keep asteroid mass dark without losing facet read
Large foreground rocks were collapsing into near-black cutouts against the violet nebula. Raising global light would also wash the Kraken, weapons, and sky, while the owning problem was the rock material range.
Give capital destruction a broad warm fire body
The approved luminous space-opera target makes warm consequence as substantial as the cold weapons that caused it. The former star, thin ring, and small flipbook puff did not carry enough visible mass for the game's largest ship class.
Make faction charter progress read as a campaign
Long faction stories need visible momentum and a legible payoff. The old STAGE 1 OF 3 line collapsed two different scales of progress and buried the charter reward inside dense work terms.
Let a final faction charter end with earned authority
A three-chapter campaign needs a distinct culmination in the moment and a lasting record afterward. A routine success toast alone would make the faction-wide payoff feel like another completed job.
Make ambient comms yield to flight instruments
Useful first-session information became noise when four lines crossed the flight instrument rail. Actual occupied bounds keep the compact composition readable without a fragile viewport breakpoint.
Lead the first map open with the active objective
The objective was truthful but visually stranded among a thousand systems. Leading with its route and dossier turns the map into the next playable decision without taking agency away.
Match every Signal Deck prompt to the active device
The game accepted controller input while its signature narrative screen still taught only arrow keys, Enter, and Esc. Truthful prompts keep the first meaningful choice from becoming an avoidable controls test.
Leave the relay cipher at the guard wreck
The first fight needs a readable payoff and one final act of player agency. Automatic delivery made the reward causally invisible, while a glow alone disappeared into bright planets and wreck sparks.
Boot and travel share one fleet cook and cache owner
The game now reuses already-built ships and has one trusted way to prepare a system fleet, which makes later starts dramatically faster. A brand-new installation still waits far too long, so the release blocker remains open and the next fix must show the title before that work or ship validated opening ships ready to load.
Load the default galaxy from its deterministic bake
The game now loads its unchanged galaxy backdrop instead of rebuilding every cloud and star lane before showing the title.
Ship the golden-path fleet through the existing recipe cache
The first battle and first jump now load their ships from the game instead of building them on the player's machine.
Treat the validated depot as the release artifact
A build is not shippable until the exact files a player receives pass the package gate.
Measure performance through the player artifact
Performance evidence now comes from the same game package a player would install and says which kind of machine ran it.
Measure the paced player loop
Release checks can now measure how smoothly the delivered game actually plays instead of inferring it from an offline test.
Resolve wound exposure only when an emission is due
The game now checks whether a wound can emit only when it is actually time to emit, instead of repeatedly searching damaged hulls between visible effects.
Normal flight controls stay inside the safe hull envelope
A normal bound control that silently removes real voxels looks like a rendering defect and punishes the player for using the ship as offered. Damage must communicate an exceptional maneuver, not ordinary flight.
Strategic map objects own nearby, explicit actions
A map is a planning surface, so the object being considered should explain what the player can do without forcing an eye jump to the opposite corner or starting travel from an ambiguous selection.
The release opening teaches one truthful action at a time
A complete campaign is not release-ready when a cold player must guess its first verb or reach for another device. The objective should say what matters, then expose the exact control without becoming a tutorial wall.
Measure the opening without profiling the player
I need honest timing and abandonment evidence, but a solo game does not need identity, wall-clock timestamps, hardware fingerprints, file paths, or player text to learn whether its opening works.
First install earns attention before it finishes building the world
A long black or frozen-looking start spends player trust before the game makes a promise. Honest, readable feedback gives the player a responsive front door without inventing a percentage, exposing engine vocabulary, or reducing the living-system population.
Ship only platforms the build can actually launch
The former universal claim produced an x86_64 app host beside an arm64-only FNA3D library. A publish command succeeding is not evidence that the game can launch.
Store support starts at the supported runtime floor
I ship.NET 10, whose current supported consumer matrix starts at Windows 11 and macOS 14. I will not call a system supported just because the binary happens to open there.
UI motion is quiet, responsive, and optional
Command interfaces feel premium when every response is immediate and coherent, but constant motion competes with ship combat, dense decisions, and readable status. A stable whole-control frame remains the primary selection cue.
Faction work grows as authored sequel arcs
The existing 11 proof-backed mission verbs are broad enough; the thin part was dramatic composition, contact variety, and persistent progression between authored operation sets.
Exploration grows through authored mysteries, not coordinate chores
Procedural discovery only stays interesting when the thing it casts has an authored question, escalating evidence, and a remembered payoff. More rolls against eight clues would increase repetition, not playtime.
Specialist hulls make fleet composition readable
More silhouettes only create lasting play when a player can infer what a wing is trying to do. The catalog needed cargo traffic, harassment craft, protective screens, standoff pressure, and heavy line targets, not six more versions of the same gun brick.
The armory grows by combat questions, not stat tiers
A 100-hour combat game cannot get its longevity from five ascending damage numbers. It needs recognizable reach, cadence, geometry, target priority, and counterplay that change how the player flies and which enemy matters first.
The content century is authored arcs plus remembered selection
More jobs only become more play when the galaxy remembers what the player just did and when repetition advances an authored relationship. Three mandates let each faction establish its ethic, complicate it through a second contact, and finally force an ideological payoff. Ledger-aware selection gives the procedural layer a short memory without starving live strategic needs or inventing a second quest state.
The Galaxy Should Remember Your Name
I stopped treating faction work as a pile of missions and started treating it as a relationship that remembers what I have done.
Let an early rival bring witnesses
The second atom needs a different dramatic purpose, battle shape, cadence, and eligibility rule so the situation vocabulary proves it can author variation instead of reskinning one return.
The focus marker is a leading rail, not an outer ring
The owner looked at the title screen and asked why New Game had "a red square over it" that "looks so out of place" — and it did. Two coral marks fired for one state: an outer StrokeRect ring plus ControlFrame's engaged rail. Worse, the ring drew hard 90° corners while every control on screen uses a clipped/beveled frame, so the only sharp rectangle in the interface sat on the default menu item and read as a stray debug box. The 4px rail also sat on top of the button's own border and butted against the label. The code even documented the intent it had lost: focus was meant to be "an outer navigation ring, distinct from an action's semantic accent border," but the rail turned accent on focus too, collapsing the distinction.
Selection follows the input you are actually using
the owner: *"the highlight effect needs to just be on hover, its weirdly being sticky."* Two systems were drawing one look. Hover already existed (a scale + lit frame), but the KEYBOARD focus marker stayed parked on whatever was last focused — so after boot, New Game stayed lit while the mouse moved elsewhere, and the menu read as stuck. A screenshot of the menu could tell you where the mouse used to be.
The UI framework grows before the screen count does
the review measured ~2,000 lines of framework carrying ~21,000 lines of hand-rolled panels, with 58% of panel code outside the layout system and 8 of 18 screens exempt from the layout gate. Tripling the screen count on that shape multiplies the hand-rolled half. The specific blocker for the owner's stated direction (animations, transparency) was that two thirds of the widget code scaled alpha only, so the first fade would have made most of the UI GLOW instead of dissolve.
A faction withholds work from a captain who broke its line
The Signal Deck shipped three recorded positions and nothing anywhere read them, so every vector cost the same and bought the same galaxy. A choice that changes only the reply text is a menu, not a decision. Trust is the right currency for the first consequence: Halcyon's most sensitive work is exactly what a faction gives to someone who respected its line, and withholding it is a consequence the player can feel without being told.
Hardpoint pods size screen-constant, like every other billboard
The markers showing which gun sits at each mount are small pips on the hull again instead of big cards covering it.
World-space weapon hardpoint pods REMOVED
The bright squares stuck to the ship are gone. The armory still shows which gun is on which mount, on its own schematic, which is the only place that ever showed it.
Project strategic needs instead of adding a second AI
One connected decision chain now carries distant events into the ships and jobs the player sees.
Contract content joins the faction library
Contract files are now first-class faction data, not loose mission scripts.
Contract completion preserves authority under cargo, encounter, and save pressure
Contracts now survive full cargo holds, old saves, distant encounter resolution, and retries without cheating or losing the player's progress.
Faction needs must become visible work
Rich lore and combat doctrine were not enough while several strategic goals had no action and the civilian ships in front of the player did not respond to what their faction needed.
Faction work has distinct funded identities
A generic job board would flatten the faction canon into color and copy changes. The work itself must reveal what each faction values and refuses to do.
Faction charters grant durable institutional access
A charter is an institutional relationship, not a temporary mood bonus. Its result must survive contact churn and have an actual gameplay consumer.
Contract access and history are different player surfaces
A public board that leaked covert work, one ledger that mixed offers with outcomes, or an immediate abandon button would make channel, status, and consequence unreadable even when the simulation was correct.
Faction contracts are authored obligations, not interchangeable jobs
Faction lore only matters if the player can recognize it from what a faction asks, what it refuses, how it settles, and what changes afterward. Repeating one easy operation or resolving an unrelated crisis would reduce that identity to prose.
Nothing Happens Until I Show Up
I decided the galaxy would never advance on a clock, only on what I actually did out there, and then spent two weeks making good on it.
Command UI roles have one authored and rendered owner
Change the authored command palette once and the whole ship computer follows it.
Roster loads resolve one complete saved-ship revision
Loading a saved name always produces one real version of that ship, never a hull from one save and modules from another.
Native UI layout responds to information density
Each screen uses the shared system at the size its content needs, and small viewports keep their proven controls.
UI clauses fail at their owning boundaries
The standard is connected to the data, controls, tests, and visual proof, so future UI changes cannot quietly bypass it.
Narrative graphs reuse the persistent campaign fact ledger
Story files describe the conversation, the simulation records the choice, and the same save already remembers it.
Construction recipes compile into ordinary ship packs
The editor produces a normal StarGazer ship. It survives saving, loading, damage, and flight through the existing pack path.
The interface reads like an operational spacecraft
The UI foundation was clear but still felt like a collection of separate game panels. The captain needs target state, ship condition, weapon readiness, and alert severity to scan as one operating system.
Screen space serves the current decision
A coherent visual language still fails when important copy truncates, support text fades away, or empty chrome competes with the ship.
The command interface has one tested design standard
A visual direction can drift into tiny text, decorative noise, input dead ends, or inaccessible state unless the same rules guide design, implementation, and review.
Conversations are compact command decisions with durable consequences
Long dialogue trees and vague paraphrase choices interrupt the space game without giving the player meaningful command. Compact packets preserve pace while persistent facts let later missions, factions, and speakers remember what the captain actually decided.
A ship can begin as an empty grid
A Starfield-level Shipyard needs structural authorship, not only sliders and module swaps. An empty start, visible geometry, exact blockers, and safe drafts make construction understandable without replacing the existing procedural hull path.
Shipyard highlights belong only to the active editing mode
The stale Broadside wash appeared as a bright yellow card behind the selected Systems mount, obscuring the ship and making two unrelated selections look active at once.
Core Signal finale is authored gameplay
The last Core Signal jump now reaches a real place with a real battle and hazard. The player must bring the Relay Lens, survive the breach, and scan the choir while the fight continues.
Pack v2 owns a strict ship-system node catalog
Ship packs now carry the install points the future editor will use, and broken or stale node data stops at load.
Ship layouts compile before flight
The Shipyard can now say whether a ship can fly and what it can do before the game launches it.
Shipyard system placement is a full runtime-backed editor
The player can now place owned machinery on real mounts, see the result, save it, and fly the accepted build.
Small-craft RCS exhaust never points into the hull
Fighter maneuvering jets now fire away from the ship, not through it.
Refabrication restores derived ship capabilities in the same tick
A rebuilt ship is healthy immediately. Its engines, guns, shields, cargo hold, and mass no longer wait on a recompute that may never happen.
Verification jobs have one bounded orchestration owner
The same checks now finish in about half the time, and each failed child leaves its own reliable evidence.
Travel and same-world worker defaults stay conservative
Whole-test parallelism is a clear win. More background ship cooking and live simulation threading are not proven wins yet, so they stay off.
Project skills have one owner per workflow surface
Agents now have fewer overlapping checklists and one clear place to look for each kind of work.
Keep web design iteration and native UI on one contract
I can explore interfaces quickly, but the version players see is always the real game screen and it is checked in every important state.
UI semantics live below the input surface
Every way to operate the Shipyard now obeys the same rules, and the real screen uses the same tested components as the gallery.
UI state is effective, bounded, and torn down with its screen
Hidden or closed UI is truly gone, long text stays inside its control, and every accepted theme definition is safe for the native renderer.
Animation verification is a distinct visual proof surface
I made animation checks put the whole visual progression side by side so the judgment comes from seeing the effect, not trusting a number.
Heavy verification runs once at landing
Small changes now get quick checks while I work, and the long safety sweep happens once when the finished result lands.
Authored interface definitions are safe for every native control
If a theme definition loads, the native UI can actually render it safely, and a missing theme authority fails loudly instead of pretending defaults were authored.
Shipyard operations expose one canonical state to UI and automation
Mouse, controller, automation, and failure handling now agree about what is focused, dirty, busy, and safe to leave.
Ship designs and UI proofs have complete lifecycle ownership
The game now saves, restores, applies, rejects, and tears down the same complete ship design the player sees.
Shipyard preview publication is one recoverable transaction
Fast edits, Undo, failed previews, controller navigation, and first-load recovery all preserve the exact ship the player meant to build.
The Core Signal ends at a memory choir under quarantine
The finale needs a distinct place, factions with motives, and pressure that exists without the player or a test harness. The Lens also needs to be a real key to the source, not only a checklist item from the prior dock beat.
Ship customization uses authored system nodes
Starfield-style ship building needs visible, stable placement points and clear flight errors. Pack-owned nodes also give damage, save data, preview, and runtime compilation one shared identity.
Ship modules install into physical system slots
Counting every nozzle as a separate engine would make large ships expensive and overpowered for having richer geometry. The ship should be balanced by installed machinery, not by how many visual outlets the artist authored.
Ship systems affect flight and survive outside the editor
Ship modules need consequences in flight, but the editor graph cannot become a per-tick simulation graph or replace proven weapon ownership.
Shipyard layouts are owned, previewed, and applied at dock
A placement editor must be safe to explore. A click cannot mutate combat state, erase a module, or launch a ship with a hidden invalid build.
Make Shipyard decisions readable before they are committed
A deep ship builder is useful only when the player can predict what a change does and recover from a bad draft without decoding compiler output or losing sight of the ship.
Shipyard controls have one truth across every input
Input parity is a gameplay rule, not a documentation promise. The player must not receive a different inventory or draft result because they used a controller, and a visually strong selection must be the thing a click actually selects.
Leaving Shipyard never destroys an uncommitted systems draft silently
A high-agency builder has to be safe to explore. Silent draft loss and controller dead ends turn customization into a trap even when the underlying compiler is correct.
Shipyard exit is visible, modal, and safe across tabs
A draft remains real when its tab is hidden. Exit safety cannot depend on which panel happens to be visible, and a modal must own both pixels and input rather than merely painting above live controls.
Hull and systems edits share one safe Shipyard draft decision
Hull edits are no less valuable than module edits. A player must not lose either kind of work by changing tabs or leaving, and a long cook cannot masquerade as an ignored input.
A saved Shipyard build means the whole ship
Players do not distinguish a hull recipe from the ship they just configured. Silently dropping placements on Save or Undo violates the editor's promise more severely than a visual defect.
A Shipyard preview may fail, but the player's design may not
High-agency customization has to remain understandable under latency and failure. Silent stale previews, endless loading, or input-specific dead ends make experimentation unsafe even when the underlying save data survives.
Architecture readiness fixes get permanent guards
The checks now find the runtime consistently, UI screenshots wait for their click to land, and the orbit camera has a direct self-test.
Vertical slice P4: recovery is saved signal state
Death now leaves a durable recovery receipt, so the campaign can pick back up instead of pretending the setback never happened.
Vertical slice P5: live weapons finish the damaged guard
The test captain now has to finish the wounded enemy with the real guns instead of getting a hidden cleanup shove.
Vertical slice P6: reward, dock, and outfitting are real edges
Winning the fight now gives you a useful thing, and the route spends it at the dock like a player would.
Vertical slice P7: the finale is scan-backed campaign state
The last beat now asks you to jump to the relay and hold the scan under pressure instead of quietly ending in the background.
Vertical slice P8: completion is a screen plus saved acknowledgement
The game now has a real end screen, and pressing Continue Sandbox is saved instead of being a temporary pop-up choice.
Vertical slice P9: player death recovery is catalogued
Getting destroyed now shows a clear recovery panel, and that screen is part of the visual test catalog.
Vertical slice P9: recovery keeps the relay reward reachable
Death can no longer strand the mission prize, and the first episode now tests the intended wounded guard instead of a random tougher ship.
Vertical slice P10: evidence gates are executable
The first episode now has a repeatable proof report, and wrecks are sized so they can be looted without crashing the system load.
Vertical slice P10: app shell proof is executable
The start, first scan, first jump, and end of the first episode now run through the real app loop instead of only through sim tests.
Vertical slice P10: app route proves combat reward
The first episode app proof now makes the reward drop come from a player-owned combat kill instead of skipping straight from the first jump to the ending.
Vertical slice P10: app route proves full Core Signal completion
The automated app run now plays the first episode from title to ending instead of cutting from the first fight to the victory screen.
AI gameplay verification is an explicit matrix
The game now has a checklist that lets the AI play the first episode and say exactly which part stopped working.
Combat proof gallery carries fleet, beams, and damage
The proof report now shows the battle, the lasers, and the ship damage instead of asking readers to trust a hidden state file.
Pause inventory reuses the bay equip seam
The new weapon inventory screen uses the same equipment rules as the rest of the game, and the ship now shows visible weapon pods on its authored hardpoints. Current firing authority is still group-level; the mount index is placement validation and visual identity until the future per-mount fire-stats slice.
Every lead target must be playable
Lead-chain content already allowed non-POI vocabulary, but the runtime only advanced POI types. That made some clues authorable but impossible to complete. The fix keeps the vocabulary and makes it true in play instead of shrinking clue content back to signals only.
The vertical slice advances by facts the player caused
The vertical slice is supposed to prove start-to-finish play, not prove that a test harness can nudge state. Fact-backed progression gives every milestone a durable receipt that survives Continue and can be audited for provenance. It also scales cleanly: later authored content can add new facts without inventing a custom flag field for every beat.
Travel progress needs provenance
Moving the player between systems is too important to hide behind CurrentSystemIndex = n. Without provenance, a full playthrough can pass while skipping the act of travel. The audit makes travel evidence legible: the player route asked, it was accepted for a reason, and no hidden direct relocation happened.
Beat ids are not objective copy
A vertical slice is only playable if the player can read what to do, where to do it, why it matters, what changed, and what comes next. Slugs are useful for determinism and reports, but they are not instructions. Making copy required in schema prevents the team from accidentally shipping a technically complete but player-hostile spine.
The first Core Signal must be scanned
The opening must teach the player that campaign progress comes from doing ship actions in the world. A passive first beat made the story move without the player proving anything.
Travel must read as a player command
The player needs to understand why a jump can or cannot happen. The test needs the same proof: who asked to travel, where they asked to go, and whether the map allowed it.
Death keeps the Core Signal alive
The slice needs to survive combat tuning. If dying wipes or hides story progress, every later fight becomes a soft-lock risk instead of a setback.
The first Core Signal duel is a wounded capital
The route needs a kill that comes from the player's guns now, but full-health balance belongs after reward, dock, and finale beats exist around the fight.
The first Core Signal reward must be used at home
A vertical slice needs a post-fight breath that changes the ship and confirms the kill mattered. If the reward only advances a hidden flag, the dock, cargo, wallet, and loadout systems do not become part of the player journey.
The Core Signal ends at a relay under pressure
The slice needs a climax before the completion screen exists. A final jump and scan keeps the end tied to flying, pressure, and the strange signal.
The Core Signal needs a quiet victory screen
The player needs a clear breath after the relay overload. A visible ending makes the slice feel like an episode, and the saved sandbox acknowledgement lets the world continue afterward.
Death should explain the tow home
The player needs to understand that death is a setback inside the run, not a broken save or a developer reset.
Death cannot strand the relay prize
A story-critical reward should be a setback risk, not a campaign soft-lock. The player can lose time and pay recovery costs, but the first episode must remain finishable.
Derelict hulks stay salvageable, not system-breaking
A fighter wreck was too small to support local breach-and-spill gameplay, while a capital wreck could crash an authored campaign boot before the player saw the map.
Objective travel completes when the captain arrives
The objective tells the player to jump to the revealed source. Holding that beat until conquest made the next reward/refit beat invisible even after the player did the requested action.
Make capital combat heavier and easier to read
The ships were moving and trading fire, but the proof frames and feel still read too polite. I want a capital ship to take a moment to swing around, then make its lasers, plumes, and wounds obvious when the battle opens up.
Put weapon inventory inside pause
Weapon swapping is part of the captain's build, so it should feel like placing modules on the hull instead of clicking a small list. The pause flow is still the right home because it sits beside cargo, map, event log, and settings.
Every system has a typed, lethal, orbited star
the sky was a lie — one hardcoded sun decal shared by every system, one planet pinned to one constant, a moon that followed the camera. A living galaxy needs each system to LOOK and BITE differently; the star taxonomy + typed planets are the per-system identity layer, and the lethal star turns the sun from wallpaper into geography (the harbor is safe BECAUSE the arena sits outside the warn band — the validator enforces it).
Capitals are bosses; the mobs are fighters, frigates, and light capitals (owner edict)
A battle of nine capitals makes capitals worthless and fights end before they read as fights. Rarity is what makes a boss a boss.
The save file is one galaxy save plus save points
Only credits cross processes today, so Continue restoring "everything" is net-new serialization, and the shape has to be pinned before WP1 starts adding fields to it.
Repair and revival REBUILD, not restore
The one re-knit path (BrickVoxelDamageState TryRestoreCell, canon law 4) refuses a killed hull and released cells, so severed matter is gone for good (canon law 3) and a dead ship's cells can never be un-killed, making a fresh fabricated hull the only honest way back to whole.
Failure fiction is harbor revival
No permadeath was already decided, so death needs a fiction that costs something without rewinding the living galaxy or wiping progress.
Spend model is outfitting at friendly structures
The slice needs one legible thing to spend on, and outfitting turns every kill into buying power without committing the galaxy to an economy shape yet.
Galactic credits — earn-only wallet, kill bounties, loot canisters (WP1)
The living galaxy needs a reward loop for its combat, and bounty + salvage is the smallest one that reads. Earn-only is deliberate: the economy-shape fork (what credits BUY) stays open per the gameplay-structure decision — nothing here bakes in a spend model.
Galactic credits — the money you can SEE (WP2)
WP1's earn loop was invisible — money that doesn't show isn't a reward. One warm accent color across every credit surface is the cheapest possible readability rule.
Weapons fire only at targets (owner edict)
Owner, after diagnosing the "blue sparkles": the armed auto-laser battery volley-fired 14 beams into empty space on every trigger pull — pure visual noise, wasted reactor, no meaning. "Weapons shouldn't fire without a target anyway. That is the new rule. Everything that can be shot can be targeted as well."
Sub-light drive VFX become a speedometer; standoff pulled to 500u
VFX that read as a live speedometer make the drive legible without ever checking the SPD number; a 500u park distance matches where the owner actually wants to arrive.
Structures get a layered material identity plus lit windows
Structures read as flat single-color silhouettes — identifiable but dead. Ships got 22 materials through the same per-voxel pipeline; structures authored 2. Windows are what make a silhouette read as a *place*.
Structures stop being jack-stones — a 12-skeleton shape language
One grammar meant every station in a 1000-system galaxy was the same jack-stone with different colors. Shape is the first thing a player reads at range; twelve skeletons x drawn parameters x styles is where "every structure feels found, not stamped" starts.
Non-faction style families + the condition axis (WP2 of the content machine)
A thousand structures need more than shape variety: they need wear, voice, and builders that aren't the eight ambient factions. The condition axis is the "shattered/derelict" answer WP1 deferred — it composes over EVERY skeleton instead of being one more shape.
1000-structure content machine — density, ancient placement, seeded identity (WP3)
WP1/WP2 built the vocabulary; nothing in the galaxy spoke it. Placement density, relic builders, seeded chassis picks, and composed identity are what turn 15 chassis × 17 styles × 5 conditions × 10 registers into ~97k distinguishable identities a player can actually encounter — and the audit is what keeps that true forever.
Seven alien factions become full canon
A faction must change how its people speak, bargain, fight, build, joke, and remember. Palette swaps and placeholder empires cannot carry diplomacy or story.
World events become player dispatches
A living galaxy has no value if its wars, disputes, treaties, and consequences happen only in hidden state or brief toasts. The player needs durable context without stopping distant simulation.
Damage outcomes coalesce per attacking ship, so no battle can overflow the political queue
A long battle used to slowly fill a political ledger until the game crashed. Now each ship's ongoing bombardment is one running entry instead of thousands of drips, while kills stay their own line items — the ledger can no longer overflow, and the politics mean the same thing.
The galaxy is a spiral of constellations
The old uniform-noise scatter read as a chart, not a place. A spiral of constellations gives the map a silhouette, gives regions somewhere to live, and gives factions readable homelands — while staying a pure seeded function with the same determinism story as before.
A menu owns the screen
A UX review of the old menu found it never owned the screen — the fps counter, throttle gauge, hotbar, target-lock box and dev diagnostics all stayed lit around a small centred panel, and the cyan dev menu clashed with the amber panel. A menu should command the screen; the player's eye should land on it, not fight eight glowing instrument clusters.
Swarm missiles become slow white naval salvos
Owner: the swarm missiles should move slower, carry a whiteish trail, move like a space naval missile, and be a bit more epic.
The sub-light drive is the player's fast-travel mount
The player needs real mobility inside a local system — a main ability to close big distances fast — without it being a free "always-on" speed that trivializes combat. Tying it to fly-to (a locked destination) keeps it a deliberate travel tool, not a combat dodge; the damage dismount + cooldown make it a commitment.
The sub-light drive looks sub-light
The drive was mechanically fast but visually indistinguishable from fly-to. A mount needs a mounted look — the player should FEEL the mode change the moment it engages, and read it on any other ship later if AI ever gets drives.
Make campaign regions a resolver-owned source of truth
One campaign table says what each part of the galaxy is, when it opens, and what kind of systems it tends to make.
Gate generated system quality through playable surfaces
I made the generator prove each system has a readable map, safe starting point, living factions, and useful places before it can pass.
Add one deterministic gameplay journey smoke
I made the game play a whole campaign by itself and explain where the journey is thin.
Make the whole campaign readable as one report
The game now plays a full campaign by itself and gives us a report a person can read.
Turn playthrough evidence into decision data
Each automated campaign now becomes durable evidence that can show what changed and what keeps happening.
Resize faction outcome headroom for accelerated play
Faster play can no longer outrun the political event queue in the measured fleet battle.
Simulate arrived ships, not reserved slots
Reserved ships no longer burn CPU before they arrive, and reused ships start clean.
Split campaign space into three unlockable regions
The map needs a clear outward journey without hand-authoring all 1000 systems. The Core can open deeper space as the story advances, while the generated galaxy still supplies local variety.
Let the player accelerate deterministic time
Capital-ship travel, positioning, and large battles need room to breathe without making the player wait through every quiet stretch at normal speed. The simulation still advances through the same fixed ticks, so faster play does not create a second set of combat rules.
Gameplay structure is DECIDED — a directed spine over a living galaxy
The last four days already narrowed this. (1) The fiction rules out clean permadeath — the player Core is defined by regeneration and self-reconstruction, so a run-ending death fights the hero fantasy. (2) The built world only pays off if it persists — a 1000-system galaxy that remembers causes (grievances, treaties, trade dependency, multi-step explainable faction choices, unlockable regions, save v4→v7) is wasted by disposable roguelike runs. (3) The full-playthrough report's three recurring warnings (objective completing from lock state before the player won; 417 idle strategic ticks after combat; the epilogue firing through an effect before its own trigger) are the symptom of having half-built an authored campaign and half-built a sandbox without deciding they are ONE thing. Committing to this shape turns those three warnings from bugs into the design: a beat resolves because the player caused it.
Select voxel proxy faces from camera position
Large stations stay whole at the edge of view instead of breaking into disconnected slabs.
Store access and trade as bounded faction state
The game now remembers who may enter, who trades with whom, what each side gains, and what breaks when the link fails.
Make faction choices bounded, sourced, and replayable
Factions now choose from a fixed budget, say why, keep the evidence, and make the same choice after a save.
Split system fleet capacity by hull tier
A system can now hold large fleets and hundreds of working small craft without letting capital ships crowd them out.
Compose small-craft roles with faction doctrine
A faction ship keeps both who it serves and what job it does.
Scale ordered faction outcomes for full system fleets
Bigger fleets can create more political facts without losing or reordering them.
Make the ship the player
The player needs a clear heroic identity and power source while factions remain dangerous through fleets, territory, and rare apex threats rather than ordinary ships matching the hero one for one.
Make faction access and trade concrete
Relations need visible local effects and useful strategic risks. A treaty should change where ships can go, what services work, and what both sides stand to lose.
Make faction intent visible before consequences
Drama is readable when the player can connect intent, evidence, choice, and consequence. Silent fallback makes a faction look arbitrary, especially when a failed diplomatic offer turns into aggression.
Put faction drama where the player can meet it
Drama is useful when the player can see its cause, enter it locally, and trust that travel, saves, and hidden intel do not rewrite the story.
Let doctrine create identity without adding a second faction AI
Combat identity should be visible and data-driven without creating a parallel AI, hidden action budget, or public strategy leak.
Give small craft jobs, not new physics classes
A ship's job should change its shape and behavior without duplicating movement rules. Factions can now show their economy and local control through the craft around them.
The Lights in the Dark Have Names Now
I wanted every distant station to feel worth crossing the dark for, with a purpose, a flag, and wounds that wait for your return.
The Galaxy Learned to Say No
I wanted the galaxy beyond the bow to stop feeling like a field of dots, and tonight one distant star told my capital ship it was not welcome.
I Gave Three Small Ships a Reason to Cross the Dark
From the command chair, I wanted every distant light to mean something: ore coming home, cargo moving, or a patrol keeping watch.
Keep travel's mutation lease until rollback ends
A jump now finishes or rolls back fully before another mode can replace the battle.
Capture submitted frames before swap
Screenshots now save the complete frame the game is about to show. The map no longer draws hidden UI behind itself.
Failed travel stays locked until restoration is proven
A broken jump cannot return to unsafe play, and the map tells the truth about what the player can do.
Sync-main auto-rebases unless a major conflict appears
I made sync cleanup automatic unless the branch is truly conflicted.
Make VFX content failure visible before expansion
I built a repeatable visual proof so every effect must exist, render, and identify itself before the library grows.
Make weapon VFX lifecycle data authoritative
Every weapon can now carry its own flash, impact, interception, and expiry look without special-case rendering code.
Run VFX as fixed timed recipes
Explosions, trails, and electrical failures can now unfold in clear stages while staying repeatable.
Reserve VFX capacity by visual importance
Important blasts and hit cues now stay visible in large battles, while smoke layers hold together as the view moves.
Treat flash accessibility as an effect policy
Flash controls now soften the whole effect while keeping the information needed to follow a fight.
Keep wound history outside voxel authority
Fresh breaches now spark, vent, and cool over time while always staying tied to the damage that is really present on that ship.
Scale collision effects from contact severity
Light scrapes now throw a restrained spark fan, while hard rams add a brighter flash, fragments, and dust without hiding the fight.
Tint VFX from authored faction identity
The same weapon effect now reads cyan for the player, coral for the legacy hostile fleet, and violet for the Scourge without becoming brighter or changing shape.
Drive warp VFX from ship lifecycle edges
Arriving ships open a restrained warp wake at their aft face. Departing ships leave from their last real position.
Map planet profiles to VFX through strict data
The planet generator says which world this is. VFX data says how that world's weather looks.
Render planet weather from stable profile seeds
Gas giants, rocky worlds, and alien worlds now choose different weather recipes from data.
Keep planet terrain covered during LOD changes
Planet detail changes without opening cracks in the world.
Keep Metal body lighting in fragment slot zero
The voxel shader keeps data that changes per ship in one stable Metal buffer.
Drive space weather from generated world profiles
Each system now surrounds its worlds with distinct dust, charged filaments, flares, and coronal debris.
Use pipeline linear depth for soft particles
Smoke now fades into ship surfaces instead of cutting across them as a hard card. Sparks and hot points keep their sharp edges.
Structure state and targets use stable simulation identity
Stations now stay damaged, react to attacks, and remain the same target even as the surrounding battle changes.
Give weapon verbs distinct render geometry
Missile swarms now travel as compact groups, while electrical weapons snap across space in a changing zigzag.
Keep faction diplomacy bounded and transaction ordered
Factions can now make deals, answer calls for help, press claims, wage limited wars, and negotiate peace for reasons the game can remember.
Encounter markers show owned instances, not guesses
Spawn requests can be delayed, refused, killed, or reuse slots. A signal or ship scan cannot reconstruct the authoritative pending and active counts. Persistent instances make the marker truthful and replayable.
Jumps pause the bubble but keep the map live
Advancing the old bubble would make travel results depend on machine speed. Freezing the whole window hides progress and removes cancel. This split keeps deterministic sim time while the player still has a responsive screen.
Make fun evaluation explicit and evidence-backed
Build, determinism, asset, and visual checks prove the game works, but they do not ask whether the player makes a clear choice, reads the consequence, and wants another try.
Give every space structure a job before a shape
A station chosen from one global table cannot say why ships are present or make capture, damage, and faction identity legible. Separate data lets a harbor, refinery, listener, yard, bastion, and gate change local traffic without duplicating geometry.
Raids attack exposed infrastructure before the harbor core
I want a raid on a listener, refinery, relay, or yard to create a readable local loss. Repeated attacks on an already dead site or the safest central beacon do not.
Factions remember causes, not one score
One symmetric reputation value cannot express love, fear, need, betrayal, duty, or a shared enemy. Separate causes let factions act differently and let the player see why.
Space structures change local behavior, not only scenery
A purpose label has no value if traffic, defense, repair, intel, and incidents behave the same. Local consequences make each station explain what ships are doing and what the player changed.
Structure effects stay local and weapons obey physical blockers
A disabled relay must not shut down an unrelated shipyard. A warning service must change time, not only text. A station must obey the same physical weapon rules as a ship.
Generated structures inherit local builders and castable conflict
A generated station must belong to the place around it. A raid or opening scene must create real local actors, not a label with no possible cast.
Active structures belong to the factions present and operating them
A local station cannot support a castable story if its active faction is absent, its raid target is friendly, or its guns follow a former owner's doctrine.
Structure activity must name both ends and obey live authority
A station story is only believable when ships visibly travel between places and current control changes who visits, attacks, responds, and appears locally.
Make faction conflict limited, caused, and endable
I want betrayal and cooperation to create readable consequences without turning every refusal into permanent total war.
Destination fleets cook in parallel
The long jump wait was ship building. I split that work across four workers without changing fleet order.
Jump directly from the Strategic Table
This completes navigation without deciding whether the wider game becomes strategy-first, a campaign, or a roguelike.
The game is the only ship visual authority
Its static Three result had drifted from the voxel-native game and gave a false picture of the current art.
My Living World Was Counting Its Dead as Alive
Yesterday my star system passed its own health check. Today I caught it counting corpses as crew, and the honest fix finally taught the world to measure itself without lying.
THE PLANET IS AN UNREACHABLE VOXEL BACKDROP AT ACTUAL PLANET SCALE
Descending to a planet surface was a spectacular tech demo but not the game — StarGazer is capital-ship combat. As pure scenery the planet needs none of the approach/surface machinery (governors, horizon camera rigs, VFX depth bands), and dropping them collapses three fragile depth regimes into one exact partition. Meanwhile "actual planet scale" is what makes the backdrop read as a WORLD: at theatrical scale (14k) the planet was ~93 ship-lengths of radius — a moonlet; at 500k it's a wall of world behind every battle.
Planetfall Phase 3h — the hover sits LEVEL over the surface (+ richer terrain)
The 3g arrival worked but the ship kept the tilt it flew in with, which looked like it had stalled mid-turn rather than arrived. A capital holding station over a planet should sit flat to that planet's horizon — that one change is what makes the hover read as "arrived and parked" instead of "paused." The taller terrain gives the coastline more drama at the scale you view it from.
Planetfall Phase 3i — a broad voxel landscape, not a small patch
The 3g/3h arrival worked, but the view only reached a short distance, so the voxel land felt like a little island rather than a world. Letting the camera see much farther (and growing the voxel ground to match) is what makes it read as a real planet surface you're flying over — the difference between "a patch below me" and "a landscape to the horizon." It's the payoff of the whole planetfall being a place, not a prop.
Planetfall Phase 3j — planetfall is now NORMAL PLAY (the G cruise flies you there)
Up to now the whole planetfall lived behind a launch flag — a demo, not a feature. The point of the ask was "can I actually go to the planet and it's voxel" — and "actually" means in the game you play, by pressing the key you already use to set course, not by relaunching with a flag. Wiring the cruise to land you on the voxel surface (and keeping the terrain invisible until you're there, so combat is untouched) is what turns it from a showcase into a place the game takes you. It's the difference between "I built a planetfall mode" and "the planet is somewhere you go."
Cruise key moved G → J (G was already the shipyard toggle)
A double-bound key is a bug — the shipyard binding is the established one, so the newer cruise binding is the one that moves. (Reported in play: "G is colliding with the shipyard.")
Planetfall Phase 3k — the transition is a joke; NMS research + a from-the-surface SKY
The research's headline lesson is that atmospheric scattering is ONE continuous effect — the limb you see from orbit is the sky you see from the ground (O'Neil GPU Gems 2 / Hillaire). Our atmosphere was limb-only shells that vanish once the camera is inside them (exactly the arrival case), so the surface had literally no sky. A sky is the fastest, highest-leverage step from "green slab in the void" to "standing in a world's atmosphere" — and it's what the ask literally named ("into the atmosphere"). Shrinking the patch matters because a flat finite slab, seen from low altitude, juts ABOVE the true horizon and occludes the whole sky — the smaller it is, the more world + sky show beyond it.
Planetfall Phase 3k.2 — the LOCAL-HORIZON camera (the arrival finally reads as a world)
This was THE thing hiding all the other work. The sky dome and the smaller patch were both there, but the camera was looking straight down at the ship against the ground with a tilted horizon, so you never saw the sky or the curve of the world. A planet has a local "up" (straight away from its centre) that is nothing like the game-world "up" once you're tens of thousands of units out; the camera has to know that to frame a horizon. Aligning the rig to the local horizon is what turns "top-down at a ship over a floor" into "banking over a world."
Weapon mounts were comically oversized — bulk re-trim of the ×3 voxel-scale re-author
The re-author's floor (armament ≥ ~4-8 voxels so it survives the cook) is correct, but ×3 made a "large" drum on a capital a ~3u barrel-less box that dwarfed the hull, and the casemate a ~1.9u cube whose thin barrels vanished against it — reading as shipping crates, not guns. The fix is proportion, not floor: shrink the housings toward the gun and let the barrels carry the read. Verified across four fresh capital seeds (12345, 88, 424, 7777) at real viewing scale — mounts now read as proportionate turrets with visible barrels.
Broadside guns were too LONG — stubby re-trim (reverses the fix-1 barrel lengthening)
The player literally named these "broadside turrets" in the prior report, and the only barrel I'd just made *longer* was the broadside pair — so "so long" maps straight to that change. Stubby is short-and-thick, so the fix is both axes: cut the length hard and fatten the barrel so it still reads as a gun deck rather than a bristle.
FLYABLE PLANET Phase A — the surface is a STREAMED cube-sphere voxel planet
A fixed patch (however broad/curved) can only be a hover backdrop — you'd fly off its edge. A cube-sphere gives every surface tile a STABLE global id, so chunks generate once, stream, and LOD independently, covering the whole sphere (poles included) — the real planetary-terrain substrate (Outerra OSC / the NMS research), not a re-centering hack. Built on the marcher's existing multi-volume API (register/unregister/prune, per-frame poses, front-to-back depth cull) — the AsteroidField already runs many volumes, so this is the same proven path at planet scale.
LOGARITHMIC DEPTH BUFFER — the planet is now VOXEL from orbit (P0 unblocked)
The reverted Phase B.2 proved the smooth mesh could only be a far-LOD because the voxel chunks span too large a depth range for a standard 1/z buffer (clipped past the far plane, z-fighting with a wide one). The log-depth buffer is the *only* clean fix (the research's P0), and now that it's in, the "fully voxel, no shortcuts" planet is real — voxel from space down to the surface.
Log-depth GATED to the approach band — surface VFX stay consistent
The log-depth buffer only *needs* to span the huge range during the approach (a rock in front of the ship + a chunk 27km out). At the surface everything's within the standard far plane, so classic depth is sufficient AND it's what the VFX already write — gating there gets correct plume compositing for free, deferring the full VFX→log-depth conversion to when it actually matters (the brief high-speed cruise). No new mismatch: the only frames with a plume/terrain depth disagreement are the ~5-tick cruise, mostly hidden by cruise speed.
Atmosphere halo CONTINUOUS across the mesh→voxel boundary
The vanishing halo was the most jarring part of the descent pop and was an artifact of the BodyHidden early-return (it dropped the shells too), not inherent to the LOD architecture — so it's a seam to close, not a fundamental limit. A full mesh→voxel silhouette crossfade (geomorph/impostor) remains the hard, deferred piece; halo continuity is the cheap high-impact 80%.
Crisper planet from orbit — finer terrain voxels (CellsPerChunk 32→64)
Blockiness from orbit was purely the voxel SIZE, and the marcher profiled as coverage-bound with ~11ms of headroom under the 16.6ms/60fps budget — so buying 2× the detail for ~0ms of steady GPU cost is the obvious lever. Chose finer cells over more chunks (higher baseRes) precisely because it adds detail without multiplying draw calls.
Galaxy backdrop structure (Skysphere/Starfield/NebulaClouds) — render-only, hash-neutral
The code that paints the sky at startup now draws a structured galaxy — a banded core with dust lanes — instead of an even haze, and the stars cluster along that band. None of it runs per frame or touches the game simulation, so nothing about the game's determinism changed.
Far-layer rendering + world-positioned terrestrial planet (Phase 2a/2b) — render-only
Added a way to draw very distant things (like a planet tens of thousands of units away) that the normal camera would clip away, and gave the planet an Earth-like surface generated from the same kind of noise the real terrain will use later. None of it runs in the game simulation.
Planet-approach cruise governor (Phase 2c) — sim-side autopilot, hash-neutral
New sim code flies the player's ship to the planet on command, slowing smoothly as it arrives. It only runs when the player chooses it, so the game's fights and its automated tests behave exactly as before.
Shared PlanetHeightField + displaced terrain mesh (Phase 3a) — render-only
Added one shared, exactly-reproducible "how tall is the land here" function, and used it to push the planet's surface out into real hills and coastlines. It doesn't touch the game simulation yet.
Voxel terrain patch renderer (Phase 3b) — render-only
New render-only code turns a patch of the planet's surface into blocky voxel cubes read from the same height map the orbital planet uses, flat-shaded by the sun like the ships. It doesn't touch the game simulation.
Voxel terrain migrated to the GPU marcher (Phase 3c) — render-only
The planet ground is now drawn by the same voxel engine as the ships — same lighting, same detail-reduction, same destructible material — instead of a separate stand-in that painted its own light. It still doesn't touch the game simulation.
Destructible voxel terrain (Phase 3d) — render-side Direct overlay, render-only
New render-only code carves craters into the voxel ground so it shows real holes — the same hole-rendering ships and asteroids use. It doesn't touch the game simulation.
Surface-arrival mode (Phase 3e) — render-only, env-gated
New render-only code lays the voxel terrain out as a ground plane under the ship and frames the shot, so you see your capital hovering over the planet surface. It doesn't touch the game simulation.
Surface descent (Phase 3f) — governor retarget + level attitude, hash-neutral
The ship now flies itself down onto the voxel surface, staying level like a big ship should. It reuses the existing "fly to the planet" autopilot aimed at a point under the ground; the only new sim behavior (staying level in a steep descent) never runs in the automated tests, so the game's determinism is unchanged.
Point defense is a recharging burst, and missiles now saturate it
The old pass granted PD its full capacity EVERY tick, so crossing the 200-unit intercept sphere (~20 ticks) multiplied PD strength twenty-fold: a healthy capital provably shot down every missile ever fired at it, which is exactly what play felt like ("they get shot down pretty fast"). The AI's own volley math already assumed the salvo-minus-K model; now the sim agrees with it. My first cut used fixed tick-windows and the new gate arm immediately caught volleys straddling a window boundary facing double budget, which is why it became a rolling bucket.
Collapse the dev command stack behind one small toggle
The dev buttons were always on screen and dominated the right third of the view, which made the game read like a debug tool instead of a game. They are still one click away, and every one of them still has its keyboard shortcut, so nothing got less reachable.
Showcase reels roll a fresh ship, reproducible by seed
A marketing or demo reel that always shows the same ship hides the whole point of the game (every ship is procedurally generated and different). The seed is the reproducibility answer: variety by default, exact repeat on demand, without falling back to a boring fixed ship.
Fix the two dead cinematic beats (shear + head-to-head)
The trailer's self-check had been failing on these two beats since before this session (I confirmed it against an older build) because the game's combat and damage systems moved on while the beat scripts didn't. A trailer scene that stages no combat or checks for a deleted effect is worse than useless. This is exactly the silent drift that rots a vibe-coded project.
Planetfall research — adopt DeepSpaceEngine techniques at theatrical scale, techniques only
The engine is an unknown (zero stars) but genuinely good reference: it proves the whole seamless orbit-to-surface pipeline runs in C# on weaker GPU features than ours, and its design docs record the lessons (precision first, per-seed determinism, geomorph + fractional octaves for pop-free LOD, worker-pool baking). The scoping insight that makes descent affordable for us is that its hardest subsystem — true-scale coordinates — is the one part a single-arena combat game does not need. The backdrop gap, meanwhile, turned out to be composition rather than technology: our sky is a uniform nebula wash, theirs is a structured galaxy; our existing procedural bake infrastructure can produce their look by changing what it bakes.
DeepSpaceEngine owner granted permission to use parts of the code
The whole planetfall proposal keyed its legal framing off DSE having no license file (all-rights-reserved by default). Direct permission removes that constraint for the parts that port cleanly as C#, which meaningfully speeds up Phase 2-3 (adapt a proven, tested noise/quadtree implementation rather than rebuild it from prose). Recording it matters because "why is there DSE-derived code in the tree, and under what right" is exactly the provenance question a future contributor — or a storefront's legal review — will ask; a verbal okay that isn't written down is the kind of thing that rots.
Capital ships now frame big — size-adaptive camera distance
The old default framed every ship at the same fixed distance regardless of size, so a capital read like a desktop model and a fresh fighter was a distant speck. Framing by size is what makes a big ship actually feel big — the complaint that started this.
Planetfall Phase 1 — the sky becomes an edge-on galaxy
The user liked how the reference engine renders its stars and background, and the gap turned out to be composition, not technology — our procedural sky bake already had the machinery, it just baked a flat smear. Adding band structure + a bright core + a dark rift is what makes a sky read as a real galaxy edge-on. Keeping the core aimed at the default camera means the improvement shows on "run the game," not only when you turn to look (default run is the showcase). I pulled the core brightness back a notch so the deep-black void contrast the middle-ground baseline wants is preserved.
Planetfall Phase 2 (render foundation) — the planet becomes a destination
The load-bearing problem the review flagged is that a planet parked that far out is far past the camera's far plane and simply would not render. Solving that (a far-layer with its own wide projection, drawn behind the arena) is what turns the planet from unreachable-backdrop into a body the game can actually place at destination scale. Making it terrestrial (baked from the same seeded height field a future terrain would use) both reads as a place you'd land on and de-risks Phase 3 — if the continents look good painted on the sphere, the terrain will. Keeping it world-fixed is the difference between "a bigger backdrop" and "a destination."
Planetfall Phase 2 — you can now fly to the planet (approach cruise)
The ship's normal top speed is tiny (tuned for close-range capital combat), so the planet was effectively an hour away at combat speed — a beautiful backdrop you couldn't reach. And simply letting the ship go faster would have broken combat (the player could sprint at hundreds of times combat speed around the arena). A separate, opt-in cruise autopilot is the clean answer: it makes the destination reachable and the arrival cinematic, while leaving combat speeds and feel exactly as they were. The eased, self-slowing approach (fast then gentle) is what makes arriving feel like settling into orbit rather than slamming to a halt.
Planetfall Phase 2 polish — cruise turns nose-first, toggles, and arrives on its own
The raw mechanic worked but read rough — a capital ship crabbing sideways toward a planet looks broken, holding a key for a ~20-second flight is tedious, and a travel mode that doesn't tell you when you've arrived leaves you fighting the autopilot. Turning nose-first, toggling, and auto-arriving are what make it feel like a deliberate "set course for the planet" command instead of a debug hold. The turn is a smooth swing (not a snap), so engaging cruise looks like the ship banking onto its heading.
Planetfall Phase 3 (start) — the planet becomes a real 3D world
This is the load-bearing, always-needed foundation for any version of "descend to a surface": one deterministic height map, and the mesh pipeline that turns it into visible relief. Getting that in — and proving the terrain renders (relief in the silhouette, a flyable coastline) — de-risks everything downstream and is a real visual leap (a world, not a marble). It's honestly limited without the next piece, though: from orbit the relief is too small to see (it looks like the Phase-2 textured planet), and up close the fixed-resolution surface is soft and blocky. Both are fixed by the quadtree level-of-detail system (fine surface only where the camera is close) — the multi-session heart of Phase 3, which is the natural next decision point now that there's a 3D world to look at.
Planetfall Phase 3b — the planet surface is voxels too
Everything in StarGazer is voxels — the ships you fly, the asteroids you shoot, the wreckage. A smooth painted-mesh planet surface would be the one thing that ISN'T, and dropping onto it would break the whole aesthetic the moment you got close. Proving the surface can be built as on-brand voxel cubes from the shared height map — and that it reads as a real coastline with biomes and per-face sun shading — is the load-bearing "does the look work" answer before I invest in the streaming/level-of-detail machinery that makes a whole planet of it. Doing it as a simple cube patch first (rather than jumping straight to the destructible GPU version) got that answer cheaply.
Planetfall Phase 3c — the planet surface runs on the real voxel engine
Everything in StarGazer is drawn by one voxel engine — the ships, the wreckage, the asteroids. Having the planet surface drawn by a SEPARATE stand-in renderer with its own hand-painted lighting was the seam that would always look slightly "off" next to a ship parked on it, and it was a dead end: the stand-in couldn't be shot, couldn't share the ships' destruction, couldn't share their detail-reduction. Putting the surface on the real engine is what makes it a first-class part of the world — the lighting matches the ships automatically, and it's now the exact same destructible voxel material, so weapon damage to the ground is a wiring job on top of what's already there rather than a whole new system. The stand-in did its job (it proved the look); this retires it.
Planetfall Phase 3d — you can blow holes in the ground
"Everything is made of destructible voxels" is the promise of the whole game; the ground being the one indestructible thing would break it. Proving the surface actually craters — with the same look as ship/asteroid damage — closes that gap and confirms the marcher-migration payoff (the ground is real destructible material, not a decorative skin). Doing it as a scripted carve first is the honest increment: it demonstrates the capability now, on the exact rendering path the live version will use, without pretending the surface is reachable by weapons yet (that needs the orbit→surface descent).
Planetfall Phase 3e — the capital ship at the planet surface
The arc so far built each piece — a galaxy sky, a planet to fly to, the cruise to reach it, the surface turned to voxels, put on the real engine, made destructible — but never showed the one image that makes it all land: your ship over that surface. Staging it now proves the surface reads as a place a capital ship belongs over, at the right scale, with the space horizon selling "this is a planet, and I'm above it." It's the emotional close of the loop even though the *mechanical* descent (flying continuously from orbit down onto it) is still ahead — worth having the destination view now so the descent has an obvious target.
Planetfall Phase 3f — flying the ship DOWN onto the surface
Phase 3e showed the ship AT the surface; this is the motion that gets it there, which is the verb in "bring my capital ship DOWN to a planet." Reusing the existing cruise autopilot (just aimed at a point below the ground) meant the descent came almost for free — the same self-easing travel that solved "the planet is too far to reach" also solves "come down gently onto it." The one thing that needed fixing was attitude: the autopilot turns to face where it's going, which for a straight-down descent pointed the nose at the ground (a capital standing on its nose — wrong). Making it hold its deck level for steep descents is what turns an awkward plunge into a proper warship settling onto a world.
Planetfall Phase 3g — you can actually FLY to the planet and it's voxel
This is the actual thing that was asked for — "go to the planet and have it be properly voxel, hover 5000 ft up." The big worry (a planet parked tens of thousands of units away can't be drawn as voxels from that far) turned out not to block it: because the SHIP flies there too, once you arrive the voxel ground is right next to the camera, and the numbers stay precise enough at that distance (sub-centimetre) to draw it cleanly — so no elaborate "re-center the universe" machinery was needed, just placing the voxels on the real surface and flying there. Lighting the approach side (it's the planet's night side by geometry) is what turns a dim arrival into a bright green voxel coast.
Weapons are data: def catalog, pack bindings, declared visuals
Every weapon in the game, from its damage numbers to the color and shape of its shots, now lives in small data files instead of buried code, so a new weapon is a short recipe file rather than a programming session.
Armory phases 6-8: live tuning, loadout defs, material seam
Tuning a weapon, changing the player's build presets, and deciding how armor resists each damage type are now all edits to small data files, and a running game can be tuned live and save those tweaks back to the files itself.
Coarse cook keeps the largest component, then seats the core
Some randomly generated ships were secretly hollow to the physics engine because a floating crumb of hull stole the ship's heart during baking, and the game crashed when they tried to fly; now the bake always keeps the real ship and the crumbs are swept away.
Projectile velocities quantize to a 1/32-voxel lattice
Plasma shots were snapping to a coarse direction grid at launch and could miss where you were aiming by a wide margin; the grid is now 32 times finer, so shots fly where the crosshair points and a test keeps it that way.
Gunnery review hardening: floor, faction guard, archetype re-check
I had the new weapon system reviewed and hardened the rough edges: a shot can never round down to doing literally nothing, the systems-disruptor beam won't knock out your own ships, and a mistyped build can't quietly load the wrong gun.
Weapon-arch cleanup executed: one owner per stat, one copy per rule
I had the weapon code audited for tangled wiring, then rewired it so every number has exactly one home and every rule is written exactly once, which also fixed the build presets so their stat bonuses actually apply when you play.
The player flies a freshly generated ship every launch
Every session should open on a ship you have never seen before - the generator is the game's content engine, and the launch moment is where that variety should show.
The whole battle is freshly generated every launch
The generator IS the content engine; a roster of eight hand-kept ships was a placeholder cast. Every battle should be a fleet nobody has ever fought.
Weapon machinery scales with the hull, not the class floor
The 0.75 floor exists so hull greebles stay readable, but weapon banks clamped UP dwarf a short hull: the owner's 9.2u ship carried side turrets sized for a 13.5u hull, 47 percent oversized, spanning the full flank height. Machinery must read as hardware ON the ship, never rival the ship.
The Gunnery: player gun system expansion proposed
The audit showed the bottleneck is not tech, it is roster: salvo/pattern fields and the whole EMP system are implemented but unused, and the player literally cannot pick a different gun, only tune the fixed one.
Swarm missiles: vertical tube launch, ripple, arc onto the lock
Missile volleys that pour out vertically and curve onto the target are the single most iconic sci-fi combat read, and the ordnance group was dead weight: it had NO launch trigger in mouse-aim mode at all.
The Gunnery A1+A2: builds pick guns, five new player weapons
The audit showed the real gap was not tech but roster and selection: the player literally could not swap a gun. A1 unlocks that with a small keystone; A2 fills the roster with data only, no new code.
The Gunnery A3: armor now matters (damage-material matrix awake)
The audit's biggest sleeping lever was the per-cell material table, shipped neutral so the plumbing risk landed separately from the balance decision. Waking it makes a ship's armor placement tactical reading and gives HE its identity as the mount-stripper.
The Gunnery B4: player HE spall (the mount-stripper)
The spall resolver existed but nothing the player fired reached it, and A3 had just given HE a material identity worth exploiting. A distinct projectile kind isolates the change so nothing existing moved.
The Gunnery B2: the EMP beam (arc-projector, the tech-killer)
The whole EMP disable system was implemented (it powers the spinal disruptor) but no player weapon delivered it. A hitscan beam is the cleanest EMP delivery, and it slots straight into the primary picker.
Allies are immune to all friendly fire
Friendly fire was a latent gap the weapon review surfaced (the EMP beam, and every existing hitscan, would carve a teammate in any ally scenario); with the arsenal expanding it is time to make allies safe by rule rather than by luck of positioning.
Middle-mouse target lock (and the T double-bind fix)
Gunner mode freed the left button for firing and lost click-to-lock, leaving Tab-cycling as the only designation path — awkward mid-fight. A dedicated mouse button makes locking a flick.
All player weapons live on the hotbar, one trigger fires them
I kept catching dedicated fire hotkeys sneaking in (T for missiles was the second). One trigger plus an arm/disarm loadout bar is the model: the bar shows everything you can fire, keys stay scarce, and arming finite ammo is a deliberate act instead of a fat-finger.
The target-lock reticle is player HUD, not a debug visual
Screenshots lied by construction: capture frames force the debug overlay on, so every verification screenshot showed brackets while live play showed none. The fix ships with a catalog case (mmb-lock-reticle) that stages the live-parity frame (lock scripted, debug lines hidden) so the regression cannot re-hide. The same pass surfaced that the scripted-input branch dropped the lock stamp entirely (third instance of the scripted-branch-must-mirror-the-live-stamp class); both scripted returns now carry it.
Transient dynamic lights: combat flashes cast onto hulls (8-slot, render-tier)
When something explodes next to a warship, the warship now catches the flash — bright on the facing side, falling off around the hull, cooling from white-hot through orange toward the arcane violet as the blast dies.
StarUI foundations + settings graphics tab (one arc, gallery canary, settings proof)
The game now has real menu building blocks — rows, cyclers, one keyboard-focus system, one look — and its first real settings screen built from them, where changing an option takes effect instantly, saves itself, and can never silently fight the developer test switches.
Settings fast-follows: controls-tab rebind UX + device rows (display/vsync/render-scale)
You can now rebind every flight key in the menu — the game warns you when a key is stolen from another action and shows exactly what's still bound where — and drop the 3D resolution to 75% or 50% for frame rate without the menus or HUD getting blurry or tiny.
Sprint architecture audit: 28 confirmed findings, one crash fixed, work list in UI-WEAPONS-ARCH-AUDIT
We had thirty-three reviewers comb through everything shipped today; the features themselves are solid, but the places where new code gets bolted on are wearing out, and there is now a ranked to-do list for reinforcing them — plus one crash that could only happen on machines missing shader files, fixed on the spot.
core_rating is pack data: the re-knit gate and rate come from the sidecar, not a player-index check
Each ship's data now says how good its magical heart is at re-growing lost hull; every enemy ships with an ordinary heart that cannot, and the player's unique one still can, so nothing changes in play — but a future boss that heals is now just a number in its file.
The Core RE-KNITS: carve damage heals after disengaging; severed matter is spent forever
Degradation without recovery is a death spiral and made every fight pure grind-down; the two-tier economy (chips heal, severs cripple) makes sever-hunting the decisive layer and creates the disengage-to-heal rhythm, exactly where the ship-class review pointed.
Canon amendment: ONLY the player's Core re-knits — everyone else's cores are lesser
It puts the player's Core at the literal center of the power fantasy — the one artifact in the sky that can undo violence — and it keeps fights convergent: the player can attrit an enemy across passes without it healing back, so patience is always rewarded.
THE WEAVE: channeling the Core is a held stance with a cost, and its onset is an event
Passive-only regen is a timer, not a decision; routing the accelerated weave through the reactor makes disengaging-to-heal an ACTIVE choice with a visible cost and a dramatic beginning, in the same resource language as every other player expenditure.
Damage-control UX: focus the weave, see your envelope, read ADRIFT on the target
The physics arc made damage REAL but invisible and unsteerable — the player could lose authority without seeing it, and the weave healed in an arbitrary order nobody could direct; this pass turns the recovery loop into decisions a player can read and make (engines first when adrift is THE beat).
The target lock gets teeth: lock-gated plasma homing + a lead pip
The lock panel was excellent intel bolted to a ritual — Tab did nothing your weapons could feel; homing-on-lock plus the lead pip makes designating a target a real tactical verb that pays off in landed volleys.
One trigger fires the loadout (supersedes the 2026-07-01 split-trigger model)
The split-trigger model shipped 2026-07-01 read as broken in play — the owner armed plasma+laser, held the fire button, and nothing visibly changed ("i turned on plasma and laser but its not shooting"). A toggle that arms a weapon the trigger then ignores is a lie in the UI; one trigger + a loadout hotbar matches the ARPG framing the kit was designed around (enable your kit, hold the button, manage the reactor).
The showcase must exercise every weapon: class-interleaved AI pool + a legible hotbar
"Default run is the showcase" is a tenet — a default encounter that cannot exercise a third of the player's kit is a broken showcase, and a toggle state the owner cannot read in the heat of a fight is not a state indicator.
Visible weapon mounts on the player ship: turrets that track your crosshair
The mounts existed only as data and baked voxels — the player could never SEE their broadside face the enemy or their turrets swing onto a target; tracking heads turn the crosshair into something the ship visibly obeys, which is the whole capital-gunnery fantasy.
Armament is voxels in the pack: gunmetal finish + voxel-scale guns + capital main battery, render bolt-on removed
Ships ARE their cooked voxel packs; a runtime overlay is a parallel geometry system that damage, mass, and per-pack binding can never see. And the voxel grid imposes a minimum feature size: geometry authored below one voxel does not exist after the cook, no matter what color it is — armament must be authored AT voxel scale, in dark steel, or a warship reads as an unarmed liner.
Auto-turrets harass everything (supersedes decision-6's fighters-ONLY gate)
With the fighters-only gate, an armed AUTO slot in a big-ship fight was dead weight — indistinguishable from broken (the exact confusion that opened today's UX thread). Constant low-grade harassment keeps the hull visibly alive and the slot's firing pulse honest, at zero cost to the kill economy because the ballistics never mattered against armor.
Plasma gets its own body: compact violet ball, stubby wake (VFX identity)
A weapon named plasma that draws as a kinetic shell is a broken promise — and the long tail + big head made the player's own secondary read as incoming enemy fire in a furball. Violet also rhymes with the Core's arcane identity (the magic canon's color) without colliding with the enemy-warm or player-cyan lanes.
AI reacts to crippled ships: finish the helpless, go weapons-platform when it is you
The flight-dynamics arc made maneuvering authority real, degradable, and recoverable — but the AI ignored it: pilots thrashed dead controls chasing orbits they could not fly and kept respectful standoff rings around helpless wrecks. Both read as broken the moment a player notices.
The Guns Are Real Now, and the Hull Knows How to Mend
My ship finally wears guns you could shoot clean off her spine, and when I limp clear of the fight and hold the weave, her heart drinks the reactor dry to knit the wounds closed in violet light.
Live mass properties: ShipMassTracker follows damage (flight-dynamics P1)
A ship now keeps honest books on its own remaining matter, so a hull that loses a flank collides and strains like the lighter, lopsided thing it has become.
Damage now reshapes handling: live maneuver-static rebuild (flight-dynamics P2)
Battle damage now changes how a ship flies: lose a flank and it turns lopsided around its new balance point, while a lighter, shot-up hull answers its surviving engines more eagerly — and an undamaged ship flies exactly as it always did.
Flight dynamics direction: handling derives from working RCS, thrusters, and live mass
The model is already half force-based (thruster positions and forces, a torque Jacobian, per-thruster alive fractions, a real anisotropic tensor in collision response), but mass properties freeze at load and authored rate caps mask the physics, so damage never reads in the player's hands. Closing those gaps is an upgrade, not a rewrite.
Canon: the Core is magic; hull matter is woven and can be re-knit (sci-fi meets magic)
One fiction rule now explains and stabilizes a set of previously separate decisions (severed pieces dissolving, core death as total dissolve, the hot-to-arcane color journey, the VFX tech-vs-arcane split, the repair economy in FLIGHT-DYNAMICS-PLAN), and it constrains future features cheaply instead of demanding a magic subsystem.
The Fleet Finally Glows on PC
For weeks PC players could see everything except the ships. Tonight the whole fleet finally drew, and then it caught fire with light.
Solo agents may self-merge worktree→main; the gate is *concurrency*, not worktrees
The rule was written for the parallelizable-by-design case (multiple Agent(isolation: "worktree", …) running at once; the human reconciles to avoid clobbering). It was being mis-applied to *solo* worktree work, forcing a pointless human merge step on a single developer who only used a worktree for isolation — exactly the completion-blocking friction the 2026-06-21 skills audit set out to remove. A lone agent has no one to collide with, so hand-merging its branch is ceremony, not safety.
The Day the Ship Became Mine to Shape, Then Stood Trial
This morning the answer was no. By night you could stand on your own bridge and rebuild your warship in the dark, watch it tear itself down and become yours. Then a panel of pitiless reviewers tore the whole thing open and found twelve wounds I had been quietly taping over.
Ship-ship collision damage — impacts crater + shed chunks, "dramatic but survivable" (owner request; v1 of universal collision)
Collisions were inert — ships bounced as rigid boxes with ZERO damage (the Collision damage type existed but was never emitted). That is both undramatic and tactically dead. Real ships now take a proportionate crater (a 985k-voxel hull shrugs off a ~1.3k-voxel ram-dent at 99.9% hull yet sheds visible chunks; a small/fragile hull can be gutted by a hard ram), which turns ramming + positioning into a real tactic.
VoxelType catalog is the cross-stack material registry (P2a foundation, hash-neutral)
the alternative (a fixed ≤16-row role enum in a single palette byte) right-sized the visual scope but under-modelled the owner's "hundreds-to-thousands of variants + per-ship aggregate stats, no future rewrite" requirement; a 32-bit catalog id costs the same per-voxel (zero) and never needs a format bump to grow. Building the registry FIRST as the contract makes armor/interior/resistance/glow all "assign an id, read its row" instead of N ad-hoc special cases — the strongest answer to silent cross-stack drift.
Armor exterior = hull paint + metallic gleam, steel only on the cut edge (owner decision)
At the fleet's cook resolution the armor rind is the whole 1-cell exterior skin (K=1), so tinting Armor strongly toward gunmetal (the prior pass's RoleTintStrength Armor=0.82) repainted every cooked ship gunmetal and erased its signature hull color — a kestrel no longer read blue. The owner's call: the SIGNATURE COLOR is load-bearing (ship identity at a glance), so it must survive on the unbreached hull; the "this is armored" read comes from the gloss, and the "you can see the plating at the wound" read comes from steel on the cut edge — both without touching the paint. This keeps the cross-section informative (the cake interior already provides breach contrast) AND keeps the fleet recognizable.
A Million Blocks Deep
For months my capital ships were gorgeous hollow shells that faked every wound. This week I deleted the last of them and rebuilt the whole fleet out of solid matter, so now when you punch a hole in one, you are staring straight into its guts.
Pack format v2 + SceneIR→SDF cook contract (P0 of GLB retirement)
I wrote the new ship-file contract and its tamper-evident checksum chain down on paper before touching code, so the migration off the old mesh format has one exact target and the simulation's answer key is allowed to change exactly once, with my sign-off.
GLB retired: ships are voxel-native end to end
the voxel volume is already the render and damage truth; a triangle artifact surviving as cook input, hash anchor, and fallback renderer is a second source of truth I pay to keep in sync on every change. Honest drift I am signing up for at the flag-day: all 10 packs' voxel sets re-source (SDF is not bit-for-bit SAT), the suite baseline moves exactly once with my acknowledgment, and ship radius/mass shift by at most 0.4%/1.1%.
Voxel-render Phase 0 — share FNA3D's SDL_GPU device (the engine fork) + fix a latent FNA3D rebuild bug
Taught the engine to hand our new voxel renderer direct access to the GPU so it can draw ships as true voxel volumes — and fixed a hidden bug that stopped the engine from being rebuilt at all on a current system.
Voxel-render Phase 1 — GPU ray-march proven in the live frame (THE gate, passed)
The game can now draw true ray-marched voxel objects inside the normal scene — they correctly hide behind ships, ships hide behind them, and weapon beams pass in front and behind them properly. The door to Teardown-style voxel ships is open.
Voxel-render Phase 2 — solid materialized 1M-voxel brick volumes per pack (additive, zero sim drift)
Every ship now has a million-voxel solid version of itself, colored exactly as the ship designer painted it — cooked, verified, and stored compactly — ready for the GPU to draw, without touching any of the game's existing simulation guarantees.
Voxel-render Phase 3 — the player ship IS ray-marched voxels (848k-voxel brick volume, GLB parity verified)
The player's capital ship is now drawn as nearly a million tiny cubes, ray-traced live on the GPU — and it looks like the same ship in the same colors, just made of voxels, exactly the Teardown-style goal.
Voxel-render Phase 4 — the whole fleet is ray-marched voxels, and it's FASTER than the mesh path
Every ship in a hundred-ship battle is now made of a million voxels each, drawn by tracing rays — and the game runs at 60 fps, slightly faster than the old way of drawing ships.
Voxel-render Phase 5 — the SceneLighting rig + voxel corner AO + sun-shadow march in the marcher
Voxel ships are now lit by the same sun and studio lights as everything else, every little cube corner self-shades realistically, and the ship's own structure casts soft shadows on itself — the flat toy look is gone.
Voxel-render Phase 6 — REAL destruction: sim damage punches holes through to the cooked interior
Shoot a ship and the cubes are really gone — you see the dark guts of the ship inside the hole, exactly like Teardown. The old fake-dent system can't drift out of sync anymore because there's nothing to keep in sync.
Voxel-render Phase 7 — the flip: ray-marched voxel ships are the DEFAULT showcase
From now on, just running the game gives you the voxel ships — a million cubes each, real holes when shot — with the old renderer kept as a safety net you can switch back to with one setting.
Damage perf-on-hit — baked-distance field + per-vertex 2-pass build + rebuild throttle (render-only)
Getting hit used to freeze the game for a moment while the torn-up hull was rebuilt; now that rebuild is ~6-10x faster and happens far less often, so combat stays smooth.
Readable battle-damage deformation — coherent shared-basin bowl + wall-shading normals (render-only)
Damaged hull now visibly caves in around a breach — a dented bowl of plating that catches light — instead of looking like a flat wall with a clean hole punched through it.
Kill grazing-angle residual see-through — plug the carve↔interior mouth-ring gap (render-only)
from a glancing angle you could still catch a sliver of space through the very edge of a breach; the breach's inner cavity now plugs the opening edge-to-edge and flares inward, so there's always solid dark structure behind the hole.
High-res capture override + see-through verified at 3200×1800 (the "peek-through" was silhouette, not a leak)
Added a way to take much higher-resolution screenshots, used it to zoom way in on the battle-damage breaches, and confirmed you can't actually see through the hull — the bit of background near a breach is just the edge of the ship, not a hole.
Documentation + skill drift sweep — audited all CLAUDE / MCP / charter / schema docs + 23 skills against the live repo (two-workflow audit→fix)
Swept every project doc and skill file for claims that had gone stale as the code changed underneath them — references to a build server that doesn't exist, renamed folders, deleted features still written up as live, out-of-date counts — and fixed 124 of them so the instructions match the actual repo again.
Ship rendering becomes GPU ray-marched voxels (voxels as the single source of truth)
Today a ship has TWO representations — a GLB triangle mesh it renders through, and a separate sim voxel grid that drives gameplay — kept in uneasy sync, with damage *faked* by deforming the triangle mesh to approximate voxel destruction (the recurring see-through / boxy-breach damage bugs are exactly this gap surfacing). Collapsing both onto one voxel representation makes destruction REAL (a hole exists because the voxels are gone, with solid interior behind it, not because triangles were dropped), unifies the pipeline, and unlocks the volumetric look. Teardown proves per-object voxel volumes + in-shader ray-march hold 60 fps on modest hardware; ESVO supplies the hierarchical empty-space-skip and attribute-averaging-for-LOD ideas (we take those, not its octree encoding).
Federation ship family in the generator (family-gated, non-invasive)
Added Star Trek Federation ships to the generator without changing any existing ship — all the new code only runs for the "federation" family.
Federation hardening — fix core zone + RCS, add excelsior variant, completeness test
The first Federation ship looked right but had a mis-placed reactor and thrusters firing the wrong way — the tests caught it, and I reshaped the hull so both the cruiser and the new big explorer pass every check.
Wound heat — fresh breaches glow molten, old scars cool to charcoal (render-only)
Fresh hull breaches now glow hot like just-cut metal and cool to dark charcoal over a few seconds, so you can tell a ship that was just hit from one carrying old wounds.
Debris chunks — fresh impacts knock tumbling wreckage off the hull (render-only)
When a ship takes a hit, chunks of burnt hull now break off and tumble away into space.
Fix textureless damaged hull — wound-heat floor + lighter heat-bleach (render-only)
Badly damaged ships were turning into flat grey blobs; now they stay charred metal that keeps the ship's colour.
Damage proving harness + see-through invariant (tear/deform/stretch gated to a backed interior)
Badly damaged ships had holes you could see space straight through. Now a hole is only ever opened where there's solid interior behind it; everywhere else the plating stays whole and just chars.
Federation (Starfleet) ship family — saucer + warp-nacelle hull type
The fleet was all original wedge / spine / dreadnought silhouettes; a recognizable real-world archetype adds instant-read variety. The "Federation" read lives in the SILHOUETTE (saucer + nacelles), so it survives the project's vibrant-color rule — the hull is a saturated Starfleet azure that clears the HULL_COLOR vibrancy floor rather than the canonical desaturated grey (which the floor would resample to a random vibrant colour).
The Ship I Grew Up Wanting to Command
The silhouette everyone knows now flies in my fleet: a broad saucer, a slim body behind it, two nacelles swept high and glowing blue. I finally built the ship I sat too close to the TV for.
Claude-only consolidation — AGENTS promoted into CLAUDE, agent-agnostic file removed
The project only uses Claude now, so the old generic "AGENTS" instruction files are gone and their contents live directly in the "CLAUDE" files Claude already reads. Nothing about the rules changed — they just live under one name. Old diary/history entries still say "AGENTS" on purpose, because that's what the file was called when they were written.
Dark-end color floor — kill near-black structural albedo on ships
Ship sidepods, vents, fairings and other structure used to be painted nearly pure black, which looked harsh against the bright hull. They're now a readable dark grey-blue instead. Only the paint changed — the ship shapes are byte-for-byte identical, so the game's determinism checks are untouched. The deep shadows tucked between the tiny surface details are still dark, but that's real 3D shadow, not paint.
Wound smoke — lighter + PS1 screen-door dither (see-through, tasteful)
Battle smoke used to be a thick grey cloud that covered the ship. Now it's a light, retro dot-stipple haze (PS1-style) you can see the ship through.
The Fleet Got Its Colors
For weeks my whole fleet was the same grey smear. Then I went loud, and a battle line of rival houses came up out of the fog: steel blue, deep violet, and a dreadnought the color of old blood.
Voxel-driven mesh-deformation damage renderer (per-cluster wounds, render-only)
Battle damage is now built by bending and tearing the ship's actual surface around where it lost material, with each separate hit becoming its own torn, charred, glowing wound, instead of stamping square holes on a grid.
Ship battle damage tears the hull open (epic capital-ship wounds)
the prior attempts read as cheap because the torn edges snapped to the ship's blocky internal grid (square holes); I had my agents drive the wound shape off the visible hull surface instead, with the internals only deciding where and how big. Damage finally looks like a wound, not a missing-block bug.
The Hull Tears Open
For weeks my ships died on the inside while the outside stayed perfect. Tonight the armor finally tears open where the shot lands, glowing at the rim, the ship's bones showing through the dark.
Performance & Scale pass — 100 ships as the comfortable case (caps, pooling, registries, LOD, perf gate)
I measured first and found the game already runs 100 ships smoothly — so instead of chasing speed I fixed the things that quietly broke or got messy AT scale: every ship now has thrusters (not just the first 32), big battles show many beams (not 8), the asteroid belt and turret-aim stop wasting work, loading 100 unique ships allocates 396MB less, distant ships use a cheaper body that looks identical, and adding new systems/renderers is now a one-line register. A new automated gate guards the speed numbers so they can't quietly regress, and I re-checked the determinism hashes and the on-screen pixels myself after every step.
Upgrade FNA and StarGazer to.NET 10 LTS
I updated the game engine and its build tools to run on the latest long-term support version of the software framework.
Harden docs against two verification gotchas (voxel-suite cwd, launchctl env-strip)
I wrote down two easy-to-trip traps so future-me (or an agent) doesn't fall into them again: always run the determinism test from inside the game/ folder (a crash there means wrong folder, not a missing file — don't "fix" it by regenerating the file), and remember that the game launcher drops any custom env switch you didn't explicitly wire through.
Visual verification is a ship requirement — catalogued visual-test suite, equal weight to determinism
I built a proper test area for "does it look right on screen". For each visual feature there's now a saved test that puts a single ship in a fixed camera view and triggers the feature (e.g. fire each thruster direction), takes a labelled screenshot, and writes down exactly what to check. The feature isn't "done" until someone has actually looked at that screenshot and confirmed it — the same bar the determinism hash checks already hold.
Input layer plus the camera-mirror fix for inverted controls
The ship was steering backwards because the camera sits behind it and flips left and right on screen, while the controls had been set up for the opposite view. I proved which way each control really turns the ship, corrected them, and rebuilt the control system so keys and a gamepad both run through one place that decides direction, with a test that fails if anyone ever flips it again.
FNA fix #1 — SpriteBatch delivers MatrixTransform to custom effects
A long-standing engine-side bug silently dropped sprite-pipeline shaders we wrote ourselves: the rendering library only handed the screen-mapping math to its built-in shader, so a custom shader saw zeros and quietly drew nothing. I fixed the library so it now hands the same math to a custom shader too, and proved it with a deliberate magenta test that was invisible before the fix and floods the whole screen after.
FNA campaign foundation — build-fna3d + first locally-rebuilt libFNA3D.0.dylib
Up to today our shipped FNA3D binary came from an upstream CI farm. Now we have a one-command script that rebuilds the same binary locally from our own source tree, plus a doc explaining how to do it on each operating system. I ran it to prove it works, replaced the old binary with the new one, and confirmed the game still launches cleanly on macOS. The two FNA C-level fixes left in the campaign are now unblocked.
FNA fix #3 prep — Metal fp16 sceneTarget bug NO LONGER REPRODUCES on M4 (H1 disproven, FNA3D edit not landed)
I added a one-line switch so I can flip the in-game render into a higher-quality color space and look for an old rendering bug. When I tested it on my current Mac the bug did not happen, even on the exact same rendering library that originally hit it months ago. So I am not changing the rendering library yet, because there is no live bug for the change to fix. The switch stays in case the bug shows up again.
Debug HUD overlay refactored into a lower-right collapsible widget
I moved the live debug stats panel into a small collapsible tab pinned to the lower-right corner. The default view is now uncluttered, just a single tiny toggle button. Click it (or press the tilde key) and the stats grow upward from the corner so they don't fight the gameplay area. Saved screenshots still carry the stats automatically for analysis.
A heavy camera for a heavy ship (decouple position from aim)
the current camera is a pure function of the current frame (it snaps every tick with no memory), so every cue of mass is structurally impossible and a 100m warship reads as a 1m toy. Making the camera a spring the ship's motion drives is the one change that unlocks scale, heft, and power at once.
The Day I Lit the Whole Sky
For weeks my ship sailed through a darkness it carried with it, until one switch finally lit the whole sky and the hull became something worth flying.
Five Days in the Chair: The Bridge Starts to Feel Real
Five nights of work in the captain's chair: the ship learns to wheel in three dimensions, the guns trade a cheat-beam for honest steel, and the cockpit finally looks like an instrument I trust.
Whole-pipeline scaling audit — the per-voxel component-kind spine is dead; standardize on geometric footprints instead
The shipyard is great at adding new looks but was quietly broken at adding new *functions*. The code that's supposed to notice "this ship's guns are shot up, stop firing" never actually runs, because the information about which blocks are guns gets thrown away when a ship loads. The steering jets don't have this problem — they figure out their blocks by location instead. The proposal is to make everything work the way the jets already do, which also makes adding brand-new systems (sensors, shields) cheap and means we never have to rebuild old ships when we add a new kind.
Scaling-audit NOW follow-through — prow dedup, coverage/parity gates, longbow bridge + fleet completeness gate
Added automatic checks that catch a few ways the ship factory could quietly break — a menu option with nothing behind it, two copies of the same list drifting apart, or a saved ship missing a required part. Also gave the longbow a bridge (it didn't have one) and made the fleet health-check run every time, not just when asked.
Weapons Phase 7 — 3D AI spatial tactics (PitchReacquire / PlaneBreak / BowBias) default-disabled in the live sim
New AI behaviors landed — diving above or below the enemy's heavy-gun plane, attacking the stern blind spot, and pointing the bow at the target if the ship has a spinal cannon — but they're all OFF in the normal game so saved fights play identically. You turn each one on with a command-line flag for testing. The behaviors plug into the existing turning controller instead of growing a new one, so future-us has one place to tune steering, not three.
Spatial-combat layer — 3D firing arcs, computed hull-wide coverage, and roll-to-tank fresh-face armor
the fight is mathematically 3D but plays flat, every procedural ship covers every face identically, and a wounded capital ship has no way to turn its scars away — the exact 2D-collapse the research catalogues. The voxel hull makes face-tanking *mechanically real* (damage is location-specific) rather than cosmetic, which is a StarGazer-native differentiator.
Kill the center-to-center laser; replace it with a projectile-based capital-ship arsenal
The laser fails every pillar at once — no WEIGHT (instant, no lead/dodge/telegraph), damage is a shape-blind blob not a SYSTEMIC story, every hotbar slot is the same non-DECISION, and center-to-center fire ignores muzzle geometry so THE SHIP ISN'T THE CHARACTER. It's also the performance villain: the radius-2 cube destroys ~125 voxels and triggers a full-ship topology BFS per damage tick. Projectile travel-time is the single precondition for nearly all the counterplay (leading, dodging, interception, bearing-prediction) that eight research domains — naval doctrine, hard-sci-fi sims, capital RTS/4X, ship-builders, space-sim damage triangles, sci-fi fiction, weapon-variety design theory, voxel-damage mechanics — independently converge on. The energy fantasy survives louder in three earned places (EMP disruptor set-piece, torpedo drive trail, muzzle-charge telegraph): the laser fantasy was never the beam, it was light crossing space and meaning something when it arrives.
3D AI spatial tactics — diving the plane, attacking the stern, and presenting the bow
the broadside/spinal weapon redesign promised a fight where positioning was a real decision — attacker wants bow-on, defender wants side-on, the incompatibility *is* the gameplay. Without these tactics the AI plays both roles flat: a broadside ship has no reason to fear vertical evasion, and a (future) spinal ship would orbit broadside-on like a normal ship and never present its bow. Three behaviors close the gap at the cheapest possible price: each adds one verb the existing controller already had a setpoint for, no new control surface.
A Hundred-Meter Ship, Wheeling In The Dark
It used to fake its turns. Now the ship fires real jets against its own weight, vents cold gas you can read, and you can shoot those jets to pin it.
Remove the visual damage system (Phase 0 of the rebuild)
I stripped out the old visible battle-damage system entirely so I could rebuild it fresh, which for now means ships take hits without yet showing the wounds.
Maneuvering thrusters: full deterministic force/torque rigid-body model
I chose the most believable approach for ship movement: thrusters pushing against a ship's real mass, so the drama of a crippled ship spinning or losing control comes naturally from the physics rather than being faked.
Maneuvering thrusters Phase 1: clean unified thruster record + committed fleet manifest + full re-export
I cleaned up how every ship's jets are described into one tidy, consistent format and wrote down each ship's recipe in one place, so the fleet stops drifting out of sync as the game grows.
Maneuvering thrusters Phase 2: load-time thruster derivation (footprint, jacobian, inertia/COM)
I taught the game to work out each ship's balance point, weight, and where its jets push from the moment it loads, laying the groundwork for the new weighty, physics-driven steering.
Regenerate _test_materials fixture; user-approved voxel-suite baseline bump
I fixed a broken internal test that had been crashing on startup and silently skipped for two updates, so the safety checks that confirm ships behave consistently are running again and all of them pass.
Maneuvering thrusters Phase 3: force/torque integrator, capability gating, AI PD retune
Ships now move by firing real jets that push against their own weight, so when battle damage knocks out part of a ship its handling drifts and degrades on its own instead of following a script.
Maneuvering thrusters Phase 4: thruster VFX fire on command, not on speed
A ship's steering jets now light up the moment they fire, even when it is turning in place or starting from a standstill, so what you see on screen matches what the ship is actually doing.
Thruster plume size by role (not strength) + emissive hot core
The little steering jets were drawing as big as the main engines; now each jet is sized to the thruster it comes from (small for steering, large for the main drive) and glows with a hot bright centre so even the small ones read as real thrusters.
Maneuvering thrusters Phase 5: dramatic plume (glow + vent particles + onset punch + shimmer)
Firing a thruster now glows, vents a puff of gas, and punches bright on a fresh maneuver, so a hard turn or a main-drive burn looks like a ship lighting its engines.
Thruster VFX fixes: roll-plume X-bridge + main drive tracks the throttle setpoint
The steering jets now light on the correct side when you roll, and the main engines glow as bright as the throttle is set, easing off as you ease the throttle down.
Coordinate unification — one right-handed +X-starboard ship frame (root-cause fix for the mirrored-jet bug class)
The ship models were being built mirror-image of the way the physics thought about them, and the code papered over the difference axis-by-axis — getting yaw right but roll wrong, so rolling fired the wrong thrusters. Now the models and the physics agree on left and right, so the steering jets always fire on the side that matches the turn, and that whole family of left/right bugs simply can't happen again.
Full 6-DOF RCS thrusters + completeness gate + A/D-turn rebind
Every ship was missing half its little steering jets — it could slide right but not left, drop but not rise, and couldn't back up. Now each thruster pod has a full set of nozzles facing all six ways, so ships can move and turn freely in every direction, and a new automatic check fails the build if any ship is ever missing a direction again.
Maneuvering feel — flip yaw/strafe input signs + reverse retro plume at full intensity
Turning and strafing left/right were backwards on screen, and the reverse jets were firing so faintly you couldn't see them. Now the left/right keys match the screen and reversing lights the front jets brightly.
Ship-completeness fuzz suite — 100 generated ships vs the minimum-parts contract every run
Instead of checking only the eight ships we keep around, this builds a hundred brand-new random ships every time it runs and makes sure each one actually has everything a warship needs — steering jets that can push it every direction, weapons that are properly mounted, a bridge, and a solid single-piece hull with one core in a sensible spot. It deliberately also builds a couple of broken ships to prove the test can still tell when something's missing.
Strip the visual damage system to rebuild it fresh (Phase 0)
The iterative wound visuals (beveled cut cross-sections, molten rims, layered interior detail) had grown into a complex render path that still wasn't landing the look I wanted, and each tweak fought the existing geometry. It's cheaper to delete it wholesale and design the next system against a pristine codebase than to keep patching. This is Phase 0 — clean ground before the rebuild.
Neutral "NASA/ISS footage" lighting baseline
The player wants a neutral, non-stylized foundation matching real spacecraft footage to build the next visual era on. The old colored 3-point rig + colorful nebula/galaxy vista read as space opera, not NASA footage. A neutral baseline is a stable starting point; stylization can be layered back per-scene later.
Grey procedural asteroid field (clustered belt)
The old field read as colorful random rocks (ice/copper/gold + amber/cyan beacon glows) lit by the pre-neutral colored 3-light rig — out of step with the new NASA/ISS baseline and the player's ask for grey, asteroid-ish rocks that are "far and distributed like asteroid fields, not just random rocks in space."
Maneuvering thrusters: destructible 6-DOF RCS that physically drives turning
I want capital ships to feel like a mass you conduct, where you read an enemy's next move from the puffs blooming along its hull and "shoot its thrusters to pin it" is a real tactic, not a stat tweak.
Tighten 10 skills with mandatory proof artifacts or ask-user fallbacks
I tightened my own development checklists so that every step which used to rest on just eyeballing the result now demands real proof, guarding against bugs slipping through unnoticed.
Split Game1 (1689 LOC god-class) into StarGazerGame partial-class file map
I broke up one enormous tangled chunk of the game's core into clearly named, bite-sized pieces, so it is far easier to find and fix the part that controls any given behavior.
Partial fix to skill-tightening: relax visual-eval verbatim-quote, standardize ask-user wording
I loosened some of my own self-imposed review rules that were demanding busywork for tiny changes, so the checks I keep stay focused on catching real problems instead of producing empty paperwork.
Add verify-fleet one-command end-to-end fleet verification
I built a single command that runs every check on the fleet of ships at once and writes up a clean report, turning what used to be ten minutes of poking around into a quick glance to confirm nothing broke.
Extract StarGazerGame.Scenario partial, single owner for scenario reset cluster
I reorganized the behind-the-scenes wiring that resets a battle scenario into one tidy place, so changing how a fight restarts stays simple and predictable as the game grows.
Phase 2 of 6-DOF refactor, swap ShipControlState to quaternion + ship-local angular velocity (baseline drift [hash] → [hash], benign FP noise)
I rebuilt how a ship's orientation is stored under the hood so it can later turn freely in all directions without the math breaking, and confirmed the change does not alter how anything actually plays.
Phase 3 of 6-DOF refactor — wire PitchAxis + ToggleFlightAssist; direct quaternion integration (determinism baseline unchanged)
Ships can now pitch their nose up and down as a true third turning direction, so you can fly and aim freely in full three dimensions without the controls locking up when looking straight up or down.
On-screen ACES tonemap fixed + enabled by default via fullscreen-triangle + sRGB-decode composite ("cheap path"); full linear-HDR pipeline shelved
I got the cinematic film-style color grading working and turned it on by default after it had quietly been doing nothing, giving the whole game a richer, more filmic look without having to redo every scene's lighting.
Damage shell binds per-primitive PBR materials (one indexed draw run per material)
A damaged ship's surviving hull now keeps its original surface look instead of turning into one flat dull color, so a battered ship still looks like itself where it has not been hit.
Damage rebuild — ship Phase A+B; defer wound-aesthetic phases to interactive/MCP verification
I brought visible battle scars back to ships and added a glowing-breach foundation, then deliberately stopped short of the fancier torn-edge and debris effects because I could not reliably confirm they looked right yet, and I refuse to ship visuals I have not actually seen working.
Re-enable visible battle damage by default
The player asked for capital-ship battle damage back. It was disabled 2026-05-25 only because the damage shell looked muted; now that the shell binds per-primitive PBR materials, a damaged ship's surviving hull matches its pristine self, so re-enabling no longer regresses the showcase.
I Lost A Morning To A See-Through Ship
From the back, my warship was a ghost. Engines hanging in the dark with nothing behind them. Three wrong fixes later, the real culprit was hiding where I never thought to look.
Skills migrated from to; lint script enforces the path
I moved my collection of helper guides into the folder where they get picked up automatically, so they are always available to assist instead of sometimes going unseen.
The Day I Could Finally Whisper To The Living Ship
Tuning the ship used to mean stopping the world, changing one number, and waiting to see it again. Now I reach into the ship while it is still flying, turn the dial, and watch it answer in the same breath.
Diverged-main sync policy: rebase the trivial cases, surface the messy ones
I set rules for safely merging my work when two copies of the project have drifted apart: the obvious cases get reconciled automatically, while the risky tangled ones stop and wait for me, so no work gets destroyed.
Add stargazer-verify-determinism skill +.gitattributes LF-pin for hash-bound fixtures + defer stargazer-schema-contract
I fixed a Windows quirk that was silently corrupting ship data files and added an automatic guard that flags any unintended change to how ships are shaped, before it can sneak into the game.
Ship pipeline phases L→F→G: shipyard cooks voxels, game stops cooking at load
I moved the heavy work of turning a ship's 3D model into its solid blocky form out of game startup and into the build step, so ships load noticeably faster and look the same on every platform.
Ship pipeline Phase I followup: multi-stage shipyard.Dockerfile + digest-pinned cook-base + cross-platform byte-determinism verified
I proved that ships now come out byte-for-byte identical whether they are built on a Mac or on a Windows machine, so every player sees exactly the same ship no matter the computer it was made on.
Close out 3 deferred ship-pipeline items: schema canonical-cook CI gate + oracle threshold calibration +.last-hash Mac bump
I locked down the ship-building pipeline so that any change to how ships are shaped from their models has to be deliberately acknowledged, preventing quiet drift in the final result.
Skill overhaul: fix daily-blog, add data/asset/combat verification skills, add [flag]/[flag], extend determinism gate to physics
I expanded my toolkit of automatic checks to cover the ship numbers, combat, and physics that were previously unguarded, catching the kind of silent breakage that once shipped a glaringly pink ship without anyone noticing.
Unified capital-ship reactor core (Singularity Forge)
The previous quantum_sphere focal was undersized (around 0.6m on a 72m ship), the four-style split meant no ship felt iconic, and the connectivity-slide pass kept burying it inside the hull. The replacement lands at 1.05m on an 18m gunship and 4m on a 72m dreadnought, and the spine yoke gives the shell guaranteed OBB-overlap with the rib frames so connectivity is satisfied without any sliding. The anchor leaves around 78 percent of the surface exposed above the hull silhouette, which supports the "the core is your exposed kill target, defend it" fantasy. The validator passes 8 out of 8 randomized ships at 82 to 100 percent exposure (it was failing-by-burial on most before).
Singularity Forge v2: midline-centred, 20% cap, hex+multi-band
v1 floated above the hull instead of sitting in the gap, had no diameter ceiling (I was seeing 8m orbs on 72m dreadnoughts), and read as a saturated white emissive ball with no surface structure. With v2 I inverted the contrast strategy to bright shell with dark cladding, so the hex pattern and the bands read as silhouette structure at every zoom. I directed a multi-agent parallel review across 30 renders (6 ship families across 5 angles), and it confirmed that v2-iter3 reads as "a contained hex-panelled reactor cell on the centreline" on every family.
I Wanted Every Ship To Share One Heart
Every capital ship now carries the same glowing core at its centerline. One shape to learn, every hull. The day I gave the whole fleet one heart.
Phase 5b kinematic chain: 3-phase render-side aim path
A ship's turrets now physically swivel to track the nearest enemy within their real swing limits, instead of being painted on, so the ship visibly looks alive and aimed in battle.
StarUI Zero-Allocation Responsive UI Framework
I built a custom interface system for the heads-up display that never stops to clean up memory mid-frame, which is what keeps the game running smoothly even on a handheld.
Wound clusterer: O(n²) all-pairs → O(n) cell-indexed BFS
I rewrote how the game groups a cluster of damage into a single wound so it stays fast even when a weapon carves out a large area, keeping the frame rate steady in sustained fights.
DamageVisualHistory skips clean chunks instead of full 21k-voxel walk
When a ship takes a hit, the game now only re-examines the small region that was actually damaged instead of rechecking the whole hull, cutting a big chunk of wasted work during heavy combat.
KinematicAimSystem.BuildDeltaLookup reuses caller-owned Dictionary
I stopped the game from throwing away and rebuilding a chunk of memory for every ship on every frame, which keeps the action smooth even with lots of ships on screen.
Gameplay loop phase 2: 9-slot hotbar UI + scenario keys move to F1/F2/F3
I added a row of nine numbered ability slots along the bottom of the screen, the place where the player's powers will live, and moved the battle-scenario shortcuts up to the function keys to make room.
Enforce voxel core placement zone and exposure constraints
Every ship is now checked to make sure its vulnerable core sits in a sensible spot and stays exposed enough to actually be shot, so the targeting-the-weak-point fight always works as intended.
StarUI Responsive HUD Button Panel and Command Routing
Decoupled, addressable UI trees make every UI feature reachable visually AND programmatically. That meets my tenet that external AI agents can query UI state via JSON dumps and execute path-addressable button triggers (e.g. /hud/buttonpanel/reset-battle), which keeps test automation fast and direct.
Majestic Dawn Logo Color Swap
I wanted a gold background with navy lines and details for a high-contrast, vibrant look.
Update Native Game Icons with Refined Logo
I wanted the refined Majestic Dawn logo in the game shell too. Updating the raw SVG and the compiled binaries together ensures the executable shows the gold-background, navy-lines branding on Windows and macOS windows, the dock, and the file explorer.
Require core visibility and longitudinal zoning on ship hulls
I want every ship to have a core that is visible, accessible, and shootable. Targeting the core is a primary combat mechanic, so if the core can hide buried in the middle of the hull, the whole tactical loop collapses. The three longitudinal zones also help players read silhouettes quickly.
Monorepo: four-stack + standard library, one repo
I'm a solo dev, and polyrepo discipline was costing me time without buying anything. A shared schema/ subdir plus CI cross-validation kills the silent contract drift that motivated the integration plan in the first place.
Two Quiet Calls About Where the Work Lives
I decided the guns point themselves where you can see them, and the menu never begs for more memory mid-fight. Both calls protect one thing: a big ship running on a small machine.
Share interactive combat launch defaults
I tidied up the default fight you drop into so the ships actually square off and trade laser fire, with longer, more visible beam pulses, instead of drifting out of range before anything happens.
Default Program camera to Orbit
Launching the game now drops you straight into an orbiting camera that circles the action, so a normal play session and a captured snapshot start from the same vantage point.
Default Program voxel view to mesh damage
When a ship gets hit, you now actually see the hull tear open by default, and I shrank the size of each hit so battles chip away at a ship instead of blowing huge chunks off too fast.
Keep default render systems enabled
The game now switches on all its stable visual effects (like the glowing energy shields around ships) by default, so a normal launch shows the game at its best unless something is deliberately turned off.
Tune beam damage as direct hits plus splash
I retuned weapon beams so a hit destroys the spot it strikes and only lightly chips the surrounding area, fixing a problem where ships were being blown almost completely apart and vanishing after just a few shots.
Run live apphost as one-shot LaunchAgent
I changed how the game launches in the background during automated testing so it reliably starts once and stays up, instead of either being killed early or stubbornly relaunching itself after I close it.
Keep broadside orbit steering in AiPilotSystem
The logic that makes enemy ships circle and align for broadside attacks now lives squarely with the rest of the combat behavior, keeping their orbiting and aiming consistent and easy to find.
Default voxel debug to translucent overlay
I set the default debugging view to show ship damage as a see-through overlay so the visible hull, the underlying structure, and the width of incoming beams all line up correctly when checking how a battle looks.
Plan damage rendering as derived render meshes
I decided detailed ship damage would be handled purely as a visual layer built on top of the simulation, so the wounds can look rich and cinematic without ever changing what the game considers truly destroyed.
Add retained wound history to damage plan
The damage system now remembers a wound's shape even after the shattered pieces drift away, so a dramatic gash keeps its torn edges, interior decks, smoke, and sparks instead of healing over once the debris is gone.
Build first retained damage renderer slice
I built the first version of the system that renders battle damage as layered wreckage you can see into, while the underlying simulation still treats the ship's structure as the single source of truth for what is actually destroyed.
Aggregate damage wound across chunks, cull interior-poking GLB
Battle wounds now form as one clean carved-open breach instead of a blocky grid of dark squares, and stray bits of the ship can no longer poke through the hole from the inside, giving each wound a deliberately crafted look.
Remove energy shields from the universe
I removed energy shields from the game entirely, because a glowing protective bubble would hide the very battle scars the game is built to show off, so combat reads purely through armor wear and ships physically breaking apart.
Gate full structural wound on cluster size; tiny hits scorch only
Now only real, sizeable hits tear open a ship's hull with a proper jagged cavity, while tiny grazing shots just leave a hot scorch mark, fixing an earlier glitch where small hits sprouted floating black squares instead of believable damage.
Default launch is an AI-vs-AI RTS battle with damage on the selected ship
Launching the game now drops you straight into a six-ship computer-versus-computer fleet brawl seen from a high overhead view, with one ship shown in full battle-damaged detail, so the default experience is a watchable showcase of ships tearing each other apart.
In-game HUD buttons for reset + runtime scenario switching
I added a clickable button panel in the corner of the screen so you can restart a battle, flip through ships and camera angles, switch between fight scenarios, and toggle damage effects on the fly, without having to quit and relaunch the game with different settings.
Voxel state is the truth for visual feedback, not the physics OBB
Set a firm rule that anything a player sees touching a ship (a beam's end, an impact spot) is placed at the true point on the hull, so weapon glows land flush against the ship instead of floating in empty space beside it.
Ship contact normal + point routed through voxel raycast
When two ships collide, the game now figures out the exact spot on the hull where they touched rather than guessing the rough center, so contact effects land where the ships actually meet.
Coalesce shell triangle draws into one per-ship buffer
Rebuilt how a damaged ship's surface is drawn so the whole hull goes to the screen in one efficient pass instead of thousands of tiny ones, restoring a smooth sixty frames per second during fights with several ships on screen.
Defer voxel topology BFS to end-of-batch
Reworked how the game recalculates a ship breaking apart after a hit, doing the heavy check once per volley instead of once per shattered chunk, which keeps the game smooth at sixty frames per second even mid-battle instead of stuttering with each beam strike.
Honor glTF PBR materials on ship draw
Ships now keep the colors, metal sheen, and glowing accents their artist gave them when they appear in the game, so a custom ship looks like itself instead of being repainted a single flat faction color.
Read KHR_materials_emissive_strength from raw GLB JSON chunk
Now reads how strongly a ship's lights and engine glows should shine from the standard place any 3D art tool writes it, so glowing parts keep their intended intensity instead of dimming to a flat default.
Revert emissive strength to material.extras["strength"]
Switched to reading the brightness of a ship's glowing parts (like engine flares) from a simpler, reliably written value, so authored glow intensity comes through correctly with less fragile machinery behind it.
DamageableGlbMeshAsset multi-primitive, retains node identity
The system that builds a damageable ship can now read a ship made of many separate pieces instead of just one, so the detailed new ships hold together and show their full shape rather than appearing as a single stray sliver.
GlbVoxelTriangle carries NodeName
Ships now carry the original name of each part of their body (engine, weapon, and so on) through the building process, so the game can later treat a thruster as a thruster and a gun mount as a gun mount based on what the artist actually labeled it, instead of guessing from shape.
Automated frame sequence capture and GIF compiler pipeline
I added a way to automatically record a smooth run of gameplay and stitch it into a short clip, so highlight reels like explosions and maneuvers can be captured for the dev blog without manual screen recording.
Default launch is single-ship Dreadnought-style + hull binds GLB material
I made the game open straight into a close-up duel between your capital ship and one enemy, and removed a color tint that had been masking each ship's true paint, so ships now show their real materials and tell friend from foe through the interface instead.
ShipPackSidecarReader implements the ninja-blender ship-pack v1.0 contract
The game now reads the new richer ship files and refuses to load any that have been tampered with or half-written, so a corrupted ship is caught immediately rather than glitching later.
Migrate default ship path to
I switched the default ship over to the new, far more detailed version built by my ship-maker tool, while still falling back to the old plain one if the new files are missing.
Start the default run in combat
The current playable slice is about proving voxel and GLB combat, so the first window should show enemy engagement without requiring hidden scenario flags or perfect timing.
Make run launch orbit combat
My "run" loop should land me directly in the playable test surface, not force me to remember hidden flags or press Tab before camera input works.
Show voxel damage through the GLB by default
Voxels are intentionally invisible gameplay truth, but the normal playtest view has to show their effects, otherwise combat looks like lasers hitting an indestructible model.
Treat default run as the showcase
My run loop is the product review surface. Hiding effects behind flags makes features look broken or absent when I (or anyone else) glance at the game.
Make lasers scar before they sever
Capital ship damage should read as progressive hull punishment. When the ship just disappears after a few hits it feels like a render bug, even when the voxel topology is technically obeying core ownership.
Make enemy broadsides orbit the player
Moving the firing origin spreads laser hits across the voxel and GLB damage surface, and it makes the encounter feel like two capital ships maneuvering around each other.
Show voxel truth over the GLB in default combat
To playtest the voxel damage cornerstone I need the authored ship and the underlying damage grid visible together. The oversized lasers were making hits look wider than the damage they were applying.
Replace triangle deletion with authored wound rendering
Capital-ship damage needs to expose structure and battle scars, not look like missing GLB triangles. The full reviewed plan is in SHIP-DAMAGE-RENDERING-PLAN.
Treat breaches as capital-ship interiors
A capital ship breach should read as a huge layered vessel being torn open, not as a GLB shell with missing faces or flat caps.
Use layered wreckage as the damage bar
I want the damage cornerstone to feel like a huge ship being gutted, not like a debug mesh disappearing. The working art bible is DAMAGE-VFX-ART-BIBLE.
Honor glTF PBR materials by mapping onto BasicEffect (v1, no custom shader)
I need external authors (ninja-blender) to author per-part colors, metallic distribution, roughness, and emissive engine glows, and have the in-game ship match the source preview's color identity. The renderer was throwing every material away and re-tinting per faction (cool steel for the player, warm copper for the AI), so two visually-distinct authored ships read the same in-game. The "color identity matches" plus "engines glow" goals only require per-part color, per-part specular character, and per-part emissive, none of which need a custom shader.
Tonemap target: ACES filmic at exposure 1.0
The ninja-blender web preview uses THREE.ACESFilmicToneMapping with exposure 1.0. Matching the tonemap end-to-end means the per-part baseColor and emissive values authored in Blender will read the **same shade** in StarGazer as in the source preview. Without it, a red-orange engine glow can read pink-white because the shoulder curve differs. Tonemap choice has more visible impact on "does this ship look like its preview" than BRDF choice does, so picking the matching one closes the biggest source-of-truth gap.
Tonemap target: AGX (supersedes ACES choice)
AGX preserves bright chromatic edges around stars and thrusters better than ACES, and that matters for a space-combat game where every visible HDR source (engines, beams, suns) sits over a dark background and the tonemap shoulder decides whether they "bloom and bleed" or "clip to a flat hot ring." That was the original analysis in the render architecture entry. The brief deviation toward ACES was driven by ninja-blender's preview using ACES, but matching the planned architecture beats matching one external preview.
v1 IBL stand-in: asymptotic raise-the-blacks emissive lift
Bare PBR through BasicEffect renders the literal product of baseColor * directLighting, and for a baseColor authored to expect environment-map bounce (which is what every modern ship tool does, including ninja-blender's Three studio HDRI), the missing bounce leaves dark hulls reading pure black. My first reaction on dotnet run was "why is the ship so dark?", and the math confirmed it is authored that dark on purpose, expecting IBL to lift it. The (1 - baseColor) * k curve is the "raise the blacks" component of any HDR or tonemap workflow, max lift to surfaces with minimum direct-light response, zero lift to already-bright ones. That matches the qualitative behavior of an IBL irradiance map without requiring the cubemap or the shader pipeline.
Trust contrast: tiny IBL floor + brighter key lights (supersedes the k=0.25 lift)
The k=0.25 lift was the wrong knob. For ninja-blender's baseColor (linear ~0.014), a 0.25 emissive add is roughly a 17x boost, which paints near-grey over near-black and erases the "dark hull" identity. The right principle, per the feedback I got, is "accept that dark materials render dark in shadow, raise the key-light intensity, trust the contrast." With the bright key, lit faces read at 30 to 35 percent sRGB (dark but structured), shadow faces read at around 5 percent (truly dark, matches SceneIR), and metallic spec hot spots punch at around 60 percent because they reflect the bright key and fill, not the dark base.
Configure interactive combat launch defaults and broadside AI behavior
Grouping the combat parameters under a central defaults registry gives me consistent, predictable scenario initialization. The broadside-hold pilot keeps weapon alignment for high-fidelity combat feedback.
Guts And Glow
The first day damage stopped looking like deletion and started looking like a wound. Armor peels, ribs show, and the enemy has learned to circle.
I Decided Damage Should Open The Hull, Not Erase It
When a beam lands on a capital ship, the cheap thing is for the wound to vanish. The right thing is for the ship to come open. Today it came open.
Canonicalize agent skills and split solo-main from worktree-branch commits
I gave my helper assistants one clear home for their instructions and kept my own solo work separate from work running in parallel, so different streams of effort no longer step on each other.
Add world grid and scripted thrust for movement captures
I added a fixed grid in space and a way to drive a ship along a set path automatically, so I can capture the exact same movement shot every time and judge whether motion looks right.
Camera is lightweight render-side state with CLI modes
I kept the camera as a light, easy-to-script viewing tool separate from the simulation, with a default follow mode and exact preset shots, so I can frame screenshots quickly without complicating the game's core or adding heavy machinery.
Orbit camera remains render-side and scriptable
The orbit-around-a-ship inspection view lives purely on the viewing side, steered by keyboard or gamepad and repeatable from exact angles, so studying a ship never disturbs the actual simulation.
Camera default far clip keeps 10x space headroom
I pushed the camera's view distance ten times farther by default so it won't clip away ships and scenery while I orbit around to inspect them, giving the wide open feel that space scenes need.
Engine systems use findable ownership boundaries
I broke the game's inner workings into clearly named pieces by job, so it's easy to find and grow the camera, controls, visuals, or flight without behavior leaking messily across everything.
Ship visual forward is world +Z
Until ships could rotate, I locked in which way counts as forward and right for the default ship so the movement keys actually push it the way it looks like it should go, fixing controls that had felt backward.
Ship motion starts as assisted Newtonian velocity
Ships drift with real space-like momentum: thrust builds up speed, there's a top speed, they coast freely when you let off, and a brake assist helps you stop, giving flight weight without going full orbital-physics.
Make thrust follow ship yaw
Thrust now pushes in whatever direction the ship's nose is pointing, so its momentum follows where the bow faces instead of always shoving in a fixed world direction.
Keep vertical thrust on Shift
I set the controls so holding Shift thrusts the ship upward and Space acts as a brake, which feels more natural since Space reads like a deliberate stop and Shift is easy to hold alongside the movement keys.
Add target dummy instrumentation before weapons
Before adding real weapons I gave ships a practice target plus on-screen guide lines showing heading, speed, distance, and direction to the mark, so I could fine-tune how flying and lining up a shot feels.
Kill stale game instances before launching
I made it a rule to always shut down any leftover copies of the game before starting a fresh one, so stray hidden windows can't pile up and muddy my testing.
Roll joins ship-local orientation
Ships can now roll, banking around the line their nose points down, and that roll actually affects how they thrust and fight rather than just tilting the picture.
Ship physics has a named sim system
I gathered everything about how a ship moves, turns, and slows into one clear home, so tuning the feel of flight is a single obvious place to work instead of scattered through the whole simulation.
Roll basis matches rendered ship roll
When a ship rolls, the invisible guides I use for its weapons and steering now tilt the same way the ship visibly does, so what I see and what the game thinks are happening finally agree.
Coordinate conventions get a project skill
I set a standing rule that any work touching how ships are aimed, turned, positioned, or how the camera sees them has to first sort out which way is up, so the game's directions stop drifting into a tangle of opposite-facing fixes.
Keep AGENTS as the instruction source
I settled on a single master instruction file for the project, with everything else just pointing back to it, so the guidance my various helpers follow never drifts out of sync.
Plan BEPU-backed body physics
I wrote down the plan for handling large numbers of colliding space objects with a real physics engine, kept walled off behind my own code so the game stays organized and runs well everywhere.
Extend physics plan for modules and constraints
I expanded the physics plan to treat solid ship bodies, breakable modules, and hinged connections as distinct problems, each with its own performance targets, so capital ships can lose pieces and link up without hurting performance across computers and consoles.
Headless sim scenarios start physics migration
I recorded how ships currently fly (thrust, turning, rolling, braking, and firing) as fast windowless test runs, so the big physics rework can be checked against them and never quietly change how a ship feels to pilot.
Benchmark body iteration before BEPU
I added a quick stress test that runs a crowd of moving objects with repeatable results and timing, giving me a cheap baseline to compare against before the bigger physics overhaul lands.
Ship pose snapshots become the read model
I had the simulation start broadcasting each ship's position and orientation in a single shared form, so the parts of the game that draw and inspect ships can move onto the new physics one at a time instead of all at once.
Validate physics assets before runtime bodies
I made every ship's physical properties (its shape, weight, and how it reacts to forces) start life as checked, readable data, so problems show up as clear differences before they ever reach the live game.
Keep BEPU behind StarGazer physics handles
I tucked the new physics engine behind a clean wall of my own so the rest of the game never talks to it directly, keeping the borrowed engine swappable and the game's code tidy.
Start collision slice headless
I built the first slice of collision handling as a windowless test that proves objects spawn, get scanned for hits, and report events in a reliable order before any of it is shown on screen.
Render physics debug from collision slice data
I made the on-screen physics debugging view draw straight from the same verified data the underlying simulation uses, so what I see while debugging is the real state and not a separate guess.
Prove compound detach before articulated joints
I proved that big ships can break apart cleanly, with detached pieces carrying their momentum away, before wiring up the more delicate physics of hinged and jointed parts.
Set first physics performance gates
I set concrete speed targets the physics has to hit, including a profile for the lower-powered handheld console, so performance is measured against real limits as the simulation grows more complex.
Harden physics runtime API
I gave the physics layer a proper toolkit for spawning, destroying, and tracking objects safely, so the game can handle many different kinds of moving things instead of a handful of one-off test pieces.
Add a BEPU runtime benchmark gate
I built a tool that measures how fast the game's collision and motion math runs on its own, so I can see exactly where the time goes before adding heavier physics.
Support static physics bodies behind BodyRef
I taught the physics engine to handle immovable things like stations, beacons, and obstacles through the same simple interface it uses for ships, so non-moving objects don't need their own separate plumbing.
Name physics runtime velocity units
I renamed the speed values in the physics engine to clearly mark which ones are measured per second versus the older per-frame ones, so the two timekeeping styles that coexist during this transition can't get confused.
Keep BEPU shape ownership inside PhysicsWorld
I made the physics engine quietly clean up after every object it creates and destroys as ships come and go, so spawning and removing things doesn't slowly leak clutter behind the scenes.
Serialize dotnet commands per worktree
I made it a rule never to build or run two copies of the game at once from the same folder, because doing so causes false errors from the two builds stepping on each other's files.
Route runtime queries through collision channels
I made the game decide what can collide with what using the same rulebook the ships themselves are built with, so hits and near-misses behave consistently everywhere instead of each feature inventing its own rules.
Make runtime query hits self-describing
I made every detected hit carry its own details, like what it struck and how it should react, so the game can resolve a collision instantly without having to go look the answer up afterward.
Make playable physics consume PhysicsWorld
I moved the real game (your ship, the target, and weapon fire) onto the proper physics engine instead of leaving it confined to behind-the-scenes test runs, so everything you see and shoot now obeys the same real physical rules.
Wake controlled physics bodies on motion
I fixed a bug where a ship left sitting at the start would refuse to move forward (the engine had quietly put it to sleep), so a ship always responds the instant you give it a push.
Separate chase and orbit camera ownership
I gave the default camera its own follow-behind mode anchored to the ship and clearly separated it from the orbit and fixed views, so a ship sliding sideways now actually looks like it is moving instead of just spinning.
Harden live physics review gaps
I tightened up how the physics engine tracks which objects are touching and rejects bad data, so as the fleet grows it stays fast and never gets fed nonsense numbers that would corrupt the simulation.
Use raw runtime icon assets
I set up the game's window icon so the program automatically finds and shows it on Windows and Mac without extra fuss.
Deterministic AI pilot emits movement intent only
I taught the computer-controlled ships to simply decide where they want to go (like wandering or charging) and let the shared movement system carry that out, so their behavior replays identically every time and they stay unarmed for now.
Promote ships into a dense control store
I gathered every ship, yours and the computer's, into one shared registry that feeds them through a single steering pathway, so growing from one ship to a whole fleet stays organized and the ships still bump and collide believably.
Add real-ship scale and determinism gates
I built a way to run whole fleets of ships through the game's movement and combat logic without any visuals, so I can prove the ships behave the same way every time and measure how they hold up at scale before trusting it.
Measure live frame metrics in the render HUD
I added a live readout of how smoothly the game is drawing, so I can spot stutters in real time while flying around as I push the number of ships and the intensity of combat higher.
Draw selected ship vectors from sim snapshots
I made the on-screen debug arrows for a selected ship (which way it faces, where it's heading, where its computer pilot is aiming) come straight from the same source the actual gameplay uses, so what I see while debugging matches what the ship truly does.
Split ship scale profiles and benchmark phases
I added different ways to lay out test fleets, from ships spread thinly across space to crowds deliberately packed together to collide, so I can tell exactly which part of the game is slow when the action gets heavy.
Plan voxel ships as deterministic state over coarse physics bodies
I decided each destructible ship would be a single solid body for movement with a detailed damage map laid over it, rather than thousands of separate physics objects, so battles can scale to enormous fleets without grinding to a halt.
Harden voxel plan around chunked and pooled performance paths
I rewrote the destructible-ship plan to demand the fast approach from day one, avoiding shortcuts that would look fine on a single ship but crawl once hundreds or thousands fill the screen at once.
Define voxel construction, destruction, debris, and performance test gates
I wrote out a full test plan for destructible ships, listing every sneaky way the system could break (a severed chunk still acting alive, ships splitting wrong) so those flaws get caught automatically instead of slipping past a screenshot.
Add synthetic voxel validation, split scenarios, and benchmark gates
I delivered the first working slice of destructible ships: test shapes that break apart correctly, pieces that drift off as wreckage when severed, and speed tests to make sure all of it stays fast.
Add CPU GLB voxel cook slice
I got the game to take a real 3D spaceship and slice it into its damage blocks for the first time, turning a detailed ship into roughly twelve hundred destructible cells, proving the pipeline works on an actual model and not just made-up test shapes.
Add aggregate voxel test suite gate
I built one single command that runs the whole gauntlet of ship-damage tests at once, from ships breaking into floating pieces to a real spaceship being chopped into its damage blocks, so I can catch broken battle behavior before it ever reaches you.
Record core-death hull as voxel debris
When a ship's core is destroyed, all of its remaining intact pieces instantly become drifting wreckage in one clean stroke, so a dead ship can no longer keep fighting or be targeted as if alive.
Hash voxel suite results by stable evidence
I changed how the game double-checks that battles play out identically every time, basing that check on what actually happened (which parts lived or died) rather than on stopwatch timings that naturally wobble run to run.
Harden voxel headless gates before runtime integration
I tightened the automatic safety checks around how ships are carved into their tiny damage blocks, so the system refuses to choke or quietly lie about being reliable when ships get very large or very numerous.
Attach voxel state to runtime ships
Every ship, whether you or a computer opponent flies it, now carries a living record of damage to each part of its body, hit and torn apart in a strict, repeatable order, so a wreck always falls apart the same way.
Add selected-ship voxel debug overlay
I added a way to peek under a chosen ship's skin during play, showing its damage in little building-block chunks and counting how many are still alive, dead, or knocked loose, so I can prove the damage is real before building bigger battle features on it.
Plan FNA-native HDR forward rendering pipeline
I laid out the full plan for a modern, cinematic look for the game: rich lighting that holds bright and dark detail at once, soft glows around hot light, crisp edges, film-grade color, and realistic shadows, all tuned to run smoothly even on a handheld.
Fold Git LFS upload into the committed pre-push hook
I fixed how my project uploads its large screenshot files so that pushing my work no longer leaves the heavy images stranded on my machine, which had been causing fresh copies of the project to fail to download.
Render voxel debug cells at cooked GLB density
The debug view that shows a ship's building-block structure now displays it at the true, fine density the ship was built with, so when I inspect it the framework looks as detailed as it really is instead of a coarse stand-in.
Route beam hits through ship-local voxel DDA
Weapon beams now do their damage by tracing the actual shot through a ship's blocks and striking the first solid one it reaches, so hits land where the beam really goes instead of from hand-picked spots, all kept fast and exact.
Prove sparse voxel DDA crosses empty cells without allocation
I proved that a beam can travel through long stretches of empty space inside a ship's frame and find the first solid block to hit without ever bogging the game down, which matters because capital ships are mostly hollow and beams cross a lot of nothing.
Add aggregate voxel state slots with promotion on demand
Far-off ships can now sit as lightweight summaries that cost almost nothing, and a ship only blossoms into full block-by-block detail the moment it actually takes damage, so the game can hold hundreds or thousands of ships at once while nearby combat still looks fully detailed.
Add detailed voxel state scale ladder
I added a test that builds 1, then 10, then 100 ships all tracked in full block-by-block detail and damages each once, confirming every one registers its hit cleanly before I push battles to heavier fire.
Report detailed voxel caps in sim scenarios
Test runs now print exactly how many ships are being tracked in full detail versus kept as cheap summaries, and you can cap that number, giving a clear honest readout that the fleet's detail-saving system is really working in the live game.
Apply voxel damage by sorted command runs
I rewrote how a wave of incoming hits is processed so the game handles them in tidy groups by which ship was struck, letting a thousand-ship battle's damage scale with the number of volleys rather than ballooning out of control.
Resolve same-tick voxel detaches inside command runs
When a chunk of a ship breaks off during a single burst of hits, later hits in that same instant correctly pass through the now-floating debris instead of pretending it is still part of the living ship.
Report real voxel topology and LOD benchmark metrics
I taught the performance test to report honest, real numbers about how ship hulls are broken into pieces and how much work each tick does, so a slowdown at large fleet scale can't hide behind tidy fake totals.
Guard aggregate voxel ships against invalid promotion
I made sure that a shot which misses or doesn't really count against a distant ship no longer accidentally jolts that ship into expensive full-detail tracking, which is what keeps huge fleets affordable to simulate.
Read aggregate voxel core ids without promotion
When something just needs to peek at which block sits at a distant ship's core, the game can now glance at it cheaply instead of waking the whole ship into full detail, so far-off ships only get spun up when damage actually lands on them.
Test killed voxel ships through runtime control systems
I added tests that fly destroyed ships through the game's real steering and computer-pilot logic to confirm a ship with its heart blown out goes truly dead and stops trying to move, instead of only checking that on stand-in stand-alone wrecks.
Extract render pipeline scaffold from Game1.Draw
I reorganized the behind-the-scenes drawing code into one tidy pipeline, clearing the way for the richer lighting and visual polish I plan to layer on next.
Mark detached voxel debris without drawing dead hull
When a chunk of a ship breaks off, the lost piece vanishes from the hull and gets its own marker showing exactly where it tore away, so a ship splitting apart is easy to follow.
Use apphost launcher for live game runs
I changed how the game gets launched so the running game stays alive on its own and does not get killed when I close my work session, making testing far more reliable.
Add live voxel damage demo
I built a small live demo that plays out damage over time, breaking a structure apart piece by piece, so I can actually watch how destruction unfolds rather than just inspecting frozen snapshots.
Render voxel debug cells as filled blocks
I switched the damage view from thin wireframe outlines to solid filled blocks, so torn hull, dead sections, and floating debris all read clearly instead of looking like a see-through cage.
Cache voxel debug rendering by dirty chunks
I made the game redraw only the parts of a ship that just took damage rather than rebuilding the whole hull every frame, keeping things fast even as the cornerstone damage system runs.
Drive GLB mesh damage from voxel state
Damage now eats away the ship's actual sculpted surface where it was hit, so a wounded ship keeps its real shape and loses recognizable chunks of hull instead of turning into crude blocks.
Add programmatic GLB breach demo
I added a quick way to drop straight into a scene showing a fresh breach blown into the top of a ship's hull, making it easy to look at battle damage on demand.
Share GLB breach damage patterns with tests
I set up an automatic check that confirms a blast through a ship's hull always carves a proper hole without instantly killing the ship, so the damage stays believable as I tune how it looks.
Route ship lasers through voxel damage
Ship laser fire is now wired straight into real hull damage: a beam that lands burns away part of the enemy and drains its health, so what you see hitting the ship is what actually hurts it.
First weapon is a broadside beam gate
Capital ships should reward bearing and positioning before twitch aim. The beam gives me immediate feedback while the weapon art and damage rules are still fluid.
Make prototype thrust visibly readable
The physics-backed ship was technically moving, but the motion was too subtle against the follow camera and the large grid for me to trust the controls during live playtesting.
Default flight view is ship-local chase
Translational motion needs to stay readable during live playtesting. A visual-center follow camera can hide movement on a capital ship because rotation changes the camera's target.
First AI gameplay slice is no-combat flight
I want to prove ownership, control, collision, camera framing, and the debug surfaces before I layer fighting, targeting, damage, or fleet behaviors on top.
Compact runtime HUD around performance first
The previous debug readout exposed useful values but behaved like an unstructured dump. I need performance visible while playtesting at scale, and I want the rest scannable without covering the playfield.
Ship selection is keyboard and CLI addressable
Fleet-scale debugging needs a stable way to inspect one ship at a time without mouse-only picking. Keeping chase player-owned preserves the flying camera while orbit becomes the inspection camera.
Capital ships become core-rooted damageable voxel structures
Damageable capital ships are a cornerstone fantasy for me. Positioning and weapon impacts should matter spatially, not just subtract from a single health bar. A core-rooted graph gives readable rules, supports future "real ship systems", and keeps disconnected wreckage behavior deterministic for the first slice.
Detached voxel islands become debris, not ship
Capital-ship damage needs to feel physical without letting severed pieces keep acting like the player ship. This gives the sim a crisp ownership boundary for future salvage, collision debris, visual wreckage, and system detachment.
Core death sheds remaining hull ownership
Core death is the same ownership boundary as bridge severing. Once the root is gone, no surviving hull piece should keep behaving like the ship.
Adopt cinematic space-opera aesthetic
The "modern beautiful space game" target needs a single aesthetic compass so I stop relitigating per-effect technique choices. Cinematic space-opera fits capital-ship combat's slow tactical pacing, gives every system biome a strong identity, and survives the FNA SM3 rendering ceiling without compute-required modern looks.
Tune flight around capital-ship commitment
Capital ships should feel massive because repositioning is a decision with momentum, not because the top speed is tiny.
Put primary turning on A/D
For capital-ship handling, left and right on the home cluster should command heading commitment first. Strafe is secondary maneuvering thrust, it deserves the secondary keys.
Use voxels as invisible damage truth
Capital ships need authored silhouettes and readable art direction. Voxels give me spatial damage and scaling, but showing raw blocks as the main ship would undercut the fantasy.
Make lasers the first live voxel combat proof
It proves the cornerstone loop in actual play (weapons, ship ownership, voxel damage, life, debris, GLB mesh removal) without waiting for turrets, reactors, armor types, or full combat AI.
The Ship Coasts Now
I gave the ship drift, broadside arcs, and a quiet foundation strong enough to hold a debris field. Today it stopped being a toy.
Three Calls I Made About How The Ship Should Feel
Does the ship dart or does it drift? I want it to drift. Three decisions in a row, all serving that one feeling.
Vendor FNA instead of MonoGame NuGet
I copied the game's core engine directly into the project so I fully own it and can change it freely whenever the game needs it, rather than depending on an outside package.
Target.NET 8
I built the game on the current long-term-supported version of its programming platform, which runs natively across Windows and Mac (including Apple's own chips).
SDL3, not SDL2, as the FNA platform layer
I built the game on the modern version of its underlying platform layer, which brings better controller and high-resolution display support that matters for gamepad play and Mac.
Native libs laid out as runtimes/<rid>/native/
I organized the game's platform-specific support pieces into the standard layout so the correct ones get bundled automatically for Windows or Mac when I build for each.
Use SharpGLTF.Core via NuGet for GLB loading
I adopted a well-maintained, widely trusted tool for reading the 3D ship files the game uses, so loading ship models is reliable and I am not maintaining that plumbing myself.
Main-only git workflow with auto commit + push
Working alone, I save and back up my progress automatically at every finished step, which keeps the game always in a working state and gives me easy points to roll back to.
Adopt DOC/ decision-log discipline
I started keeping a running journal of every meaningful design and technical choice and the reasoning behind it, so when I return to the game after a break I can remember why things are the way they are.
Defer text rendering library choice; "Hello World" via window title only
For the very first milestone I just put the greeting in the window's title bar and held off on picking a text system until I actually knew what the game's on-screen writing would need.
Adopt FontStashSharp.PlatformAgnostic + custom FNA renderer for text
I chose a text-drawing approach that lets me load and swap fonts at any time without a rebuild, so on-screen writing renders cleanly and stays easy to restyle later.
In-process screenshot via RenderTarget2D + --screenshot CLI flag
I built the game so it can take its own screenshots from any moment with a single command, giving me a consistent way to capture how things look across every computer without any outside tools.
First ship renders: GLB loader extended for normals + BasicEffect render path
I got the first real ship model showing on screen with simple built-in lighting and an automatic camera that frames any ship, so the game finally renders a lit, three-dimensional vessel instead of just placeholder text.
Cull clockwise, not counter-clockwise, for glTF + FNA right-handed projection
I corrected which side of each surface the game treats as facing outward, so ships now show their proper outer hull instead of looking turned inside-out with their interior walls exposed.
Roguelike structure (procedural runs, not scripted campaign)
It fits my solo indie scope: replay value scales with procedural systems while content authoring stays manageable, and the roguelike loop fits "one more run" sessions, which is how I actually play games while traveling.
3D space combat centered on capital ships
This has been the game concept since I started. Capital ships afford strategic-feel combat (positioning, broadside arcs, subsystem targeting) over twitch reflexes, which aligns with the roguelike "tactical decision" loop more than with a flight-sim arcade loop.
GLB as the ship model format
It's a modern open format, widely supported in DCC tools (Blender, etc.). It avoids the dead XNA-era.fbx to.xnb Content Pipeline. And runtime loading lets me do data-driven ship variants without a rebuild.
Target PC + Mac desktop
Mac coverage lets me keep working on a Mac during travel, and the FNA plus SDL3 stack covers both desktop targets cleanly (better controller and HiDPI support along the way).
Programmatic control of every game state is a core tenet
Four compounding reasons. AI-driven verification needs programmatic state access for automated screenshots and scenario runs. My dev velocity collapses if reproducing a bug takes 90 seconds of menu-clicking instead of a --scenario flag. The same affordances let players write mods, replay, and speedrun tools later. And forcing programmatic reach makes the sim explicitly expose its state transitions (easier to test, more predictable). Retrofitting onto a finished UI is a multi-week refactor, menu state machines, animation skippers, save and load headless paths all have to be threaded through every screen. Designing it in from feature one is essentially free.
Determinism in the simulation layer is a core tenet
Replay unlocks bug-repro-by-file (a player sends a 200-byte replay, I reproduce locally), automated scenario regression (replay then diff every Nth frame), AI-agent verification loops, and modding and speedrun infrastructure, and all of those compound forever on top of a deterministic sim. The retrofit cost is brutal (every system touching randomness, time, or IO would have to be audited and rewritten), so adopting the discipline now while the sim code is empty is essentially free. The cost gap between "do this from day 1" and "add this in year 2" is multiple orders of magnitude.
Parallelizable by design, multi-agent, multi-instance from day 1
I want multiple Claude Code agents running in parallel (for example, one in worktree A and another in worktree B with screenshot diffs comparing them). That only works if the codebase has no hidden contention surface: no shared file someone forgot about, no global cache that gets corrupted, no log file two agents fight over. Building this in from day 1 costs me nothing. Bolting it on after the first global-state bug is brutal, I'd find them one race at a time over months.
Asset pipeline: raw files at runtime, no packing until shipped game needs it
My projected asset footprint is modest: a small fleet of ship GLBs, modest textures, conventional SFX and music, low hundreds of MB at ship. At that size class, the iteration-speed benefits of raw files (no build latency, trivial future hot-reload, every agent can write any asset in any worktree without tooling, dev environment matches ship) outweigh the distribution-size and cold-start benefits of packing. Stating "no packing" as a principle now prevents drift into "just add a small manifest" creep that compounds into a pipeline rewrite a year in.
Determinism tenet refinements after expert review
I had my determinism specialist reviewer pass on the original 7 rules (2026-05-21), and they named these as the 30 percent the original list missed, the parts that actually break in shipped lockstep games. It's cheap to add them to the tenet text now while the sim code is still empty.
Run shape: short FTL-style runs, hard perma-death, procedural fleets + sectors, no meta-progression
Short runs plus hard perma-death gives me the "one more run" loop that fits travel-on-Mac sessions, matches my solo-dev scope (no meta-DB to maintain), and lets each run carry real stakes. Procedural-fleet-on-a-fixed-roster keeps the content authoring tractable.
First Transmissions: One Ship, One Window, Day One
All I wanted on the first day was a window, a ship, a grid for scale, and a camera that follows. Four small proofs that the dream is real.
Day One: I Decided To Owe Nobody
Two calls I made before any of the game existed. One about the machine that runs the ship. One about the words on the screen. Both about owing nobody.