Pith. sign in

REVIEW 4 major objections 6 minor 37 references

Nova3D claims that generating 3D assets as executable source code makes them programmable—named parts, hierarchy, pivots, and joints exist at generation time—while keeping shape quality competitive.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-01 10:03 UTC pith:Y6NMZ5KX

load-bearing objection A credible, well-engineered systems paper on code-native 3D asset generation, whose central representation claim holds up but whose benchmark ground truth is self-authored — worth serious refereeing. the 4 major comments →

arxiv 2607.22738 v1 pith:Y6NMZ5KX submitted 2026-07-22 cs.GR cs.CV

Nova3D: Code-Native Generation of Programmable 3D Assets

Nimra Noor , Muhammad Bilal , Abdullah Hussain , Hassan Baig This is my paper
classification cs.GR cs.CV
keywords code-native 3D generationprogrammable assetsprocedural modeling with LLMs3D asset benchmarksassembly hierarchyarticulation and jointsBlender source generationconstraint satisfaction
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper sets out to prove that 3D generation should output a program, not just a surface. Its thesis: the program is the asset and the mesh is a compiled artifact. If true, a generated object carries named parts, an assembly tree, pivots, and edit handles at birth, so downstream systems can measure, edit, and animate it without a separate segmentation and rigging pass. On a frozen 54-item benchmark with machine-checkable specs, Nova3D produces an executable program and a valid artifact for all 54 items, satisfies 51 of 52 stated constraints, keeps all 18 local edits local, and exposes 59 geometrically valid joints where all baselines expose zero. The claim is representational rather than visual: geometry is competitive in structured domains, while texture realism is conceded.

Core claim

Nova3D's discovery is representational: generate the asset as an executable Blender program, and let the mesh be a compiled artifact. The program names every component, parents parts into a transform tree, puts each moving part's origin at its physical pivot, and stores dimensions as named constants; the exported GLB scene graph therefore natively carries named parts, hierarchy, and joints. Consequences measured by the paper: 54/54 executable assets with saved artifacts, 100% of assets with a named assembly tree, 51/52 prompt-stated constraints satisfied by direct geometry measurement, 14/18 blinded local edits passing with locality preserved in all 18, and 59 joints at 98.3% geometric valid

What carries the argument

The load-bearing object is the executable Blender Python program produced for each asset, plus the representation doctrine that the system enforces: every visually distinct component becomes a separately named mesh; repeated instances are individually named; parts are parented into a glTF scene graph with semantic group nodes and pivots; each movable part's origin sits at its physical pivot; dimensions are named constants; materials are PBR families assigned by meaning. A closed-loop package—monocular depth/normal/edge perception, verified material-color sampling, LLM program synthesis, deterministic headless Blender execution, autonomous shape/scale/parts checks, and a bounded repair loop w

Load-bearing premise

The load-bearing premise is that Nova3D-Bench's AI-assisted, author-adjudicated ground-truth specs are accurate and unbiased; the paper explicitly states there is no independent human annotation (§4.1, Fig. 3, §13), so if the specs encode the authors' expectations, the structural scores are not anchored to independent truth.

What would settle it

Take a random subset of Nova3D-Bench items, have independent human annotators (who have not seen Nova3D's outputs) write specs for parts, counts, dimensions, and joints, and re-run the constraint and semantic-recall measurements. If agreement with the frozen specs is low, or if Nova3D's scores drop to baseline levels under the new specs, the central structural claim fails. A second, cheaper test: run an off-the-shelf segmentation-and-rigging pipeline on mesh-native outputs of the same items; if it recovers equivalent named hierarchy and usable joints without oracle vocabulary, the categorical

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • If code-native generation is right, semantic handles are present at generation time, so post-hoc segmentation and rigging become optional rather than required.
  • Constraint satisfaction becomes automatable: named anchors in the scene graph let a scorer measure counts and dimensions directly, giving full coverage rather than guessing from a fused mesh.
  • Local editing becomes a surgical, source-level change: in all 18 tested edits, non-target content was preserved, even when the target itself failed.
  • Articulation becomes an additive operation: joints are inserted as pivot nodes without moving a vertex, so the rest pose stays frozen and the motion is code.
  • Production tasks benefit from the representation: unwrapping the pre-modifier construction geometry yields about 6x fewer UV islands than unwrapping the baked mesh.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The paper's own §13 boundaries the claim: N=54, synthetic reference images, AI-assisted author-adjudicated specs with no independent annotation, a VLM judge not yet human-validated on normals, 18-item and 12-item case studies, and generic joint limits. A reader should treat the structural scores as promising but not settled.
  • If the representation shift scales, assets become code objects: versionable, diffable, searchable, and re-parameterizable; the paper leaves this library/economy implication implicit.
  • The categorical 'baselines expose zero joints' invites a direct challenge: an automatic rigging pipeline on mesh-native output may recover equivalent joints, which would weaken the categorical part of the claim.
  • The reported weak spot—small accessory targets like watch hands—suggests a testable extension: add a verification agent specialized for small-part scale and visibility during the repair loop.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. Nova3D proposes a code-native representation for 3D generation: rather than emitting a mesh, the system outputs an executable Blender program whose compiled GLB is a secondary artifact, with named parts, a parent–child assembly hierarchy, pivots, constraints, and edit handles present at generation time. The paper evaluates this claim on Nova3D-Bench, a frozen benchmark of 54 items across six domains, against eleven baselines in four families plus a same-LLM ablation. Headline results are: 54/54 executable artifacts; 51/52 prompt-stated constraints satisfied; named tree on 54/54 assets; 14/18 local edits with locality preserved 18/18; 59 native joints across 12 assets where all baselines expose zero; and geometry competitive with mesh-native methods in structured domains while conceding texture realism. The authors are explicit that the benchmark ground truth is AI-assisted and author-adjudicated with no independent human annotation, and that several evaluation components are internal or LLM-judged.

Significance. If the structural claims hold, the paper would establish a genuinely useful representational shift: an asset as a program rather than an opaque surface, with measurable handles for downstream interaction. The paper has real strengths that should be credited: the deterministic checks on GLB scene graphs and geometry, the same-LLM ablation isolating the system package from the base model, the honest and explicit limitation statements, and the release of code and benchmark. Those make the reliability and hierarchy-existence findings credible. However, the load-bearing structural numbers — constraint satisfaction, semantic naming recall, joint recall — are measured against a self-authored benchmark whose ground truth was created by the same team and the same model family, and several subjective evaluations use internal or unvalidated judges. Independent annotation and external human validation are needed before the structural and perceptual claims can be fully anchored.

major comments (4)
  1. [§4.1, Fig. 3, §13] The benchmark ground truth is produced by a dual-pass AI-assisted, author-adjudicated protocol with no independent human annotation. Every structural headline — 51/52 constraints, naming recall 0.82, joint recall 0.76 — is measured against this spec.yaml. Because the same team designed the prompts, the system, and the spec, the target part decomposition, vocabulary, and dimension recipes may encode expectations biased toward Nova3D's outputs; inter-pass agreement (part-F1 0.79) leaves ample room for adjudication to steer the spec. As generation is closed-book, this would not be caught by the current protocol. I do not see how the structural claims can be anchored without adding independent human annotation on at least a stratified subset of specs, or by reusing an externally defined part/constraint benchmark.
  2. [§7.1, Table 9] Semantic recall/precision for Nova3D (0.82/0.99, 'no hallucinated parts') comes from three LLM judges with no human ground-truth labels. The reported inter-judge spread measures only self-consistency; shared model biases could inflate both recall and precision. Please add a human-labeled subset and report human-LLM agreement. Without that, the claim of 'almost no hallucinated parts' remains an model-assessed, not an independently verified, result.
  3. [§9, Tables 13–14] The editability study uses two project-team members as reviewers. Blinding and chance-corrected agreement are good practice, but internal reviewers are not an independent check. Given that the strong locality claim (18/18) and the target-success claim (14/18) are central to the 'editable asset' argument, at least the target-semantics and locality labels should be re-scored by external raters, or the claim should be explicitly limited to 'internal review shows...'.
  4. [§6.1, Table 5] The perceptual claim 'geometry is competitive, second only to TRELLIS.2' rests entirely on GPT-4o pairwise judgments over two normal-render views. The paper cites GPTEval3D, but that protocol's human alignment was not established for normal-render inputs in this setting. A small human preference study on a random subset of pairs is needed to calibrate the Elo/win-rate numbers, or the claim should be softened to 'VLM-judged parity'.
minor comments (6)
  1. [Table 3] The '54/30, mixed by modality' item set in the Visual shape row is ambiguous. Please report per-baseline item sets and separate text- and image-conditioned results where the comparison is pooled.
  2. [§4.1] The text says 18 constrained items carry a multi-constraint set (52 constraints total), but the breakdown by type (lengths, counts, angles, gear parameters) is not given. A small table or distribution would help readers see what the 52 constraints cover.
  3. [Table 4] The 'Compactness' column reports LOC for Nova3D and other code systems, but there is no definition of how lines are counted or whether comments/blank lines are excluded. Please define the counting rule or cite the tool used.
  4. [Abstract and §8] The abstract says 51/52 'prompt-stated' constraints; §8 says constraints are measured from the exported GLB against the spec. Make explicit that the numeric targets in the prompt are also encoded in the frozen spec, or readers may wonder whether the prompt was augmented.
  5. [Figure 10(b)] The caption calls the robot arm a 'depth-7 kinematic chain', while Table 10 reports mean depth 3.69. Clarify the counting convention (root vs. node depth) so the two figures are consistent.
  6. [§10] Joint recall is 0.761 with 0.700 required / 0.722 optional. This is a modest recall, and the abstract highlights 59 joints rather than recall. Consider stating both numbers in the abstract or discussion so the strength of the articulation claim is not overstated.

Circularity Check

0 steps flagged

No construction-level circularity; the disclosed author-adjudicated benchmark is an independence caveat, not a circular reduction.

full rationale

Nova3D's derivation is a systems-construction claim, not a fitted predictive model. No parameter is fit to the benchmark and later renamed as a prediction. The structural affordances—named parts, assembly tree, pivots, joints—are consequences of an explicitly enforced representation doctrine (§3.4) and are measured directly and deterministically from the exported glTF/GLB (§7.2, §8, §10, Table 12). The same-LLM ablation (§5) and closed-book generation (§3.1) provide a genuine control that isolates the system package from the base model. The paper does not rely on load-bearing self-citations or imported uniqueness theorems. The one self-referential element is the benchmark ground truth: §4.1 and §13 explicitly state that specs were produced by a dual-pass, AI-assisted, author-adjudicated protocol with no independent human annotation. This is a real limitation on the independence of the headline structural numbers, but it does not make any predicted quantity equivalent to its input by construction; the GLB measurements are deterministic given the frozen spec, and the worked constraint audit gives the evaluation independent content. Therefore no significant circularity is present, and the score remains 0.

Axiom & Free-Parameter Ledger

3 free parameters · 6 axioms · 0 invented entities

The central claims rest less on mathematical axioms than on assumptions about the evaluation substrate: that the benchmark specs are valid, that VLM judgments track human preference, that Blender execution is deterministic, and that the closed-loop repair with hand-set thresholds is sufficient. No new physical or ontological entities are introduced.

free parameters (3)
  • repair retry budget i_max = 3
    Hand-set cap on refine-and-rebuild iterations in Eq. 5; reliability percentages (100% final success, 81.5% first-shot) depend on this budget.
  • source-shrink guard threshold = 15%
    Deterministic guard in §3.4 rejects any repair correction that shrinks the source by more than 15%; the threshold is chosen by hand and shapes the repair loop.
  • material consistency threshold τ = unspecified
    Eq. 2 retains image colors whose consistency score exceeds τ; the value is not stated and is a hand-set threshold in the verification stage.
axioms (6)
  • domain assumption Headless Blender execution is deterministic and a faithful compiler from Python source to GLB geometry.
    Invoked in Eq. 4 and §3.3; if execution were not deterministic, the 54/54 executability and constraint-measurement numbers would not be stable.
  • domain assumption The base LLM can author valid Blender Python when given the Nova3D doctrine and repair feedback.
    Eqs. 3 and 5 presuppose this capability; the ablation demonstrates it for one unnamed model, and the result is not shown to be model-independent.
  • domain assumption Monocular depth, normal, and edge estimates plus ViT features contain enough structural evidence to reconstruct an asset from an image.
    Eq. 1 and the pipeline in §3.3; the 30 image-conditioned items depend on these priors being sufficient.
  • domain assumption GPT-4o pairwise judgments on texture-free normal renders approximate human preference for shape quality.
    Used in §6.1 for the shape-quality tournament; the paper cites GPTEval3D but admits in §13 that the judge is not human-validated on normal-render inputs.
  • domain assumption The AI-assisted, author-adjudicated Nova3D-Bench specs are an accurate ground truth for parts, counts, dimensions, and joints.
    Described in §4.1 and Fig. 3; all structural headline metrics are measured against these specs, with no independent human annotation.
  • domain assumption Vision-capable LLM judges correctly decide whether generated node names denote real object parts.
    Used in §7.1 for semantic recall/precision via a three-judge consensus (Claude Opus 4.8, GPT-5, Gemini 3.1 Pro); no external validation beyond inter-judge agreement is provided.

pith-pipeline@v1.3.0-alltime-deepseek · 20528 in / 13578 out tokens · 108420 ms · 2026-08-01T10:03:41.207410+00:00 · methodology

0 comments
read the original abstract

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.

Figures

Figures reproduced from arXiv: 2607.22738 by Abdullah Hussain, Hassan Baig, Muhammad Bilal, Nimra Noor.

Figure 1
Figure 1. Figure 1: Nova3D system overview: single input to production 3D asset. From one input view (sketch, photo, render, or blueprint), the system extracts prior maps (depth, surface normals, edges) and ViT patch features (stages 01–03), verifies sampled pixel values for material and color consistency, rejecting outliers (04), and compiles the verified evidence into an executable build program (05). The program is execute… view at source ↗
Figure 2
Figure 2. Figure 2: Excerpt from a generated program (the desktop robot arm, abridged). Dimensions are named constants, each component is a separately named mesh, its origin is set at the physical pivot, and it is parented into a named joint group. This is why a dimension is checkable against the source’s own anchors and why “make it taller” is a one-constant edit. 4 [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Benchmark freeze protocol. A dual-pass, AI-assisted, author-adjudicated annotation pipeline with a reported agreement gate. There is no independent human annotation; the protocol and agreement numbers make the ground truth auditable [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: The system package, not the base model. (a) Per-item execution outcome plus suc￾cess/time/compactness; only Nova3D runs and saves an artifact for all 54 items, while the same base model without the package fails or invalidates nearly half. (b) Nova3D win-rate against each code-native opponent by criterion (textured, both-orders-resolved); its closest competitor is the naive ablation (overall 67.7/19.4/12.9… view at source ↗
Figure 5
Figure 5. Figure 5: Honest qualitative comparison (as-delivered renders, shared scene). Nova3D holds the structured domains (top: a garden gazebo with clean panels and posts) and wins vehicles (middle: a go-kart, 55.6% domain win-rate), while it concedes freeform organic surface detail and baked-texture realism to the strongest mesh-native model on characters (bottom: a dragon). Right column is Meshy (top, middle) and TRELLIS… view at source ↗
Figure 6
Figure 6. Figure 6: Perceptual fidelity on texture-free geometry. Nova3D wins the structured domains and is #2 of 5 in Elo, behind only TRELLIS.2. Panel (c) shows that geometric quality is Nova3D’s strongest criterion in every domain, including the domains it loses (62% in tools); the losses concentrate in prompt alignment and structural plausibility, i.e. in matching the object’s identity and completeness, not in surface qua… view at source ↗
Figure 7
Figure 7. Figure 7: Part-aware methods build sealed solids; single-mesh diffusion outputs open shells; only code￾native ships a tiny editable program. Delivered GLB byte-size is not compared as a geometry win because baseline GLBs embed PBR texture maps; compactness is argued on triangle count and editable-source size. 20 [PITH_FULL_IMAGE:figures/full_fig_p020_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: The program is the asset: native semantic handles, shown rather than told. A generated gear train rendered alongside each system’s actual exported node names. Nova3D exposes individually named teeth, hubs, and pivots organized into a parent–child tree. CubePart, the oracle post-hoc segmenter that operates on a TripoSG mesh and is handed the target part names, returns a short flat list of labels (capped); t… view at source ↗
Figure 9
Figure 9. Figure 9: Native semantic handles. (a) The parts → named → richness staircase across 13 systems (bootstrap CIs). (b) A city bicycle: Nova3D exposes hundreds of individually named parts (spokes, crank arms); oracle CubePart is capped at 8 and drops four real spec parts; the part-aware diffusion model returns geometry N; the mesh-native model returns a single blob. 21 [PITH_FULL_IMAGE:figures/full_fig_p021_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: A parent–child assembly tree is exposed natively only by code-native generation. The robot arm’s actual scene graph is a depth-7 kinematic chain, every level a named pivot; the baselines are flat lists with nothing to address or move. 0 10 20 30 40 50 60 70 Expected benchmark constraints in this method slice CAD-Coder Text2CAD Text-to￾CadQuery BlenderLLM naive same-LLM Nova3D 5 3 7 0/15 pass cov 0.333 sat… view at source ↗
Figure 11
Figure 11. Figure 11: Constraint scorecard. Stacked per-method bars: passed (green), measured failures (orange), unaddressable anchors (yellow), and missing artifacts (grey). Nova3D is measured on every row and misses one; baselines fail through missing artifacts, missing anchors, or wrong values. base generated asset → natural edit instruction → source-level edit ↓ edited code.py + edited model.glb → deterministic gates ↓ bli… view at source ↗
Figure 12
Figure 12. Figure 12: Local-edit protocol. Deterministic representation gates precede a blinded, adjudicated human visual review. 22 [PITH_FULL_IMAGE:figures/full_fig_p022_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: Local edits preserve the surrounding asset. Deterministic representation gates saturate at 18/18; the limiting stage is target semantics. In both successful and failed edits the surrounding asset stays intact. Failures are local targets that are not visually correct enough, not global regenerations. Nova3D naive same-LLM BlenderLLM CubePart (oracle) PartCrafter TRELLIS.2 TripoSGMeshy LLaMA-Mesh MeshAnythi… view at source ↗
Figure 14
Figure 14. Figure 14: Articulation as an additive operation on a program. Nova3D produces articulable joints and readiness pivots while all baselines are at zero; the robot arm actuates across poses while its visible geometry stays frozen. Motion is added as code, not regenerated. 23 [PITH_FULL_IMAGE:figures/full_fig_p023_14.png] view at source ↗
Figure 15
Figure 15. Figure 15: Production readiness from source representation. (a) Unwrapping the pre-modifier construction geometry yields few large UV islands; unwrapping the baked GLB shatters the surface into many small islands. (b) Code-built parts deviate far less from clean fitted primitives than diffusion- or segmentation￾derived parts. 24 [PITH_FULL_IMAGE:figures/full_fig_p024_15.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

37 extracted references · 5 linked inside Pith

  1. [1]

    Ben Poole et al.DreamFusion: Text-to-3D using 2D Diffusion. 2022

    2022

  2. [2]

    Chen-Hsuan Lin et al.Magic3D: High-Resolution Text-to-3D Content Creation. 2023

    2023

  3. [3]

    Alex Nichol et al.Point-E: A System for Generating 3D Point Clouds from Complex Prompts. 2022

    2022

  4. [4]

    Heewoo Jun and Alex Nichol.Shap-E: Generating Conditional 3D Implicit Functions. 2023

    2023

  5. [5]

    Ruoshi Liu et al.Zero-1-to-3: Zero-shot One Image to 3D Object. 2023

    2023

  6. [6]

    Yangguang Li et al.TripoSG: High-Fidelity 3D Shape Synthesis using Large-Scale Rectified Flow Models. 2025

    2025

  7. [7]

    Jianfeng Xiang et al.Structured 3D Latents for Scalable and Versatile 3D Generation (TRELLIS). 2024

    2024

  8. [8]

    Tencent Hunyuan3D Team.Hunyuan3D 2.0: Scaling Diffusion Models for High-Resolution Textured 3D Asset Generation. 2025

    2025

  9. [9]

    Meshy.Meshy 5: Commercial Text/Image-to-3D Generation. 2024

    2024

  10. [10]

    Kaichun Mo et al.PartNet: A Large-Scale Benchmark for Fine-Grained and Hierarchical Part-Level 3D Object Understanding. 2019

    2019

  11. [11]

    Minghua Liu et al.PartSLIP: Low-Shot Part Segmentation for 3D Point Clouds via Pretrained Image- Language Models. 2023

    2023

  12. [12]

    Yunhan Yang et al.SAMPart3D: Segment Any Part in 3D Objects. 2024

    2024

  13. [13]

    Ziqi Ma et al.Find Any Part in 3D (Find3D). 2024

    2024

  14. [14]

    Anran Liu et al.Part123: Part-aware 3D Reconstruction from a Single-view Image. 2024

    2024

  15. [15]

    Minghao Chen et al.PartGen: Part-level 3D Generation and Reconstruction with Multi-view Diffusion Models. 2024. 17

    2024

  16. [16]

    Yuchen Lin et al.PartCrafter: Structured 3D Mesh Generation via Compositional Latent Diffusion Transformers. 2025

    2025

  17. [17]

    Sumit Paul et al.Name That Part: 3D Part Segmentation and Naming (ALIGN-Parts). 2025. arXiv:2512.18003

    arXiv 2025

  18. [18]

    Chunyi Sun et al.3D-GPT: Procedural 3D Modeling with Large Language Models. 2024

    2024

  19. [19]

    Yutaro Yamada et al.L3GO: Language Agents with Chain-of-3D-Thoughts for Generating Unconven- tional Objects. 2024

    2024

  20. [20]

    Ziniu Hu et al.SceneCraft: An LLM Agent for Synthesizing 3D Scenes as Blender Code. 2024

    2024

  21. [21]

    Sining Lu, Guan Chen, Nam Anh Dinh, Itai Lang, Ari Holtzman, and Rana Hanocka.LL3M: Large Language 3D Modelers. 2025. arXiv:2508.08228

    Pith/arXiv arXiv 2025

  22. [22]

    Yuhao Du et al.BlenderLLM: Training Large Language Models for Computer-Aided Design with Self-improvement. 2024

    2024

  23. [23]

    Rundi Wu et al.DeepCAD: A Deep Generative Network for Computer-Aided Design Models. 2021

    2021

  24. [24]

    Mohammad Sadil Khan et al.Text2CAD: Generating Sequential CAD Models from Beginner-to-Expert Level Text Prompts. 2024

    2024

  25. [25]

    Haoyang Xie and Feng Ju.Text-to-CadQuery: A New Paradigm for CAD Generation with Scalable Large Model Capabilities. 2025. arXiv:2505.06507

    Pith/arXiv arXiv 2025

  26. [27]

    ICML 2025

    Ruiyu Wang, Yu Yuan, Shizhao Sun, and Jiang Bian.Text-to-CAD Generation Through Infusing Visual Feedback in Large Language Models (CADFusion). ICML 2025. arXiv:2501.19054

    Pith/arXiv arXiv 2025

  27. [28]

    Barkley et al.CADSmith: Multi-Agent CAD Generation with Programmatic Geometric Validation

    J. Barkley et al.CADSmith: Multi-Agent CAD Generation with Programmatic Geometric Validation

  28. [29]

    Anonymous.Text-to-CAD Evaluation with CADTests (CADTestBench). 2026. arXiv:2605.07807

    Pith/arXiv arXiv 2026

  29. [30]

    CVPR 2024

    Tong Wu et al.GPT-4V(ision) is a Human-Aligned Evaluator for Text-to-3D Generation. CVPR 2024

    2024

  30. [31]

    Yuze He et al.T3Bench: Benchmarking Current Progress in Text-to-3D Generation. 2023

    2023

  31. [32]

    Sitong Su et al.GT23D-Bench: A Comprehensive General Text-to-3D Generation Benchmark. 2024

    2024

  32. [33]

    Matt Deitke et al.Objaverse: A Universe of Annotated 3D Objects. 2023

    2023

  33. [34]

    Sebastian Koch et al.ABC: A Big CAD Model Dataset for Geometric Deep Learning. 2019

    2019

  34. [35]

    Willis et al.Fusion 360 Gallery: A Dataset and Environment for Programmatic CAD Construction from Human Design Sequences

    Karl D.D. Willis et al.Fusion 360 Gallery: A Dataset and Environment for Programmatic CAD Construction from Human Design Sequences. 2021

    2021

  35. [36]

    Doris, Md Ferdous Alam, Amin Heyrani Nobari, and Faez Ahmed.GenCAD-Code: A Dataset of CAD-Model Image and Code Pairs(introduced with CAD-Coder)

    Anna C. Doris, Md Ferdous Alam, Amin Heyrani Nobari, and Faez Ahmed.GenCAD-Code: A Dataset of CAD-Model Image and Code Pairs(introduced with CAD-Coder). 2025. arXiv:2505.14646

    Pith/arXiv arXiv 2025

  36. [37]

    Zhengyi Wang et al.LLaMA-Mesh: Unifying 3D Mesh Generation with Language Models. 2024

    2024

  37. [38]

    Yiwen Chen et al.MeshAnything: Artist-Created Mesh Generation with Autoregressive Transformers. 2024. 18 Nova3D (ours) Mesh-native Architecture (structured win) Vehicles (win) Characters (conceded) Figure 5:Honest qualitative comparison(as-delivered renders, shared scene). Nova3D holds the structured domains (top: a garden gazebo with clean panels and pos...

    2024