Introduction

Chat codegen can spit a cube. Astra is being used to ship journeys.

On September 4, 2026, OpenAI’s Thomas Ricouard published Building games with Astra — a developer diary for Void Explorer, a browser space game built in Codex: fly between stars, punch into atmosphere, land on coastlines, walk the surface, take off again. The universe isn’t a backdrop. It’s 2,048 star systems and more than 10,000 procedurally generated planets, including Earth-scale worlds you can actually approach.

This is the follow-up every pipeline lead needed after the Playbot grey-box demos: not “AI edited a scene,” but “AI helped carry a continuous scale problem from concept art to playtests.”

Start With the Experience, Not the Stack

Ricouard’s opening brief was brutal and correct:

Everything visible should be reachable. Keep distances real. Make travel work through scale and speed. Fly from space into atmosphere and down to ground. Earth-sized planets need procedural terrain and a chunked renderer.

That constraint list forces architecture. A star can’t be a painted billboard. A planet can’t hard-cut into a separate level. Pulse travel and hyperdrive become gameplay lies that keep real distances practical.

Art direction came before most of the systems work. Image generation set the palette — then corrections (“too realistic,” then “too simplistic,” then neon contrast and high-speed dust). Once the look locked, those frames became references for orbital flight, atmospheric entry, and landing. That’s how you keep an agent from optimizing for “compiles” instead of “feels like deep space.”

Pro Tip

Write the player verb list first. If Astra (or any agent) can’t fail your experience brief, it will invent a stack that looks clever and plays empty. Reachable stars, continuous descent, and land-walk-takeoff are acceptance tests — treat them that way.

Let the Model Propose Architecture — Then Give It Eyes

With constraints set, Astra proposed the stack: TypeScript + Vite, Three.js for meshes, materials, lighting, and procedural geometry. The first playable renderer used WebGL2; later the sim stayed put while the renderer moved to Three.js’s WebGPU path with node materials and TSL for atmosphere, water, and lighting.

Terrain generation runs in Web Workers. Vitest covers repeatable generation and coordinate contracts. Playwright drives the browser. The important move for game AI workflows: expose a debug surface the agent can call.

Void Explorer ships window.__VOID_EXPLORER__ so tests can read approach targets, flight mode, terrain readiness, camera, draw calls, triangles, queued terrain jobs, and buffered data. Named scenes — orbit, pulse travel, atmospheric descent, coastal landing — let Astra restart mid-journey instead of flying the whole universe every bug.

Agent-ready game harness checklist1. Experience brief with fail conditions (reachable, continuous, landable)2. Concept references for look targets3. Named replay scenes for hard transitions4. JS inspect API: state + perf counters5. Browser tests that play journeys, not only screenshots6. Human owns feel; agent owns investigate → patch → remeasure

That’s the real product lesson. If your AI can’t press Play, capture state, and re-run a landing, you’re still doing prompt theater.

Continuous Descent Is the Boss Fight

Void Explorer’s hard problem is continuous scale: light-years to footsteps without losing precision or popping the planet away.

Physical addresses use large integer cells plus local offsets. Before draw, subtract the observer so the camera stays near the origin. Stars, planets, and moons evaluate at the same simulation time. A parked ship stays glued to a rotating world.

LODs do the rest. Distant planets are cheap faceted proxies. Closer in, six cube faces project onto a sphere and refine as a quadtree. Near ground, local patches thicken geometry around ship and player. Coarse and fine meshes sample the same elevation function — continents, ridges, craters, biomes — so the silhouette doesn’t reinvent itself every LOD swap.

Handoffs matter as much as generation. The distant globe stays until all six coarse faces are ready. A tile stays until all four children are ready. Complementary masks assign pixels during transition so the planet doesn’t go transparent mid-approach. Atmosphere and clouds bridge orbit to landscape. Landing is stricter still: visible ground, collision, and liquid hazards for a contact patch must become ready together. Walking uses Rapier in a small local physics world.

The honest limit: heightfields. Great for continents. No caves, overhangs, or diggable tunnels yet. Ship that constraint in the design doc so players don’t expect Minecraft under every mountain.

Measure the Work Behind a Slow Frame

When descent looked wrong and felt slow, Ricouard asked Astra to inspect both. Playwright collected frame intervals alongside Three.js counters. Controlled comparisons caught real wins: screen-size LOD budgets (7,040 proxy triangles vs 51,200 in one test), indexed meshes cutting transferred buffers (~35 MB → ~15 MB at the same triangle count), and terrain selector thrash dropping discarded jobs from thousands to a handful in a fixed-latency simulation.

Human input stayed qualitative: “planet disappears,” “colors jump,” “this feels heavy.” Astra traced code, scripted repeatable terrain tests, implemented, and remeasured. That’s the division of labor that scales — not “generate the whole game in one prompt.”

Side experiments prove the pattern travels: Sunwake (procedural ocean + authored Blender boat sharing one wave model for look and buoyancy) and Hollowflux (2D action RPG with water sim tied to combat). Same thesis: procedural environment, authored hero asset, shared simulation.

Conclusion

Void Explorer is the Astra game story that matters for working developers: experience-first briefs, agent-inspectable harnesses, continuous LOD descent, and measured terrain pipelines — then deploy with Sites and hand someone a browser link.

Play the demos. Steal the harness. Write verbs before frameworks. Keep humans on feel and agents on the investigate-patch-remeasure loop.

That’s how generative game tooling stops being a trailer and starts being a shippable universe.

—Titus