Procedura: Agentic 3D Modeling with Procedural Control

Youtian Lin; Yikang Yang; Zhanpeng Hu; Mengqi Zhou; Feihu Zhang; Xun Cao; Jiaheng Liu; Yao Yao

cs.CVAug 26, 2026

Procedura: Agentic 3D Modeling with Procedural Control

Authors: Youtian Lin, Yikang Yang, Zhanpeng Hu, Mengqi Zhou, Feihu Zhang, Xun Cao, Jiaheng Liu, Yao Yao

Organizations: Nanjing University · Envision

Abstract

Native 3D generators now recover impressive mesh geometry from a single image. However, a dense mesh stays soft where a machined object should be sharp, it carries no part decomposition, and it exposes no parameter a user could edit. To address this, we explore the paradigm of 3D shape as code, leveraging and scaling the coding ability of an LLM for 3D modeling. We introduce Procedura, a novel 3D modeling agent framework that writes an object as a procedural assembly, a parametric program whose named parts are joined by typed, machine-checkable mates. From a text prompt, the agent plans the object as an assembly graph and writes the program part by part, solving each placement from the mated frames rather than guessing it, and admitting a part only once compile, mate, and connectivity checks pass. A decoupled vision critic then refines the assembly one diagnosed fix at a time. Moreover, the same graph carries per-part materials and a simulator-validated articulation. We evaluate on P3D-Bench under its assembly judge, and with the same judge on MechBench-36, our hard-surface benchmark. On both, Procedura outperforms state-of-the-art native 3D generators and every prior 3D-code agent on judged quality, produces the sharpest edges of any method we evaluate, and is the only one whose output is an editable, part-structured program.

Figures & tables

Figure 2: A shape written as code is natively part-structured. Procedura builds each object as a parametric program with one named module per physical part, so the model decomposes into meaningful, editable segments at no extra cost, since there is no post-hoc segmentation step. The assault buggy (left) is shown with per-part colours and fanned out into its named parts (roll cage, turret, seats, wheels, drivetrain, panels), alongside other objects and a library of individual parts. A generated mesh is a single opaque surface. In contrast, every part here is individually addressable and re-parameterizable, and the same decomposition drives the per-part materials ( Sec. 3.5 ) and articulation ( Sec. 3.6 ).

Figure 3: Overview of Procedura. From a text prompt, Procedura first synthesizes a reference view and then runs three stages. In Planning, it decomposes the object into an assembly graph of named parts joined by typed mates. In Procedural Modeling, the mate-driven build, it writes the 3D program part by part; each part is generated against its mates and a render of the partial build, its placement is solved from the mated frames, and a verification stack of compile, mate, and connectivity checks guards every commit. In Refine, a decoupled vision critic diagnoses the rendered model and gates one fix at a time. The same graph then completes the asset with per-part materials and an articulation validated in Isaac Sim.

Figure 4: The mate library. The nine static mating features a part may declare, each rendered from the compiler macros the build emits. Teal is the male half added to the new part and grey the female half cut from its partner; both derive from one shared nominal dimension and a signed fit offset.

Figure 5: Mate-driven building. Top: for each planned part, the dynamic context packs three grounded sources into one generation message: (a) the assembly reference, namely the reference image, the prompt, and the part’s mate, shown here beside the verdict its mesh check returned; (b) the built history, the full and already-compiling program; and (c) 3D feedback, parts-colour renders of the build so far. Bottom: the program grows one part per mate, shown as five snapshots of the assault buggy at $2$ , $10$ , $18$ , $24$ , and $28$ parts. Each part is generated in one LLM call and parsed into five blocks. The splice is deterministic and the placement is solved from the mated frames, and the compile, mate, and span gates must all pass before the part is committed. Every commit re-renders the 3D feedback for the next part.

Figure 6: Span-based connectivity. A thin detached panel has near-zero enclosed volume, so a volume check passes and the floater ships; its bounding-box span covers most of the model and the defect is plainly visible. Procedura thresholds on span ( Eq. 4 ). Drawn to the worst case from our audit of a pre-gate pipeline:

70\%

span,

1.9\%

volume.

Figure 7: Per-part PBR materials from the reference. Procedura extracts a compact material library from the reference ( $25$ entries for the assault buggy, six shown), assigns one entry to each of the $41$ named parts, and a decoupled material critic corrects the assignment against the reference. A sub-part pass then splits a module into sibling colour blocks where one material is too coarse. Renders are Blender-Cycles PBR.

Figure 8: A sim-ready articulation validated in Isaac Sim. From the rover’s named parts, Procedura measures geometric evidence (the rotational-symmetry axes and contact regions) and plans the joint tree over the kinematic mates ( $17$ links, $16$ joints). It exports an OpenUSD articulation and a URDF and validates them headless in Isaac Sim; a failed verdict feeds rendered simulation frames back to the planner for one refine. Every panel is a real Isaac frame in per-link colours: the settled rest pose, four per-joint actuation sweeps, and the rover after a nine-wheel drive.

	Judge					Edge structure
Method	Geo $\uparrow$	Aes $\uparrow$	Sem $\uparrow$	Overall $\uparrow$	CLIP $\uparrow$	Shrp ${}_{60}\uparrow$	Dih ${}_{95}\uparrow$
Procedura (Gemini 3.7 Flash)	0.799	0.827	0.858	0.828	82.67	158.08	97.97
Procedura (GPT-5.6-sol)	0.756	0.793	0.843	0.797	81.76	185.18	105.28
Agentic 3D-code
Adam CAD (GPT-5.6-sol) [ 1 ]	0.778	0.759	0.861	0.799	81.26	57.35	90.41
ArtiCraft (GPT-5.6-sol) [ 55 ]	0.682	0.596	0.827	0.702	79.12	41.31	94.74

Table 1: MechBench-36 ( Figs. 9 and 10 ). Every method is re-rendered through one rig and scored by the same judge and CLIP backbone, so the only difference between rows is the method. Geo, Aes, and Sem are the judge’s geometry, aesthetics, and semantic axes, mapped per case to

0

–

1

\mathrm{clamp}((v-1)/9)

as in Tab. 2 ; aesthetics rates the object as an engineered part, and Overall is their mean. CLIP is prompt-to-render alignment on the shared renders. Shrp 60 is total sharp-edge length above a

60^{\circ}

dihedral and Dih 95 the

95

th-percentile dihedral, both measured on the shipped mesh. The

60^{\circ}

threshold keeps only genuine machined creases, since a shallower one also counts the ridges of a regressed surface. Cases where a method shipped no mesh score zero and stay in the mean, which is why CAD-Coder and cadrille sit low. Single-shot rows are one call with no plan, build, or refine stage. Best per column in bold.

Panel of Figure 9 — Figure 9: Qualitative comparison against LLM-driven 3D generation. Six benchmark objects, one per row, each generated from the prompt printed beneath it; every method receives the same reference image and render rig. Prior agents recover the rough silhouette but collapse the mechanism into a handful of boxes, whereas Procedura resolves each part as its own solid.

Panel of Figure 10 — Figure 10: Qualitative comparison against native 3D generators. The same six objects, one per row with its prompt printed beneath it, generated by four native 3D diffusion models and by Procedura (left column), all conditioned on the same locked reference image and re-rendered from the same camera and shading rig. The natives reproduce the silhouette faithfully, since they are trained end-to-end to do so, but their surfaces are soft, so bolt heads, vents, and panel lines fuse into one skin and no part boundary survives. Procedura compiles exact CSG solids, so edges stay sharp and every part remains separable.

Method	Semantic $\uparrow$	Geometry $\uparrow$	Aesthetics $\uparrow$	Judge (Overall) $\uparrow$
Procedura (Gemini 3.7 Flash)	0.666	0.490	0.616	0.590 $\pm$ 0.009
Procedura (GPT-5.6-sol)	0.661	0.460	0.604	0.575 $\pm$ 0.010
Gemini 3.7 Flash	0.662	0.458	0.577	0.566 $\pm$ 0.016
GPT-5.6-sol	0.662	0.444	0.584	0.563 $\pm$ 0.015
GPT-5.5	0.643	0.392	0.537	0.524 $\pm$ 0.012
Gemini 3.1 Pro	0.639	0.390	0.508	0.513 $\pm$ 0.012

Table 2: P3D-Bench assembly results. Every method is re-rendered from the same rig and scored by the benchmark’s assembly judge on its three axes, semantic fidelity, geometric quality, and aesthetics, normalized to

0

–

1

by the benchmark’s mapping; Judge (Overall) is their mean, the benchmark’s composite, with

95\%

intervals. Baselines are the benchmark’s entries, re-run under the same harness, plus single-shot prompting of the two base models Procedura uses.

Variant	Geo $\uparrow$	Aes $\uparrow$	Sem $\uparrow$	Judge $\uparrow$	CLIP $\uparrow$
Procedura (full)	0.799	0.827	0.858	0.828	82.67
w/o refine	0.762	0.793	0.846	0.800	81.84
w/o planning	0.756	0.775	0.843	0.791	82.36
w/o 3D feedback	0.790	0.815	0.852	0.819	81.96

Table 3: Ablations on MechBench-36. All variants use the same base model and are judged in the same single session as Tab. 1 , with the same normalization (

n=36

). Ablated variants are evaluated at the draft stage, before refine, so the planning and 3D-feedback deltas also include the absence of the refine stage.

Figure 11: What each gated edit changes. The assault buggy, refined from the draft the build stage produced. Every frame is rendered from one fixed camera, so a difference between frames is a difference in geometry; the inset magnifies the densest region of pixels that cycle’s edit changed, and the outline on the model marks where the inset is taken from. Each cycle is one fresh diagnosis followed by one gated edit; under every state we print the tool that produced it and the number of HIGH issues the critic reported for that state. The count falls $4\!\rightarrow\!3\!\rightarrow\!2$ ; the final state carries no count because the cycle budget ends before a further diagnosis. Cycle 2 is a sub-millimetre contact snap that changes connectivity but nothing a reader could see, and the frame says so.

Figure 12: Articulation across the benchmark. Six objects, each planned, exported to OpenUSD and URDF, and validated headless in Isaac Sim. Every panel is composited from that object’s own simulation clip, with the swept poses ghosted and the final pose solid, so a still carries the motion. The first five hold one commanded joint traversing its range; the last shows the wheeled base driving on the ground plane. All six pass every dynamics phase: each position-driven joint traverses $\geq\!97\%$ of its commanded range, no non-adjacent links touch at rest, and the URDF re-imports. Five also clear the asset rules outright; the tiltrotor trips the advisory drive-gain rule, the same rule two earlier rover plans tripped.

Figure 13: Texturing across the benchmark. Ten of the $36$ benchmark objects, geometry and materials both authored by Procedura . Every image is a Blender-Cycles render of the shipped program, with per-part materials assigned to the named modules.

Procedural 3D Generation

See all 10 papers

May 31, 2026

3DCodeBench: Benchmarking Agentic Procedural 3D Modeling Via Code

Procedural 3D modeling through code is emerging as a versatile paradigm, offering deterministic, engine-ready, and precisely editable assets that neural 3D generators inherently lack. Authoring such procedural content, however, demands deep expertise in 3D software APIs, parametric design, and code-level geometric reasoning. In this paper, we propose 3DCodeBench, a systematic benchmark for evaluating vision-language model (VLM) agents for procedural 3D generation in 3D modeling software. Specifically, 3DCodeBench evaluates how effectively 12 advanced VLMs can serve as procedural 3D modelers by translating text and image references into procedural code for 3D modeling software. Recognizing that automated metrics may not fully capture the perceptual quality of 3D shapes, we build 3DCodeArena, a ranking platform based on pairwise human preferences over generated 3D outputs. From extensive evaluations and results, we observe that: (1) Failures mostly arise from API mismatches, while successful renders still suffer from disconnected or floating 3D geometric components. (2) Test-time scaling, such as higher thinking budgets and multi-turn refinement, improves performance overall. Our findings highlight a critical need for high-quality procedural coding data to advance commercial VLMs. Furthermore, effective procedural 3D modeling requires a robust execution environment that provides high-fidelity feedback for iterative refinement. We release 3DCodeBench, including the curated large-scale dataset of multimodal (text/image) prompts, procedural code, 3D object triplets, evaluation protocol, and the public 3DCodeArena platform as a foundational toolkit for exploring VLM-based procedural 3D modelers.

Yipeng Gao, Lei Shu, Genzhi Ye +5

Google DeepMind · University of Southern California · Google Research

VLM Evaluation 3D Asset Generation Procedural Content Generation Procedural 3D Generation Code Generation Benchmarks

Ask PDF

Jun 9, 2026

P3D-Bench: Benchmarking MLLMs for Parametric 3D Generation and Structural Reasoning

Multimodal large language models can write code to produce complex programs as well as use programs to do 3D modeling, which opens up a new avenue for 3D generation powered by their priors, world knowledge and reasoning. Yet existing benchmarks rarely evaluate 3D modeling through code. Such modeling demands more than runnable code: from a text or visual specification, a model must generate a parametric 3D program that is geometrically precise, semantically aligned and assembly-consistent. We introduce P3D-Bench, a benchmark for parametric 3D generation. Unlike a 3D mesh, a parametric 3D program exposes explicit dimensions, construction operations and part relations, revealing whether a model recovers a design's structure, not just its appearance. Under a unified protocol, P3D-Bench covers three task families (Text-to-3D, Image-to-3D and Assembly-3D) and scores each output for executability, geometric fidelity, topology, text-grounded constraints, multiview semantic alignment and part-level structure. We construct P3D-Dataset, comprising 400 text cases, 400 image cases, and 203 annotated assemblies. Our evaluation on 100 cases from each task family yields three key findings. First, multi-part generation is substantially more challenging than single-part modeling, with models struggling to compose individual parts into a coherent structure. Second, models can often recover the global shape and semantic identity of the target object, yet fail to reproduce the precise parametric geometry specified by the input. Third, part-level modeling remains weak on assemblies, where models recover neither the geometry of each part nor the right number of parts. These results position P3D-Bench as a benchmark for evaluating precise parametric geometry and part-level structure in parametric 3D generation.

Yikang Yang, Zhanpeng Hu, Youtian Lin +5

Nanjing University · Envision

Part-Level 3D Generation Parametric CAD Modeling LLM-Based Program Synthesis 3D Shape Generation Text-to-3D Generation

Ask PDF

Jul 22, 2026

Nova3D: Code-Native Generation of Programmable 3D Assets

Current 3D generative models mostly produce a final surface: a visually strong but largely opaque mesh. Interactive 3D worlds need more than a surface. They need named parts, an assembly hierarchy, measurable constraints, local edit handles, and joints for articulation. We present Nova3D, a system that generates 3D assets as executable Blender source code; the compiled mesh, a binary glTF (GLB), is treated as the artifact, not the asset. Because the output is a program, semantic handles exist at generation time rather than being recovered afterward by segmentation or rigging. We evaluate on Nova3D-Bench, a frozen, spec-grounded benchmark of 54 items across six domains and three difficulty levels with text and image inputs, against eleven baselines in four families (mesh-native, part-structured, code-native, and CAD) plus a same-LLM ablation. Nova3D produces an executable program and a valid artifact for 54/54 items. Every asset exposes named parts organized in a parent-child assembly tree; no mesh-native, CAD, or segmentation baseline exposes either. It satisfies 51/52 prompt-stated numeric and count constraints (best baseline: 11/52), passes 14/18 blinded local edits with locality preserved in 18/18, and articulates 59 joints across 12 assets at 98.3% geometric validity, where every baseline exposes zero native joints. Its geometry is competitive: it wins the structured domains in a pairwise shape-quality tournament and is second only to the strongest mesh-native model, while conceding texture realism to baked-PBR systems. The central result is representational: code-native generation turns a generated 3D object from an opaque surface into a programmable asset that downstream systems can inspect, measure, edit, and animate.

Nimra Noor, Muhammad Bilal, Abdullah Hussain +1

1Raresense Inc · University of Edinburgh

Constrained Generative Modeling 3D Asset Generation Articulated 3D Asset Generation

Ask PDF

Abstract

Procedural 3D Generation

Explore similar work

3DCodeBench: Benchmarking Agentic Procedural 3D Modeling Via Code

P3D-Bench: Benchmarking MLLMs for Parametric 3D Generation and Structural Reasoning

Nova3D: Code-Native Generation of Programmable 3D Assets