Recursive Code World Models build 3D scenes from one image

Code world models represent a scene as an executable program. Zhiqi Li and co-authors argue that this representation alone does not say how to construct a complex world: knowing that the end result should be a program does not tell you how to build one. Their paper, posted to Hugging Face Papers, introduces Recursive Code World Models (RCWM), a framework for reconstructing a full 3D world in code from a single reference image.

RCWM pairs two pieces. A Recursive Scene Program, or RSP, represents the finished scene as compositional scene code. A construction solver builds that program by calling itself recursively, and every call runs the same three-step loop: establish the whole scene at a coarse level, recursively reconstruct whichever parts are still unresolved, then revisit the whole scene again to refine how the newly built parts fit together. The authors call this a global-local-global recursion. It lets fine-scale structures get their own perception-and-editing loop without losing track of the scene's overall geometry and the relationships between its parts. A shared camera projection is propagated across every recursion level so that reference-aligned views stay consistent as the solver zooms in and back out, and the step where the solver revisits the parent scene is specifically what fixes boundary mismatches, spatial relationships and errors that a local edit can introduce. A vision-language coding agent drives the loop from end to end: it compares the reference image directly against renders of whatever the current code produces, and uses that comparison to decide what to refine, when to recurse deeper into a part, and when to return back up to the parent.

The authors report that across complex scenes, RCWM outperforms prior code-based methods for reconstructing a scene from an image. Ablation studies, they say, back the value of the recursive approach and show specifically that calling the solver more deeply improves the reconstruction of finer-scale detail. The text as posted gives no scores or error rates behind that comparison, names no specific prior methods it was measured against, and names no particular scenes, datasets or benchmarks, so the size of the improvement cannot be checked from the abstract alone. There is also no mention of the authors releasing code, model weights or a dataset, or of any license, so RCWM exists for now as a published method rather than something to run.

Key facts

Zhiqi Li and co-authors introduce Recursive Code World Models (RCWM), which reconstruct a complex 3D scene as executable code from a single reference image.
RCWM pairs a Recursive Scene Program (RSP), which represents the scene as compositional scene code, with a construction solver that calls itself recursively in a global-local-global loop: establish the whole scene, rebuild unresolved parts, then revisit the whole to refine how the parts fit together.
A vision-language coding agent compares the reference image against renders of the current code's output and uses that comparison to decide what to refine, when to recurse deeper, and when to return to the parent scene.
A shared camera projection carries across every recursion level to keep reference-aligned views consistent, and revisiting the parent scene is what fixes boundary mismatches, spatial relationships and errors left by local edits.
The authors report RCWM outperforms prior code-based image-to-scene methods across complex scenes and that deeper recursive calls improve finer-scale reconstruction in ablations, though the text names no scores, baselines or benchmarks.

Why it matters

The paper's own framing is that representing a scene as executable code does not by itself say how to build a complex one: a code world model tells you the destination is a program, not how to get there. RCWM's answer is a general construction principle: break the scene into a Recursive Scene Program of compositional scene code, solve whichever parts are unresolved, then reconcile them with the whole, and repeat that same three-step loop at whatever depth the scene needs. The authors report that going deeper with this same loop keeps helping: their ablations found that deeper recursive calls improve the reconstruction of finer-scale detail.

Who it affects

This is aimed at researchers working on code-based, program-synthesis approaches to 3D scene reconstruction, and specifically at anyone building on code world models: systems that turn an image into a structured, editable program rather than a raw 3D representation. Anyone developing or benchmarking a code-based image-to-scene method is the direct comparison point the authors are measuring RCWM against.

How to use it

RCWM is presented as a research method rather than a released tool. The paper's text carries no mention of code, model weights or a dataset being released, and names no license, so for now there is nothing to install or to license; the contribution is the construction method itself.

How solid is it

The support behind RCWM is the authors' own comparison and their own ablations. They report that it outperforms prior code-based image-to-scene reconstruction methods across complex scenes, and that the ablations back the recursive design, in particular that going deeper improves how well fine-scale detail comes out. What is missing from the text is any score, percentage or error rate for that headline comparison, and any name for the prior methods, scenes, datasets or benchmarks involved, so none of it can be checked against a number.

Risks and caveats

Every comparative claim in the text is self-reported, with no independent baseline, score or benchmark named to weigh it against, so the size of the improvement over prior work is not something a reader can verify from the paper alone. The method's quality also rests on the vision-language coding agent's refine, recurse and return judgments at each level of the recursion; since no specific scenes or benchmarks are named, whether that judgment holds up beyond the authors' own tests is not something the text lets a reader check. No code, model, dataset or license is mentioned, so RCWM cannot currently be run or verified independently by anyone outside the authors.

“this representation alone does not determine how to construct a complex world”

— Zhiqi Li and co-authors, on why a code representation alone isn't enough