Kiln: Text-to-3D That Writes Code, Looks at Its Own Renders, and Fixes Its Mistakes
I’ve been on a run of posts about decision models — small models that make bounded, checkable choices instead of free-generating. Kiln applies the exact same instinct to a totally different problem: AI-generated 3D models. And it’s the first approach to text-to-3D that actually looks production-sane to me.
The core idea: 3D as code, with a feedback loop
Almost every text-to-3D tool works like this: prompt in → mesh out → cross your fingers. The result usually has ugly topology, non-manifold geometry, or scale problems that need a human to clean up in Blender before it’s usable. One shot, no review.
Kiln flips it. The model doesn’t guess a shape — it writes a JavaScript program that constructs the geometry using Kiln’s geometry and material helpers. Then:
- Kiln runs the program and produces the 3D asset.
- Kiln renders views of it and runs structural checks.
- The agent looks at its own renders, sees what’s wrong, and revises the code.
- Repeat until it’s right → export a game-ready GLB, keep the source.
That third step is the whole breakthrough. It’s the difference between a model saying “here’s a peacock, probably” and a model that can see its peacock looks broken and go fix the tail. It’s the same loop a human 3D artist runs — model, orbit the camera, spot the problem, adjust — just driven by an agent writing code.
Why “as code” matters so much
Representing the model as a program instead of a static mesh buys you everything:
- Editability — “make the windows bigger” is a code edit, not a re-generation from scratch. The source is kept for later changes.
- Reviewability — geometry built procedurally can be structurally checked (is it manifold? watertight? correctly scaled?).
- Clean topology — helpers produce engine-friendly geometry, so GLBs drop in without cleanup.
- Reproducibility — same program, same asset; diffs are meaningful.
This is exactly the argument I keep making about our RF-SRC work and decision models: a checkable, revisable representation beats a one-shot opaque output for anything you actually have to ship.
It’s built for agents, not humans clicking
Kiln runs locally and ships as:
- an MCP server (so any MCP-speaking agent can use it),
- a CLI,
- a TypeScript library,
- and skills for authoring, editing, animation review, and scene composition.
Crucially: your agent supplies the model; Kiln does not require its own model API key. So you point Claude / GPT / Gemini / your local harness at Kiln’s tools, and the model does the authoring through Kiln’s feedback loop. The gallery even labels which model made which asset (a mechanical peacock by one model, an unfolding dragonfly by another) — though the authors are careful to note these are historical showcases with unvetted issues, not a model ranking.
The honesty check
Same thing I appreciated about the Laya repos: Kiln doesn’t oversell. The examples page explicitly says the showcases are “saved examples from different authoring runs… with unvetted modeling issues; they are not golden outputs or reference solutions,” and v0.8.0 notes an official package release “has not been published” yet (installable from the tagged archive via npm). That candor makes the actual claim — a working code-and-review loop for 3D — much more believable.
Why it matters
If you’ve ever tried to get usable 3D out of a text prompt, you know the gap between “cool render” and “asset I can put in my game.” Kiln attacks that gap the right way: make the AI show its work, look at it, and fix it — the same visual feedback loop a real artist uses. For indie game devs and anyone building 3D pipelines, this is the project to watch.
The pattern of the moment is everywhere now: don’t trust a single opaque generation — generate something checkable, then let the model verify and revise. Kiln is that idea, pointed at 3D.