Recursive construction strategy, not better representations, drives 3D scene fidelity

Complex 3D scene reconstruction from a single image breaks down not because the representation is wrong, but because the construction process is flat. RCWM's answer is to make that process recursive: every subworld—a building, a facade, a terrain patch—gets the same complete solve that the root scene gets, not just a local edit pass.

The mechanism is a three-stage loop that calls itself. At any level, the solver first establishes the whole scene at that scale, then dispatches child calls on unresolved parts, then revisits the assembled result to fix what only becomes visible after the parts return. That last step matters more than it might seem. A sign refined in isolation can end up covering a neighboring window; a bridge can stop meeting its riverbanks. These conflicts are invisible until the parts are composed, so a system that only refines locally and never re-inspects the assembled parent will keep producing them.

Camera geometry is handled carefully. Each child call inherits the parent's camera projection and receives a reference crop with matching coordinates and magnification. This means local comparisons stay geometrically honest—shape, scale, placement, and occlusion are all judged against the same frame the parent uses. When the root camera changes, affected child views are refreshed before further work continues.

The ablation results are the most concrete evidence for the design. On medieval-village, allowing free recursive depth (three levels, 33 nodes) raises whole-frame PSNR from 16.8 to 19.0 and local SSIM from 0.52 to 0.60 compared with a fixed two-level variant. On school-block, the free-depth run only needed two levels anyway and matched the fixed variant—which is itself informative: the recursion adapts to the scene's actual complexity rather than imposing a fixed decomposition.

Across all ten reference scenes, RCWM achieves the highest PSNR and lowest LPIPS on every one. SSIM is highest on nine of ten; on valley-village, VIGA edges it out (0.41 versus 0.38). All methods run on the same base model—OpenAI's gpt-6-astra via the Codex agent at high reasoning effort—so the gains trace to construction strategy, not model capacity.

The limitations are real. Single-view input leaves hidden geometry ambiguous, and the paper is candid that visual inspection can miss errors. Computation scales with recursive depth and component interactions, and convergence is not guaranteed. The evaluation covers ten scenes with single runs on one model, and the ablation covers only two of those scenes. Larger benchmarks and repeated runs would say more.

What the paper actually delivers is a construction principle with a clean formal statement and measurable results behind it. The recursive scene program representation—nested subworld code with explicit child references and shared dependencies—is the output format, but the solver is the contribution.