Source-linked AI summary
Procedura: Agentic 3D Modeling with Procedural Control
Youtian Lin, Yikang Yang, Zhanpeng Hu, Mengqi Zhou, Feihu Zhang, Xun Cao, Jiaheng Liu, Yao Yao
TL;DR
Existing 3D generators can recover impressive geometry but typically produce soft, unstructured meshes without editable parameters. Procedura instead has a frozen LLM write a verified procedural assembly part by part, then refines it visually. On P3D-Bench and MechBench-36, it leads native generators and prior 3D-code agents on judged quality, with the sharpest edges and the only editable, part-structured output.
Problem
Native 3D generators produce geometry that can be soft at machined edges and lacks native part decomposition and editable parameters.
Method
Procedura uses a frozen LLM to plan an assembly graph and write a parametric CSG program part by part, with typed mates, solved placements, verification, and visual refinement.
Results
On P3D-Bench and MechBench-36, Procedura outperforms native generators and prior 3D-code agents on judged quality, producing the sharpest edges and the only editable, part-structured output.
Takeaways & Limitations
The output is a detailed procedural assembly whose named parts, parameters, materials, and articulation remain available for editing and downstream use.
Takeaways & Limitations
The vision loop relies on rendered images, which can hide occluded interiors and fine contact geometry; CSG is also less natural for organic surfaces and the mate vocabulary covers only rigid joints.
Abstract
from arXiv · showhide
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.
1 Introduction
Procedura addresses the gap between visually plausible but unstructured 3D meshes and editable, precise assets by writing shapes as verified procedural assemblies. It plans named parts, solves placements from typed mates, and refines the result through visual feedback.
- Motivation: Native generators produce raw triangles that remain soft at machined edges and lack native part decomposition or editable parameters.Separate segmentation is needed for part structure, while grid-based and token-based representations limit precision or detail.
- Approach: The agent plans an assembly graph, writes the program part by part, solves placements from mated frames, and verifies each commit before admission.Compile, mate, and connectivity checks turn a single blind generation into smaller checkable steps.
- Approach: A decoupled vision critic diagnoses rendered assemblies and gates one corrective fix at a time.The same assembly graph also carries per-part materials and simulator-validated articulation.
- Approach: Procedura represents a 3D object as a parametric assembly whose named parts are joined by typed, machine-checkable mates.The representation supports precise CSG geometry, explicit part structure, and parameter-level editing.
- Results: On P3D-Bench and MechBench-36, Procedura outperforms native generators and prior 3D-code agents on judged quality.It also produces the sharpest edges and the only editable, part-structured output among evaluated methods.
2 Related Work
Prior work spans direct continuous-geometry generation, editable program-based representations, and agentic systems that iteratively write and revise 3D code. Procedura’s related tooling includes static mating features rendered from compiler macros.
- Native 3D generation: Native 3D generation synthesizes continuous geometry directly, using optimization-based or feed-forward methods for prompts and images.Optimization-based approaches distill 2D diffusion priors, while feed-forward methods produce point clouds, implicit fields, or Gaussians.
- Program-based 3D generation: Program-based 3D generation represents shapes as editable, parametric construction programs, including CSG trees, structured assemblies, and CAD command sequences.Recent systems use large language models to write parametric 3D programs or translate text into construction commands.
- Agentic 3D-code generation: Agentic 3D-code systems wrap language models in draft–execute–revise loops that compile code and revise it from rendered or programmatic feedback.Related pipelines also generate articulated assets by coding parts and their kinematics, while other systems predict joints for existing meshes.
- Mate library: The mate library contains nine static mating features rendered from compiler macros, with male and female halves derived from a shared nominal dimension and signed fit offset.The new part receives the male half, while the partner receives the female cut.
3 Method
Procedura represents 3D objects as procedural assemblies and builds them incrementally, using typed mates, solved placement, deterministic verification, and visual refinement. This preserves precise, connected, named parts while allowing the assembly to be corrected one diagnosed issue at a time.
- Assembly representation: Procedura models an object as named parametric CSG parts joined by typed, machine-checkable mates.The assembly graph carries static and kinematic relations, while the compiled program produces the shipped mesh.
- Assembly-Graph Planning: The agent plans a topologically ordered assembly graph whose parts attach to previously placed geometry.Each part includes a module name, detail level, description, and interface declarations; review may add or sharpen parts but cannot merge, remove, rename, or reorder them.
- Mate-Driven Building: The build writes one part per LLM call using the accumulated program, reference context, and parts-colour renders of the current assembly.Each call emits five blocks, and deterministic splicing prevents earlier program content from being re-emitted or corrupted.
- Mate-Driven Building: Placement is solved from mated frames and fit offsets rather than generated as a raw assembly transform.The model authors geometry and mate frames; code computes the rigid transform, using additional static mates for verification.
- Verification: A part is admitted only after compile, mate-registration, penetration, and delta-aware connectivity checks pass or its quality attempts are exhausted.The connectivity gate rejects newly increased visible floaters relative to the running baseline, while exhausted parts may be committed with a warning.
- Decoupled-Critic Refinement: A separate vision critic renders the current build, diagnoses prioritized defects, and applies one top fix before verification recompilation.The critic is decoupled from the fixer and retains issue history to check whether earlier repairs landed and detect regressions.
4 Experiments
Procedura is evaluated under shared judging protocols on two benchmarks, where it leads competing generators and ablations while adding sharp, editable, articulated outputs. Results also quantify gains from refinement, planning, and feedback stages, alongside material and articulation validation.
- Setup and Protocol: Two benchmarks use shared evaluation conditions: MechBench-36 has 36 many-part objects, while P3D-Bench scores 203 text-and-image assembly cases.The evaluation locks prompts and reference views across methods and re-renders models under common judging conditions.
- Results on MechBench-36: 0.828 is Procedura’s top MechBench-36 judge composite with Gemini 3.7 Flash, ahead of TRELLIS.2 at 0.810.Procedura also leads geometry, aesthetics, and CLIP while shipping a mesh for every case.
- Results on MechBench-36: Procedura leads MechBench-36 geometry and aesthetics, the axes spanning 0.583–0.799 and 0.105–0.827 across methods.Semantic scores vary less, from 0.775 to 0.861, and Adam CAD and TRELLIS.2 share the semantic top at 0.861.
- Results on MechBench-36: Procedura’s compiled CSG preserves crisp bolts, vents, and panel lines, while native generators reproduce silhouettes but blur these features.The strongest native generator, TRELLIS.2, trails by 5.2 CLIP points; Direct3D-S2 and Hunyuan3D trail on aesthetics by 0.27 and 0.24.
- Results on MechBench-36: Procedura’s sharp-edge lengths are 158.1 and 185.2 units above 60° dihedrals, 2.6× and 3.1× the next code-emitting method.These results use Gemini 3.7 Flash and GPT-5.6-sol respectively, with 95th-percentile dihedrals of 98.0° and 105.3°.
- Results on P3D-Bench: On P3D-Bench, Procedura solves all 203 cases and reaches composites of 0.590 and 0.575, versus 0.524 for the strongest full-coverage entry.The largest lead is on geometry: 0.490 versus 0.392.
- Ablation Study: Removing refinement, planning, or per-part feedback lowers quality on every column; removing planning costs the most overall at 0.791 versus 0.828.Dropping refinement lowers the composite to 0.800, isolating the decoupled critic’s contribution.
- Materials and Articulation: Across 18 articulated objects, 14 pass every dynamics phase and 9 also pass advisory asset rules; four fail outright.Failures comprise one asset that would not load and three whose actuators never traverse.
5 Limitations
Procedura’s limitations concern visual access, object class, and mate coverage. Rendered views can hide interiors and fine contacts, CSG is less natural for organic surfaces, and undeclared mates cannot be verified.
- Limitations: Rendered-only perception can miss occluded interiors and fine contact geometry; depth maps, cross-sections, or direct mesh queries could strengthen refinement.The rendered view conveys silhouette and placement well but does not expose every geometric relationship.
- Limitations: CSG precisely captures mechanical hard-surface objects but expresses organic, freeform surfaces less naturally than a neural field.
- Limitations: The mate vocabulary covers rigid joints only, and a mate omitted from the plan cannot be verified.
6 Conclusion
Procedura generates 3D objects as editable procedural assemblies authored by a frozen LLM, combining verified part construction with vision-guided refinement. Across two judged benchmarks, it leads prior methods in quality and edge sharpness while uniquely producing an editable, part-structured program.
- Procedura generates objects as parametric assemblies whose named parts are joined by typed, machine-checkable mates.Placement is solved from mated frames, commits are verified, and a decoupled vision critic refines diagnosed fixes.
- The same assembly graph carries per-part materials and simulator-validated articulation.
- On P3D-Bench and MechBench-36, Procedura leads native generators and prior 3D-code agents on judged quality.The evaluations use blind assembly judging on both benchmarks.
- Procedura produces the sharpest measured edges and uniquely reopens as an editable, part-structured program.