Thomas Ricouard — Astra builds a Blender-to-UE5 walkable house end-to-end via Python 3D-as-code

TL;DR

Thomas Ricouard (@Dimillian) posts a walkthrough demo pegged to OpenAI’s GPT-6 Astra launch (Sep 3, 2026): from a natural-language prompt for “a modern minimalistic house surrounded by calm and trees,” Astra iteratively designed a floorplan, authored the 3D scene by driving Blender headlessly via CLI + Python, rendered Cycles 4K stills at golden hour, wrote its own export pipeline into Unreal Engine 5, iterated on lighting/props for a “lived-in” second pass, and delivered a standalone 60 FPS walkable UE5 app plus storyboards. Ricouard’s characterization: “Apart from the first few prompts, Astra did everything” — plan, scene assembly, lighting, camera angles, renders, UE5 packaging. The thread is one of the more concrete public data points for what a frontier model looks like when it’s given long-horizon tool access to a full DCC/game-engine stack, and it lands squarely on the “generate-the-program-not-the-pixels” side of the visual-generation debate the wiki has been tracking.

Key claims

Astra designs the 3D scene by generating Blender Python and driving Blender headlessly via CLI rather than emitting pixels or a mesh directly — the pattern the tweet describes as “what Astra likes to do is use the Blender headless/CLI and write the 3D models in Python” [Post 2/thread].
The workflow is end-to-end long-horizon: Astra produces the floorplan → V1 scene in Blender → Cycles 4K “golden hour” renders → writes its own Blender-to-UE5 export pipeline → launches UE5 multiple times to test fidelity → delivers a standalone walkable app, then does a second pass adding props and improving lighting (“the coffee machine is even working now”) [Posts 2–6/thread].
Ricouard’s summary framing: “Apart from the first few prompts, Astra did everything” — plan, lighting/skybox, camera framing, video capture, and storyboard generation are all attributed to the model rather than the human [Post 7/thread].
Output artifacts include a 60 FPS UE5 standalone the author walks around on their own machine, plus Blender vs UE5 comparison storyboards used to check fidelity across the render passes [Posts 5–6/thread].

Method

Tweet thread; no paper, no code, no benchmark. The evidence is a series of demo videos and stills: (i) a plan sketch, (ii) a Blender timelapse of Astra assembling the scene via headless Python, (iii) four Cycles 4K stills with golden-hour lighting, (iv) four UE5 stills after Astra wrote its own export pipeline, (v) a first-person walkthrough capture of the UE5 build at 60 FPS, (vi) a second-pass “lived-in” build, and (vii) storyboards comparing Blender vs UE5 renders. Astra is OpenAI’s GPT-6 model, launched the same day as this thread; the thread is a “launch blog post” companion piece by an early tester. There is no controlled comparison against other agents (Claude Code, Cursor Composer, Codex, etc.) and no reported token/time/cost budget.

Results

Qualitative only. The concrete outputs: one floorplan, one Blender scene (iterated to V2), 8 Cycles 4K stills across two passes, one standalone UE5 walkable app running at “60 FPS in real time” on the author’s machine, and one storyboard set. No numbers for iteration count, tool-call depth, wall-clock, or failure/recovery statistics.

Why it’s interesting

This is a concrete, in-the-wild instantiation of exactly the “generate the source program, not the pixels” thesis that 3D as code and The Next Frontier of Visual AI Is Code both argue for: the model doesn’t produce a mesh or a rendered image, it writes Blender Python (a scene-graph program), lets Blender render, then writes a second program to export the same source of truth into Unreal. Astra also literalizes the “3D test-time loop only converges if the agent has the right tools” prediction in the a16z piece — Blender headless + Cycles + UE5 launch/test become the feedback environment, and the second pass (“more lived-in, adjust lighting”) is exactly the Code → Render → Inspect → Revise loop that essay describes. Read alongside The flavor of the bitter lesson for computer vision‘s Bitter-Lesson counterpoint, this demo is evidence that at the current capability frontier, code-as-scene-representation is the pragmatic winner even if the long-run outcome is still contested. Note the caveats: Ricouard is a launch-day tester and the thread is closer to marketing than an evaluation, there’s no comparison against Claude Code or Cursor Composer driving the same Blender stack, and none of the harder questions (physical correctness, articulation, editability of the emitted Python) are addressed by the demo. The wiki has no prior page for Astra / GPT-6; this is the first pointer.