Learning Hierarchical and Geometry-Aware Graph Representations for Text-to-CAD
Authors: Shengjie Gong
Wenjie Peng
Hongyuan Chen
Gangyu Zhang
Yunqing Hu
Huiyuan Zhang
Shuangping Huang
Tianshui Chen
Venue: ICLR 2026 Poster (2026)
Keywords: Text-to-CAD
Graph Representations
Large Language Models
Curriculum Learning
Primary area: applications to computer vision, audio, language, and other modalities
TL;DR: We propose to learn a graph as an intermediate representation for Text-to-CAD, which makes the long-horizon generation of complex, constrained assemblies more robust by first establishing a structural blueprint to guide code synthesis.

Abstract: Text-to-CAD code generation is a long-horizon task, requiring the translation of instructions into a long sequence of interdependent operations. This process is exceptionally fragile, as minor early errors can propagate through the sequence and ultimately invalidate an entire complex assembly. Existing methods typically decode instructions directly into executable code (e.g., bpy) without an explicit representation of assembly hierarchy or geometric constraints. This flat decoding strategy vastly expands the search space, amplifying local errors and leading to cascading failures in contextual operations. We address this gap by learning an intermediate representation: a hierarchical and geometry-aware graph. The graph represents an assembly-based decomposition, with multi-level nodes modeling the product's parts and components, and edges defining the explicit geometric constraints between them. Rather than mapping text directly to code, our graph paradigm first predicts high-level structure and constraints, then conditions the sequencing of operations and program generation, thereby narrowing the search space and improving both geometric fidelity and constraint satisfaction. Furthermore, we introduce a structure-aware progressive curriculum learning mechanism to enhance the model's ability to generate sophisticated decomposition graphs, allowing it to handle more complex assemblies. The mechanism constructs graded tasks via controlled edits to object structure, probes the model’s capability boundary, and synthesizes boundary examples for subsequent training rounds. We also introduce a 12K-instruction dataset annotated with instructions, geometric decomposition graphs, action sequences, and bpy code, together with metrics for node- and hierarchy-level graph accuracy and a measure of constraint satisfaction. Extensive experiments show that our approach outperforms existing methods in terms of both geometric fidelity and accurate fulfillment of geometric constraints.

Published as a conference paper ICLR 2026
LEARNING HIERARCHICAL AND GEOMETRY-AWARE GRAPH REPRESENTATIONS FOR TEXT-TO-CAD
Shengjie Gong
Wenjie Peng'
Hongyuan Chen'
Gangyu Zhang'
Yunqing Hu²
Huiyuan Zhang
Shuangping Huang" Tianshui Chen
South China University of Technology Zhuzhou CRRC Times Electric Co., Ltd.
3 Guangdong University of Technology
ABSTRACT
Text-to-CAD code generation is long-horizon task, requiring the translation of textual instructions into a long sequence of interdependent operations. This process is excep- tionally fragile, as minor early errors can propagate through the sequence and ultimately invalidate an entire complex assembly. Existing methods typically decode instructions directly into executable code (c.g.. bpy) without an explicit representation of assembly hierarchy geometric constraints. This flat decoding strategy vastly expands the search space, accumulating local errors and leading to cascading failures in contextual opera- tions. We address this limitation by learning intermediate representation: hierarchical and geometry-aware graph. The graph represents an assembly-base decomposition, with multi-level nodes modeling the product's parts and components, and edges defining the explicit geometric constraints between them. Rather than mapping text directly to code, our graph paradigm first predicts high-level structure and constraints, then conditions the sequencing of operations and code generation, thereby narrowing the search space and im- proving both geometric fidelity and constraint satisfaction. Furthermore, we introduce a structure-aware progressive curriculum learning mechanism to enhance the model's 's ability to generate sophisticated decomposition graphs, allowing it to handle more complex as- semblies. The mechanism constructs graded tasks via controlled edits to object structure, probes the model's capability boundary, and synthesizes boundary examples for subse- quent training rounds. We also introduce 12K dataset annotated with instructions, geo- metric decomposition graphs, action sequences, and bpy code, together with metrics for node- and hierarchy-level graph accuracy and a measure of constraint satisfaction. Exten- sive experiments show that our approach outperforms existing methods in terms of both geometric fidelity and accurate fulfillment of geometric constraints. Code is available at https:://itthu: com/ SMUTT-MMPR/CGO GrMPP//Gaph-CAD
INTRODUCTION
Computer-aided design (CAD) provides precise digital representations of three-dimensional objects and is indispensable across manufacturing, architecture, and product design (Zhang et al., (0024). In this context, the Text-to-CAD task aims to generate executable CAD programs directly from natural- language instructions lower the barrier to professional design and accelerate prototyping (Khan et al. 2024b).
The Text-to-CAD task presents long-horizon challenge, particularly when generating complex assemblies, requiring translating instructions into lengthy sequences of interdependent CAD operations. This process
"Corresponding author.

---

Published as a conference paper ICLR 2026
Top-down Decomposition
Geometric Constraint Connection
Structured Text
Compae
Iemeeaer one (Caquodee
Mieronore
Cf Treeiall
Compani lie wicke Lywel) (igu
Dootbact Bor bec
Thor wa Calaall sat chtes]
CCrms parc Companic ethtact Coutos bebves
lnn
A pand rgne decrro mondow left
Allen bellenn betions
Doar vilador
Cautrol pand
Bedy skell
Turanable
Compus
Playe
Allgs bock froat
Paaci bose
Costrol butioms
(a)
(b)
Figure I: Geometric decomposition graph. (a) Top-down decomposition of user instruction (microwave oven example). The process starts from the complete product and recursively factors it into parts by assem- bly relations until components can be realized with bpy operators, forming multi-level nodes. (b) Graph Connection. Edges between nodes define explicit geometric constraints that encode their spatial relations. (c) Structured textual representation that captures both the node hierarchy and the constraint links.
demands not only global structural consistency to reflect user intent in the final assembly, but also strict adherence to local geometric dependencies to ensure the correctness of each sequential step. Together, these requirements ensure that all operations coherently collaborate to form a functionally valid and intentionally aligned CAD model (Nachum et al., 2018 Guo et al.). Most existing methods typically decode text directly into executable code via an end-to-end paradigm (Du et al., 2024). By flattening the design process into a linear sequence, they lack an explicit representation of the target model's assembly hierarchy and geometric constraints. This forces the decoder to navigate vast search space where local errors can accumulate, often leading to failures on complex assemblies (Chen et al. 2018).
To address these limitations, propose to learn a hicrarchical, gaoeetry-aware graph as an intermediate representation that makes assembly structure and constraints explicit, breaks the long-horizon generation into tractable stages, and provides structural guidance for constrained code generation. As shown in Figure I nodes represent parts and components a multi-level hierarchy, while the edges encode explicit geometric constraints between them. We serialize the graph as structured text, which then conditions subsequent steps (Parr& & Russell 1997 [Brockschmidt et al. 2018), effectively pruning the search space and improving both geometric fidelity and constraint satisfaction (Bunel al. 2018 Balog et al.] (016). To translate the abstract graph into an executable program, CAD employs three-stage inference process. It sequentially transforms a natural language instruction into a geometrie decomposition graph, parses the graph into a sequence of CAD operations, and finally generates the executable bpy code. As shown in Table I. this structured approach is effective even without task-speeific fine-tuning. With few-shot prompting of general-purpose LLMs, it yields substantial gains over direct text-to-code baselines, with the largest improvements in Geometric Constraint Satisfaction (GCS).
As part count and constraint density increase, local errors tend to compound, making complex, highly con- strained designs difficult to handle. To mitigate this effect, we introduce structure-aware progressive cur- riculum learning mechanism that strengthens graph prediction for highly constrained assemblies. The mech- anism operates iteratively by first creating graded task variants from seed examples, with difficulty ranging from simple attribute edits to complex categorical changes. The model's current capability boundary is identified as the highest difficulty level it can reliably solve for each seed. Then, new training instances are synthesized at this boundary, validated by a multimodal judge, and added to the training set for the
2

---

Published as a conference paper ICLR 2026
Table I: Performance comparison of two inference pipelines for general-purpor LLMs on CADBench. The table compares a end-to-end paradigm, which directly generates bpy code, with our three-stage Graph-CAD inference process. Both methods are prompted with two-shot examples to enhance task understanding.
CADRench-Sim
CADBamch-Wild
Models
Atr.f
Spuz.
Inst.1
Arg-1
Expatsed
CLIFT
GCSS
Astr1
Spa.1
Inst.7
Avr..
Exqaterr
CLIPT
GCS!
GPF-5 lend-to-and)
0,7013
0.7347
0.4250
0.6203
2,855
0.6449
0.3846
0.6858
0.7091
0.5595
0.6515
5.5%
0.0003
0,4017
GPT-5 (Graph-CAD)
0.7342
0.7199
0.4451
0,6270
2.2%
0.6535
0.6603
0,7677
0.7523
0,5577
0.6859
4,8%
0.6318
0,5849
Clude-opue-411 (end-in-end)
0.7216
0.7368
0.5403
0.6662
7.4%
0.6151
0.4932
0.6847
0.7218
0.5997
(16688
14.5%
0.5550
0,5062
Chade-opue-411 (Ciogh-CAT)
0.7573
0.7394
0.5025
0.6664
6.4%
0.6381
0.5705
0,7524
0.7301
0.5745
0U6857
8.5%
0.6059
0,5518
next round of supervised fine-tuning. Through this process, the model progressively learns to master more complex structures. In the absence of datasets that pair natural language instructions with graph-structured geometric decompositions, we curate 12K dataset BlendGeo to support training. Each example includes a user instruction, geometric decomposition graph serialized as structured text, its corresponding operation sequence, and executable Blender code (bpy). To assess model performance, we propose comprehensive evaluation metrics that measure graph fidelity at the node level and across the hierarchy, and we also report constraint satisfaction to quantify geometric validity.
Our contributions can be summarized as follows: (i) We propose to learn a graph-based intermediate rep- resentation for Text-to-CAD. This learned graph explicitly models the assembly hierarchy and geometric constraints of the target object, providing strong structural prior that helps maintain global consistency and satisfy local dependencies in the CAD executable code generation process, To our knowledge, this is the first attempt to achieve this goal. (ii) We propose a structure-aware progressive curriculum learning mech- anism that synthesizes graded variants to identify model's capability boundary and expands it by training with additional filtered boundary cases, gradually advancing its performance on complex, highly constrained assemblies. (ii) We introduce a 12K dataset BlendGeo pairing user instructions with decomposition graphs, operation sequences, and bpy code. We also propose evaluation metrics for node-level and hierarchy- graph accuracy to assess the quality of intermediate representations in any potential graph-mediated Text- to-CAD approach. (iv) We provide extensive experimental validation on public benchmarks. The results confirm that our graph-mediated paradigm significantly outperforms existing methods.
2 RELATED WORK
CAD Model Generation. Translating diverse inputs, such as text, sketches, images, and point clouds, into executable CAD code enables accessible design automation and faster prototyping across industrial workflows (Wang et al. 2025a Sanghi et al., 2023; Chen et al.] 2025 Khan et al., (004aa). Among these modalities, natural language is especially attractive due its expressiveness and low user overhead, facilitat- ing efficient iteration and collaboration in CAD (Xie & Ju 2025 [i et al. 2024] Wang et al. 2025b).. Recent studies like Text2CAD (Khan et al. 2024b) and CADLLM (Liao et al., 2025) adopt transformer-based ar- chitectures to map text prompts directly to parametric programs, while BlenderL.LM employs LLMs with self-improvement loops to refine command sequences (Du et al. (024).. Despite promising results on single- part objects, these methods typically cast Text-to-CAD as direct text-to-code generation without explicit modeling of assembly hierarchy or geometric constraints, which limits robustness on multi-pan designs. Subsequent work explores better planning via chain-of-thought (CoT) (Guan et al. 2025) and integrates visual or execution feedback (Badagabettu et al., 2024 Alrashedy et al., 2024). Yet these are planner-level augmentations rather than structural models, and errors still accumulate on complex assemblies.
Curriculum Learning, Curriculum learning (CL) improves optimization and generalization by exposing models to easier examples before gradually introducing harder ones (Bengio al. 2009). Early work also
3

---

Published as a conference paper ICLR 2026
User Instruction
Stagel: Grometry Decomposition
Stage2: Action Planning
Stage3: Code Goneration
Layort
Crotee model of's microwave with
Intormann siic (Comuutic of User Dety)
Skitt Craaa Reaal Eo nomooait ai 1000
Uranc
iepert
Composic
Skip: Crarc Contrl bessar Culoei
Bay
slightly larger transparent window on doer rectangular body with panel on the right and inserior tumtable
Dhs form
2105 wir wil eueee key my
bucmnn foc.
Seedy sikeerjjant, jeusieg jre]
coartl pastl paral plax
Lager
Skpt Ascetiic Cantre, benco horaa
bodiza unknapeene padd ahe koap satitsblc
Dove vnsdow (aboa (cebaa cutoucaatioo E-G
Ruy
CG and Oow anderd sue Cuutoal sutee))
Blbsc aed thateennntee Consedt
Outted
oli Lomaetonnt pondt wenkcce
Sapk Avemiic Cantii paed and siidoo Cooe July skip?
coantl panatlecattin raforts
#Laym
Figure 2: Overall framework of Graph-CAD. The framework comprises three sequential stages: Geometry Decomposition, Action Planning, and Code Generation. Each stage is independently driven by dedicated Large Language Model (LLM))baaed module.
introduced self-paced learning, which automates easy-first selection based on model competence (Kumar et al. 2010). Surveys highlight two core components of CL.: a difficulty estimator and pacing sched- ule, and summarize its benefits across vision, language, and reinforcement learning domains (Wang et al.) 2021 1 Soviany et al. 2022 Narvekar et al., 2020 Portelas et al., 2020p. Recent advancements extend CL.
to generative modeling, including difficulty-aware denoising schedules for diffusion and preference-drive curricula (Kim et al. 2024 Croitoru et al. 2025). Across these settings, three properties recur: explicit dif- ficulty signals, paced exposure that stabilizes training, and targeted practice near the boundary where errors begin to appear (Wang et [dl]]2221 (ooviay et al., (022). These properties align closely with learning decom- position graphs for CAD assemblies, where increasing part count and constraint density elevate the risk of error accumulation. Building on CL. our approach employs graded structural variants and boundary-focused augmentation to stabilize training and improve reliability on complex, highly constrained designs.
3 METHODOLOGY
In this section we present Graph-CAD, a Text-to-CAD framework that addresses long-horizen challenges by preserving global assembly coherence while satisfying local geometric constraints during code genera- tion. Our framework employs a three-stage generation process: it sequentially transforms natural language instructions into geometric decomposition graph, sequence of CAD operations, and bpy code. We addi- tionally describe a Auman-AI annotation pipeline for training/cvaluation data and a structure-aware progres- sive curriculum that improves robustness on complex assemblies.
3.1 GRAPU-CAD FRAMEWORK
As illustrated in Figure 2 Graph-CAD transforms instructions into executable CAD code through three- stage pipeline: Geometry Decomposition, Action Planning, and Code Generation. This modular design aims to produce CAD models with accurate structures and robust geometric constraints. Each stage is processed by a dedicated L.LM-based module for its specific task. Stage 1, the Geometry Decomposition Model converts the user-specified target CAD model into geometric decomposition graph based on two primary principles: top-down decomposition and geometric constraint establishment. As depicted in Figure I(a), we recursively disassemble the object by assembly relations until reaching atomic components realizable by primitive operators (e.g., s., bpy primitives) The resulting parts/subcomponets become nodes, and their spatial relations are encoded edges representing geometric constraints (Figure [bb). Guided by these principles,
4

---

Published as a conference paper ICLR 2026
Supervised Fine-Tuning
Structure-aware Progressive Curriculum Exploration
Graph-CAD
hroder
(Sou Toxtar aquamuet
Iiterred
(Stuctaed anjoracc))
Decerpoliio Kindl
Problem Generalic
Fresiim
Probien Set
Plaviing
Klaki
</>
Auxiaary Gogl-CAD
Boustrry
Boundary Tatn Generation
Exploration of Capability Roundary
The SAPCL mechanism. This mechanism alternates between two core modules: SFT and SAPCE. The SFT module fine-tunes the three constituent models of the Graph-CAD using all training data. The SAPCE module, in turn, begins by sampling subset of training instances and introduces a Problem Generator to synthesize three-level difficulty variants for each instance, forming a comprehensive problem Subsequently, Exploration of Capability Boundary sub-module assesses the model's performance on these variants to determine its current capability level. Based on these levels, a Boundary Data Generation sub-module uses the Graph-CAD and an auxiliary LLM to synthesize new data the determined difficulty boundary. After validation, these new data are merged into the training set for the next round of SFT.
Figure 3:
the Geometry Decomposition Model then formats this graph into a structured textual description (Figure [()), outlining all nodes and edges. Following this, in Stage 2, the Action Planning Model leverages the node features and geometric constraints from the generated decomposition graph to determine an optimal graph traversal order and construct the sequence of CAD operations. Finally, in Stage 3, the Code Generation Model translates the planned operations into executable bpy code.
3.2 DATA ANNOTATION FOR GEOMETRIC DECOMPOSITION
To support the training and evaluation of our three-stage Graph-CAD framework, we meticulously con- structed a BlendGeo dataset that contains 12K quadruplets of user instructions, geometric decomposition graphs, action sequences, and executable bpy code. Specifically, the user instructions spanning 1.4K object categories are extracted from the BlendNet (Du et al. 2024). The data was annotated using a collaborative human-Al pipeline. First, LLM guided by structured prompts generates a preliminary quadruplet for each instruction. This output is then subjected to a rigorous validation process where a Vision- Language Model (VLM) assesses the visual-semantee alignment, after which professional industrial designers either confirm its correctness or perform comprehensive corrections to the graph, sequence, and code. The re- sulting high-quality samples form the BlendGeo dataset. Furthermore, enable a rigorous evaluation of geometric decomposition graph accuracy and geometric constraint satisfaction, we applied this same anno- tation pipeline to the CADBench benchmark (Du al. 2024p. detailed description of the data annotation pipeline is provided in Appendix C.I
3.3 STRUCTURE-AWARE PROGRESSIVE CURRICULUM LEARNING
As the complexity of CAD models increases, the number of nodes and geometric constraints grows signif- icantly. Under limited training samples, this inherent complexity hinders the model's ability to generalize CAD designs of greater variety and structural intricacy. To address this challenge, we propose novel
5

---

Published as a conference paper at ICLR 2026
Structure-Aware Progressive Curriculum Learning (SAPCL) mechanism. The core principle is to progres- sively enhance the model's capabilities by first ascertaining its current performance boundary and subse- quently generating targeted instances to strategically expand it.
As depicted in Figure 3 the mechanism operates iteratively through two alternating modules: Super- vised Fine-Tuning (SFT) and Structure-Awant Progressive Curriculum Exploration (SAPCE). Each iteration starts with the SFT module, which continues to train from the previous round using all training data, pro- ducing an enhanced model that serves as a baseline for the subsequent exploration phase. The SAPCE module then probes and extends the model's capabilities. It begins by sampling a subset of seed exemplars from the training data, prioritizing categories with fewer instances to ensure diversity. For each exemplar, a Problem Generator, implemented with a LLM (e.g.. GPT-5), synthesizes spectrum of task variations based on the original user instruction and geometric decomposition graph. These variants are categorized into three difficulty levels: Easy, involving simple modifications such as dimensions or textures; Infermediate, which alters local geometric structures; and Advanced, transitioning the object to a distinct yet structurally analogous or functionally related category. The fine-tuned model then attempts to solve these variants in ascending order of difficulty. A multimodal Discriminator automatically evaluates the correctness of the generated CAD outputs, identifying the highest difficulty level the model can reliably handle per exemplar. The aggregate results across all exemplars collectively define the model's s current capability boundary. Based on this boundary, a Boundary Data Generation process synthesizes new training instances at and slightly be- yond the model's current mastery level. For example, if the model succeeds at the Intermediate level, new data generated for both the Intermediate and Advanced levels. An auxiliary LLM accelerates this process by using the original exemplar in one-shot demonstration. Finally, these newly synthesized and validated instances are merged into the training set, forming an enriched dataset for the next SFT round. This iterative cycle enables a progressive expansion of the model's ability to handle increasingly complex CAD designs. The complete SAPCI. process is detailed in pseudocode in Appendix C.2
4 EXPERIMENTS
4.1 EXPERIMENTAL SETUP
Datasets.
We train the Graph-CAD model on our BlendGeo dataset. We split the dataset 90%/10% for training and validation, with the validation set used for hyperparameter tuning. For evaluation, utilize the CADBench benchmark (Du et al. 2024), which includes CADBench-Sie (in-distribution instructions) and CADBench-Win Wild ofut-of-distributen instructions) to fully assess model performance and generalization.
Metrics. We evaluate our method using metries targeting three key aspects: visual quality, structural in- tegrity, and intermediate graph fidelity. For visual quality and code executability, we adopt CADBench metrics including scores for attribute accuracy (Attr.), spatial relations (Spat.), instruction following (Inst.), and syntax error rate (Esyntes). ). Attr., Spat. and Inst. score reported as the average of three independent evaluations from a VLM (c.g., GPT-5). The effectiveness of using a VLM as an evaluator is analyzed and validated in Appendix D.4 In addition, we report a CLIP- text-image similarity score (CLIP) between the textual instruction and the multi-view renderings of the generated CAD models Chen et al. (2023). This metric serves as a widely used indicator of how well the generated geometry visually aligns with the input instruction, complementing our VLM-based and geometry-base introduce Geometric Constraint Satisfaction (GCS), a novel metric that measures whether parts in the final assembly satisfy predefined geometric relationships, such contact, alignment, and relative orientation. Finally, to evaluate the correctness of our intermediate representation, we propose Node-Level Accuracy (NLA) and Hierarchy-Leve Accuracy (HLA). NLA measures if the correct set of parts (nodes) was gen- erated, while HLA measures their hierarchical structure (edges) is correct. Detailed formulations for all metrics provided in the Appendix C.4 C.4
metrics. To assess structural integrity, we
6

---

Published as a conference paper at ICLR 2026
Table 2: Quantitative comparison of CAD code generation methods on CADBench. Results are reported separately on the CADBench-Sim (in-distribution instructions) and CADBench-Wild (out-of-distribution instructions) subsets to evaluate both in-domain performance and disti--iiitiiuutio generalization. Attr., Spat., and Inst. measure visual quality via VLM, and Avg. is the average of these three scores. CLIP measures global text-shape semantic alignment, complementing the VI.M-based visual metrics. Esyntaz denotes the syntax error rate, and GCS measures geometric constraint satisfaction. Best results are in bold.
Mosicls
Amr.
Spu.1
lsst1
CADBaach Siz
Ang1
E Spezificllly
OCSI
Spa..
CADBaach
Aug.7
Exyoner
CLIP
GCS1
BI
0.6895
0,6953
0.3650
0.5852
2.4%
0.6762
0.636
0.4581
0.5909
5.3%5
0,5456
0.4553
TaM2CAD
0,3278
0.3164
0,0466
0.1956
6.5%
0.5707
(14196
0.3282
0,1525
0.2865
14.0%
0.5211
CADPusot
0,3556
0,2258
0.0074
0.2166
6.2%
0,5578
0.5832
0.3716
9.1856
0.3011
11.5%
0,5278
purpose Large Langwage
Models
Owen Plss
0.3634
0.3775
0,2072
0.3151
41.4%
0.3382
0,2379
0.2596
0.2722
0.1951
0.2425
61.0%
0.2446
0.1305
Lame- I-lith
0.392
0.1845
0.1517
0.751
96.48
0.1941
0.311
0.3530
0.1945
0.3944
47.2%
0.3243
0.297
Despeekkrt
04424
04366
0.2179
15.25
0.5556
04814
0.3735
0.456
20.50%
0.435
Sige
012164
GPTS Chrnksquasfll
0,2013
0.7347
044250
25%
0.6858
0.5555
0,5003
0.4017
0.7216
0.3365
0,5403
0.9522
7.4%
04151
0.4912
0.6847
0.2218
0.5957
0.6687
14.5%
0,5530
0.5052
CEapb-CA (Uhes)
Coop--CDD-SS (SIF
7,7295
0.7265
0.8735
0.4411
2.4%
06554
0,7830
0.0988
117270
9.5851
4.5%
0,6318
019025
GrapE-CAD (SAPCL)
0
0,743
8.5546
BL6R3
2,0%
0.6093
8,9015
0.7695
0.7590
0.6057
0,7114
2.5%
8.677
0,8943
SAPCI, vz SPT
65 295911
(2.179)))
(17 (1771887)
(7.00951)
(2 (2.76871)
(15 1398
(103929
(6 00981)
(1.1991)
(6. 16.99577
(144911
(1) (11469) 1)
Implementation Details. We select Qwen3-8B (Ynng et al. 2025) as the backbone for all three models within the Graph-CAD framework and employed the Low-Rank Adaptation (LoRA) method (Hu et al., 2022) with rank of 64 for efficient fine-tuning. Our model is trained via iterative SAPCL rounds. Each round consists of two phases: a data synthesis phase (SAPCE) and a fine-tuning phase (SFT). In the SAPCE phase, we sample 1 1% of the training set as seed examples and generate 20 new data instances per seed, a process that takes approximately 30 hours. Subsequently, in the SFT phase, the model is fine-tuned on the newly augmented dataset for epochs on two Nvidia A800-80GB GPUs, which takes approximately 3 days. The entire SAPCL cycle is repeated for four iterations to progressively enhance the model's capabilities.
Baselines. Our evaluation primarily considers two categories of baseline models. The first category in- cludes open-source models specifically designed for the Text-toCCAD task (Khan et al.) 2024b Du et al. 2024]. For these baselines, we use the officially provided weights for evaluation. The second category com- prises general-purposee
LLMs that have acquired some CAD-related knowledge during their pre-training phase (Yang al. 2025 Dubey et al.) 2024, Guo et al.) 2025 Comanici et al.) 2025 OpenAl 2025 An- thropic 2025). And for GPT-5, Claude-opus-4.1 2.5 DeepSeek-RI, and Plus- we enable their official reasoning or thinking modes during inference. To evaluate the effectiveness of the Graph-CAD framework, we leverage these models to perform few-shot, three-stage inference, generating a geometric decomposition graph and an action sequence as intermediate representations to guide the final bpy code generation.
4.2 PERFORMANCE COMPARISTON WITH EXISTING METHODS
Quantitative Comparison Results. We evaluated all methods on CADBench, with quantitative results summarized in Table 2 Our Graph-CAD (SAPCL) model, trained with StructureAwwaee Progressive Cur- riculum Learning, achieves the best performance across all metrics. By learning to first generate structured geometric decomposition, our model generalizes more effectively to unseen and complex instructions than all baseline methods. This strong OOD performance indicates that our model has learned more robust and generalizable approach to solving Text-to-CAr tasks.
In addition, evidenced in Table [ key observation emerges when general-purpose LLMs (c.g., GPT- 5. Claude-opus-4-1) are guided through our three-stage inference process using two-shot examples: their Geometric Constraint Satisfaction (GCS) scores improve substantially compared direct end-to-end gen- eration. This gain in structural correctness is achieved while maintaining comparable, and in some cases better, performance visual metrics like Attr. and Avg., underscoring the general utility of the Graph-CAD
7

---

Published as conference paper ICLR 2026
Tex1CAD
BlandrLLM
(c2e)
GPT-5
-pu----opu--111
Claude-opus-t11 (3 stages)
Ouss
(SAPCL)
(3 stages)
(e2c)
Let's design convertible bed...
Let's create hand saw
Design a 3D model hellcopter.....
Figure 4: Qualitative results of Graph-CAD and baseline methods the CADBench. Our method generates more geometrically plausible models that better align with user instructions compared to baseline methods.
framework. By employing an explicit geometric decomposition graph and an action sequence as intermedi- ate representations, our framework provides more reliable pathway for generating CAD models with valid geometric constraints, benefit that extends to general-purpose purpose models in few-shot setting. Qualitative Comparison Results. Figure 4 presents a visual comparison of the outputs from our model and baselines the CADBench benchmark. Our Graph-CAD (SAPCL) model generates CAD models with higher visual quality and more plausible geometric constraints, closely matching the user instructions. This highlights the joint effectiveness of our Graph-CAD framework and the SAPCL mechanism. Further insight comes from comparing GPT-5 under end-to-end and three-stage settings: the latter always yields more orderly and geometrically coherent part arrangements. similar improvement is observed with Claude-opus-4-1, These results collectively validate its robustness in producing well-structured CAD models.
4.3 ABLATION STUDIES
4.3.1
THREE-STAAE PIPELINE OF GRAPH-CAD
To evaluate the effectiveness of the core stages in Graph-CAD, we conduct ablation studies under the SFT setting, as graph-free variants cannot undergo our SAPCL mechanism. The quantitative results are sum- marized in Table 3 and representative qualitative comparisons are shown in Figure Overall, the full three-stage Graph-CAt CAD (SFT) achieves the best performance across all metrics, especially in terms of GCS and code executability, while incurring only a moderate increase in inference time. In Figure Graph-CAr CAD (SFT) produces coherent, visually plausible assemblies that satisfy the instructions, whereas the ablated variants exhibit typical failure modes such as assembly errors, unreasonable shapes, or even invalid code. A detailed analysis of the inference time trade-off is provided in the Appendix
Effect of the graph representations. To explore the effect of the geometric graph, we compare the full Graph-CAD (SFT) model against the End-to-end baseline and the two-stage variant without graph decompo- sition (w/o Graph Decom.). The End-to-end baseline performs worst, which suggests that lacking structured intermediate representation hinders expressivity. While the (w/o Graph Decom.) variant provides modest gains, it still remains substantially lower than our full approach, highlighting that the graph representations are essential for capturing structural relationships and guiding coherent generation. For more quantitative and qualitative analysis the graph represtion, please refer the Appendix D.8
Effect of the Action Planning. To investigate the effect the Action Planning stage, we compare the full model with two-stage variant that removes action planning (w/o Action Planning). The result shows that it
8

---

Published as conference paper ICLR 2026
End-to-end
w/o Graph Decom.
w/o Action Planning
Graph-CAD (SFT)
Let's create 3D model of a bookshelf with an attached ladder.....
Assembly error
Assembly error
Could you create a coffee machine with sleek design?....
Unrensonable shape
Unreasonable shape
Syntax
Design cargo clevator with rectangular platform....
Assembly errur
Unreasonable shape
Unreasonable shupe
Assembly crror
Figure 5: Qualitative comparison of ablated variants. For three CADBench prompts, show results from the end-to-end baseline, w/o Graph Decom., w/o Action Planning, and the full Graph-CAD (SFT). Red marks indicate typical failures (assembly errors, unreasonable shapes, syntax errors), while Graph-CAD produces coherent assemblies that better follow the instructions.
leads to clear drop in performance, especially in (Inst.) and (Esyntaz), underscoring that explicitly planning the conversion from non-linear graph a sequential program essential for producing executable code.
4.3.2 STRUCTURE-AWARE PROGRESSIVE CURRICULUM LEARNING
To evaluate the effect of the SAPCL mechanism, we conduct ablation studies under the full model setting and provide a set of evaluation protocols and metrics to assess graph-mediated CAD generation methods.
Effect of different difficulty curriculum designs. To explore the impact different levels of difficulty, we compare our SAPCL mechanism with two baselines: one without curriculum learning (Only SFT) and an- other that expands the training set by randomly rephrasing instructions without difficulty grading (w/o Hier- archical Difficulty), following BlenderLLM''s self-improvement approach (Du et al. (2024). Under matched data volumes per iteration (Figure ()). SAPCL consistently outperforms both baselines overall accu- racy on CADBench (F a)). Detailed analysis using our proposed evaluation metrics: NLA, HLA. and GCS confirm greater gains in all structural aspects of the intermediate graph representations (Figure b-bd)). geometric decomposition quality in any graph-mediated Text-
These metrics offer intuitive way to-CAD approach. Furthermore, as training advances, SAPCL enhances the model's capacity to process complex instructions, indicated by rising number and proportion of generated hard samples (Figure (()).
9

---

Published as a conference paper ICLR 2026
Table 3: Ablation study of our pipeline components, evaluated on the CADBench using the SFT setting. We compare our three-stage pipeline against an End-to-end baseline. To isolate the impact of each intermediate representation, we also evaluate two two-stage variants: w/o Graph Decom., which omits the graph by generating action sequence directly from the instruction; and w/o Action Planning, which omits the
action sequence by generating code directly from the graph. CLIP measures global text-shape semantic alignment, and Time reports the average inference time per sample. Best results in bold.
CADResch-Sin
CADRemch-Wil
Training pipeline
Time
Attr1
Syul.1
Inst.1
Avg.1
Exgetel
CLIP
GC51
Attr|
Spul.1
Ins..
Avg.1
Exyster
CLIP
GCS
End end
0.6701
0.6522
0.3477
0.5573
5.8%
0.5381
0.692
0.6785
0.6645
0.4268
0.5899
8.0%
0.6067
0,7012
64.861
wio Gruph Decoo..
0.6942
0.0955
0.4561
0.6166
5.0%
0.6424
0.7208
0.6730
0.7125
0.5018
BA290
6.5%
0.6164
0.7207
79,516
who Action Planning
0,6791
0.6825
0,4006
0.5874
6.1%
0.5405
0.7545
0.6735
0.6849
0.4502
0.6029
11.0%
0.6127
0,7451
91,830
Gragh-CAAM CAD (SFT)
0.7295
0.7265
0.473
0.6431
22%
0.6544
0.7830
0.6944
0.7270
0.5861
0.6922
4,5%
0.6358
0.8025
104.755
[n] Acc. vo. Iter.
(b) NLA ve. Iter.
[4] HLL vs. ttec
(4) GCS vs. fee..
3160
All
5177
All Hemee Difuuty
Ony STT fetrrcace offecly
3100
310
Ernnion 10
nwnttio 01
Recation
teariin 01
(4) Capabiitty Boundary vs. Iter.
(f) Data Growth va, iter.
(g) Sampling Propertion va, Acc. & Tims
(h) Generation per Seed va, Atc. & Time
Easy
klam
045
Taning
tarat on It)
Itraat on ID
Samplng Prosontinn (k)
Conerated for arts Seed Instance
Figure 6: Detailed visualization analysis of the SAPCL mechanism.
Effect of the Auxilary model. We analyze the effectiveness of the auxiliary model in capability boundary exploration by comparing our full method against a variant that omits this component. As shown in Figure o(a), the variant without the auxiliary model (w/o Auxilary) achieves lower overall accuracy and exhibits a slower improvement rate across training iterations, confirming its importance in efficient model progression.
Effect of hyperparameters in SAPCL. We examine two key hyperparameters in SAPCL: the sampling proportion for Exploration of Capability Boundary module and the number of new instances generated per seed in the Boundary Data Generation module. As shown in Figure ([g) and (h), increasing either hyperparameter improves final performance but linearly increases training time. To balance effectiveness and
efficiency, we set the sampling proportion to I % and generated 20 instances per seed in all main experiments.
5 CONCLUSION
We propose learning a graph-based intermediate representation that explicitly models assembly hierarchy and geometric constraints. This representation acts as a structural prior, narrowing the search space to im- prove both geometric fidelity and constraint satisfaction. We further introduce a structure-aware progressive curriculum learning boost the model's robustness boundary and augmenting training with new, filtered examples at this boundary. To support this research, we provide the BlendGeo dataset with 12K examples and novel metrics for evaluating the fidelity of the interme- diate graph representation. Experiments on public benchmark CADBench demonstrate that our graph-based approach and curriculum strategy significantly outperform existing methods.
complex assemblies by identifying its capability
10

---

Published as a conference paper ICLR 2026
6 ETHICS STATEMENT
The research presented in this paper focuses on the generation of Computer-Aide Design (CAD) models, a highly specialized domain. The inherent nature of this task minimizes the risk of misuse, as the devel- oped methods are intended to primarily benefit professional design and engineering workflows. Our dataset, BlendGeo, is derived from publicly available academic benchmarks, and we intend to release it responsibly foster reproducible research and further innovation in the field. This work involved human participation in two capacities: professional industrial designers for the validation and correction of our annotated dataset, voluntary. For the user study,
and experienced volunteers for our final user study. All participation we obtained informed consent from all participants before they began the evaluation. We conducted all numan-involved activities in accordance with established ethical guidelines, ensuring that participants were treated fairly, respectfully, and safely throughout the process. To protect their privacy, no personally iden- tifiable information was collected from any participant. The data gathered from these activities, including the designers' corrections and the volunteers' evaluation scores, were used solely for the research purpose of developing and validating CAD generation techniques.
7 REPRODUCIBILITY STATEMENT
We have made every effort to ensure the reproducibility of our research. Our Graph-CAD framework detailed in Section 3 and the core Structure- Aware Progressive Curriculum Learning (SAPCL) mechanism is formalized with pseudocode in Appendix C.2 All implementation details, including model architecture and training hyperparameters for both the SFT and SAPCL phases, are provided in the Experimental Setup Appendix C.T, and all prompts used for data generation and evaluation are listed in Appendix E. The precise formulations for our proposed evaluation metrics (GCS, NLA, HLA) are also detailed in the Appendix C.4 To facilitate direct replication and further research, will release source code, the BlendGeo dataset, and model checkpoints upon publication, contributing to the open-source community.
(Section [.1]. The annotation pipeline for our BlendGeo dataset is described
8 ACKNOWLEDGEMENTS
This work was supported by National Natural Science Foundation of China (No.62576139, 62176093). National Key Research and Development Program of China NN..2023YFC3502900
REFERENCES
Kamel Alrashedy, Pradyumna Tambwekar, Zulfiqar Zaidi, Megan Langwasser, Wei Xu, and Matthew Gom- bolay. Generating cad code with vision-language models for 3d designs. arXiv preprint arXv::2400005340 2024.
Anthropic.
Claude opus 4.1. httpss//wwwwaattrrrg.ccccc/c//es 2025. Official an- nouncement and model overview.
Akshay Badagabettu, Sai Sravan Yarlagadda, and Amir Barati Farimani. Query2cad: Generating cad models using natural language queries. arXiv preprint 10XXv:240660014444 2024.
Matej Balog, Alexander L Gaunt, Mare Brockschmidt, Sebastian Nowozin, and Daniel Tarlow, Deepcoder: Learning to write programs. arXiv preprint 1=X.::6611.0988, 2016.
Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceed- ings of the 26th annual international conference on machine learning, pp. 41-48, 2009.
11

---

Published as a conference paper ICLR 2026
Shijie Bian, Daniele Grandi, Kaveh Hassani, Elliot Sadler, Bodia Borijin, Axel Fernandes, Andrew Wang, Thomas Lu, Richard Otis, Nhut Ho, et al. Material prediction for design automation using graph rep- resentation learning. In International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, volume 86229, pp. V03AT03A001. American Society of Me- chanical Engineers, 2022.
Shijie Bian, Daniele Grandi, Tianyang Liu, Pradeep Kumar Jayaraman, Karl Willis, Elliot Sadler, Bodia Borijin, Thomas Lu, Richard Otis, Nhut Ho, et al. Hg-cad: hierarchical graph learning for material prediction and recommendation in computer-aided design. Journal Computing and Information Science in Engineering, 24(1):01 1007, 2024.
Marc Brockschmidt, Miltiadis Allamanis, Alexander I. Gaunt, and Oleksandr Polozov. Generative code modeling with graphs. arXiv preprint 0rXiv:1805.084900 2018.
Rudy Bunel, Matthew Hausknecht, Jacob Devlin, Rishabh Singh, and Pushmeet Kohli. Leveraging grammar and reinforcement learning for neural program synthesis. arXiv preprint 1xXiv:1805.04276 2018.
Tianle Cai, Yuhong Li, Zhengyang Geng, Hongwu Peng, Jason D Lee, Deming Chen, and Tri Dao. Medusa: Simple 11m inference acceleration framework with multiple decoding heads. arXiv preprint arXiv:2401.10774, 2024.
Cheng Chen, Jiacheng Wei, Tianrun Chen, Chi Zhang, Xiaofeng Yang. Shangzhan Zhang, Bingchen Yang, Chuan-Sheng Foo, Guosheng Lin, Qixing Huang, et al. Cadcrafter: Generating computer-aided design models from unconstrained images. In Proceedings of the Computer Vision and Pattern Recognition Conference, pp. 11073-11082 2025.
Jingye Chen, Yupan Huang, Tengchao Lv, Lei Cui, Qifeng Chen, and Furu Wei. Textdiffuser: Diffusion models as text painters. Advances in Neural Information Processing Systems, 36:9353-9338 9387, 2023.
Xinyun Chen, Chang Liu, and Dawn Song. Execution-guiie guided neural program synthesis. In International Conference on Learning Representations, 2018
Gheorghe Comanici, Eric Bieber, Mike Schackermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, Marcel Blistein, Ori Ram, Dan Zhang, Evan Rosen, et al. Gemini 2.5: Pushing the frontier with ad- vanced reasoning, multimodality, long context, and next generation agentic capabilities. arXiv preprint arXiv:2507.06261. 2025.
Florinel-Alin Croitoru, Vlad Hondru, Radu Tudor Ionescu, Nicu Sebe, and Mubarak Shah. Curriculum direct preference optimization for diffusion and consistency models. In Proceedings of the Computer Vision and Pattern Recognition Conference, pp.
2025.
Gang Dai, Yifan Zhang, Qingfeng Wang, Qing Du Zhuliang Yu, Zhuoman Liu, and Shuangping Huang. Disentangling writer and character styles for handwriting generation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 5977-5986, 2023.
Gang Dai, Yifan Zhang, Quhui Ke, Qiangya Guo, and Shuangping Huang. One-dm: One-shot diffusion mimicker for handwritten text generation. In European Conference on Computer Vision, pp. 410-427. Springer, 2024.
Gang Dai, Yifan Zhang, Yutao Qin, Qiangya Guo, Shuangping Huang, and Shuicheng Yan. Beyond isolated words: Diffusion brush for handwritten text-line generation. In Proceedings of the IEEE/CVF Interna- tional Conference Computer Vision, pp. 19054-19064, 2025.
12

---

Published as a conference paper ICLR 2026
Yuhao Du, Shunian Chen, Wenbo Zan, Peizhao Li, Mingxuan Wang, Dingjie Song, Bo Li, Yan Hu, and Benyou Wang. Blenderllm: Training large language models for computer-aided design with self- improvement. arXiv preprint vrXiv:2412.14203, 2024.
Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models. arXiv e-prints, pp. arXiv-2407, 2024.
Shengjie Gong and Xinwei Zheng. Enhancing feature extraction in dbnet: novel approach with squeeze- and-excitation block and cham module. In 2023 IEEE 5th International Conference on Civil Aviation Safety and Information Technology (ICCASIT), pp. 136-142. IEEE, 2023.
Shengjie Gong, Lingxiao Huang, Shuangping Huang, Yuyi Wang, Zhiqi Wang, Tao Xiao, Xiang Yan, and Chunxue Yang. A unified framework of multi-stage multi-winner voting: An axiomatic exploration. In International Conference on Mathematical Optimization Theory and Operations Research, pp. 349-373. Springer, 2024.
Shengjie Gong, Haojie Li, Jiapeng Tang, Dongming Hu, Shuangping Huang, Hao Chen, Tianshui Chen, and Zhuoman Liu. Monocular and generalizable gaussian talking head animation. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp.
2025.
Yandong Guan, Xilin Wang, Xingxi Ming, Jing Zhang, Dong Xu, and Qian Yu. Cad-coder: Text-to-cad and geometric reward. arXiv preprint 2xXv:25005.19713 2025.
generation with
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in ilms via reinforcement learning, arXiv preprint arXiv:2501. 2025.
Qiangya Guo, Gang Dai, Zhuoman Liu, Shuangping Huang, Yunging Hu, Huiyuan Zhang, and Tianshui Chen. Plan then act: Bi-level cad command sequence generation. The Fourteenth International Con- ference on Learning Representations.
Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. Lora: Low-rank adaptation of large language models. ICLR, 1(2::3, 2022.
Mohammad Sadil Khan, Elona Dupont, Sk Aziz Ali, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. Cad-signet: Cad language inference from point clouds using layer-wise sketch instance guided attention. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp- 4713-4722, 2024a.
Mohammad Sadil Khan, Sankalp Sinha, Talha Uddin, Didier Stricker, Sk Aziz Ali, and Muhammad Zeshan Afzal. Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. Advances in Neural Information Processing Systems, 37:7552-7579, 2024b.
Jin- Young Kim, Hyojun Go, Soonwoo Kwon, and Myun-Gyoon Kim. Denoising task difficulty- cur- riculum for training diffusion models. arXiv preprint arXiv:2403. 10348, 2024.
M Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models. Advances in neural information processing systems, 2010.
13

---

Published as a conference paper ICLR 2026
Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph Gonza- lez, Hao Zhang, and Ion Stoica. Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th symposium on operating systems principles, pp. 126, 2023.
Yaniv Leviathan, Matan Kalman, and Yossi Matias. Fast inference from transformers via speculative decod- ing. In International Conference on Machine Learning, pp. 19274-19286. PMLR, 2023.
Xucyang Li, Yu Song, Yunzhong Lou, and Xiangdong Zhou. Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. In Proceedings of the 32nd ACM International Conference Multimedia, pp. 8461-8470, 2024.
Jianxing Liao, Junyan Xu, Yatao Sun, Maowen Tang, Sicheng He, Jingxian Liao, Shui Yu, Yun Li, and Hongguan Xiao. Automated cad modeling sequence generation from text descriptions via transformer- based large language models. arXiv preprint arXiv:2505. 19490, 2025.
Bo Liu, Xingchao Liu, Xiaojie Jin, Peter Stone, and Qiang Liu. Conflict-averse gradient descent for multi- task learning. Advances Neural Information Processing Systems, 11118888881000 2021.
Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforce- ment learning. Advances in neural information processing systems, 31, 2018.
Sanmit Narvekar, Bei Peng, Matteo Leonetti, Jivko Sinapov, Matthew E Taylor, and Peter Stone. Curriculum learning for reinforcement learning domains: A framework and survey. Journal of Machine Learning Research, 21(181):1-50, 2020.
OpenAL. Gpt-5 system card. hnttps://cdn openai com/ wttpggptssstttteardd.... pdf 2025, Official system card describing GPT-5 architecture, routing, and safety evaluations.
Ronald Parr and Stuart Russell. Reinforcement learning with hierarchies of machines. Advances in neural information processing systems, 10, 1997.
Rémy Portelas, Cédric Colas, Lilian Weng, Katja Hofmann, and Pierre-Y Yves Oudeyer. Automatic curricu- lum learning for deep rl: A short survey. arXiv preprint arXiv:2003. 046664 2020.
Aditya Sanghi, Pradeep Kumar Jayaraman, Arianna Rampini, Joseph Lambourne, Hooman Shayami, Evan Atherton, and Saeid Asgari Taghanaki. Sketch-a-shape: Zero-shot sketch-to-3d shape generation. arXiv preprint Niiv:2307.038666 2023.
Petru Soviany, Radu Tudor Ionescu, Paolo Rota, and Nicu Sebe. Curriculum learning: A survey, Interna- tional Journal of Computer Vision, 130(6):1526 1565, 2022.
Mitchell Stern, Noam Shazeer, and Jakob Uszkoreit. Blockwise parallel decoding for deep autoregressive models. Advances in Neural Information Processing Systems, 31, 2018.
Ruiyu Wang, Yu Yuan, Shizhao Sun, and Jiang Bian, Text-to-cad generation through infusing visual feed- back in large language models. arXiv preprint arXiv:2501.19054, 2025a.
Siyu Wang, Cailian Chen, Xinyi Le. Qimin Xu, Lei Xu, Yanzhou Zhang, and Jie Yang. Cad-gpt: Synthe- sising cad construction sequence with spatial reasoning-enhance multimodal 1lms. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp. 7880-7888, 2025b.
Xin Wang, Yudong Chen, and Wenwu Zhu. A survey on curriculum learning. JEEE transactions on pattern analysis and machine intelligence, 44(9):5555 4576, 2021.
14

---

Published as conference paper ICLR 2026
Rundi Wu, Chang Xiao, and Changxi Zheng. Deepead: A deep generative network for computer-aided design models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 6772- 6782, 2021.
Haoyang Xie and Feng Text-to-cadquery: new paradigm for cad generation with scalable large model capabilities. arXiv preprint arXiv:2505.066: 066077 2025.
Zhihao Xu, Shengjie Gong, Jiapeng Tang, Lingyu Liang, Yining Huang. Haojie Li, and Shuangping Huang. Kmtalk: Speech-driven 3d facial animation with key motion embedding. In European Conference on Computer Vision, pp. 233-253. Springer, 2024.
An Yang, Anfeng Li, Baosong Yang. Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388 2025.
Tianhe Yu, Saurabh Kumar, Abhishek Gupta, Sergey Levine, Karol Hausman, and Chelsea Finn. Gradient surgery for multi-task learning. Advances neural information processing systems, 33:5824-5836, 2020.
Zhanwei Zhang, Shizhao Sun, Wenxiao Wang, Deng Cai, and Jiang Bian. Flexcad: Unified and versatile controllable cad generation with fine-tuned large language models. arXiv preprint 1..522 2024.
Zhiyuan Zhang, Xiaofan Li, Zhihao Xu, Wenjie Peng, Zijian Zhou, Miaojing Shi, and Shuangping Huang. Mpdrive: Improving spatial understanding with marker-based prompt learning for autonomous driving. In Proceedings of the Computer Vision and Pattern Recognition Conference, pp. 12089-12099, 2025.
Yaowei Zheng, Richong Zhang, Junhao Zhang. Yanhan Ye, Zheyan Luo, Zhangehi Feng, and Yongqiang Ma. Llamafactory: Unified efficient fine-tuning of 100+ language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrationsi, Bangkok, Thailand, 2024. Association for Computational Linguistics. URL http: http:://aaww...ogabb//////s/ wttp.or/////...//////////// 13372
Jin Zhong, Jinglin Liang, Tongtong Yang. Shuangping Huang, and Hanlin Gu. Llcot: A privacy-cnhancing offsite tuning framework via loss landscape elevation.
APPENDIX
Considering the space limitation of the main paper, we provide more results and discussion in this appendix, which is organized follows:
Section
A
Use of Large Language Models
Section
B
Limitations
Section
Additional Methodology Details
Sec. C.1
Data Annotation For Geometric Decomposition
Sec.
Structure- Awarte Progressive Curriculum Leamingg
Sec.
C.3
More Implementation Details of SFT
Sec.
More Details of Metrics
Sec.
Analysis of Parameter Efficiency
Sec.
Graph Representations CAD and Relation to This Work
Section D
Addiioonal Results
Sec. D.I
Human Evaluation
15

---

Published as a conference paper ICLR 2026
Sec.
D.2
Additional Qualitative Results
Sec. D.3
Visualization Progressive Improvement with SAPCL
Sec. D.4
Validation of VLM-based Evaluation
Sec. D.5
Impact Few-Shot Examples on General LLMs
Sec. D.6
Effect of Different Base Models
Sec. D.7
Comparison with Sketch-and and-Extrude Methods
Sec. D.8
Effect of Graph Representation under Varying Object Complexity
Sec.
D.9
Captioning Cost and Comparison with Open-Source LVLMs
Sec. D.
10
Comparison with Unified Single Model
Sec. D.11
Annotation Accuracy and Typical Failure Cases
Section E
The Prompts Used in the Experiment
Sec.
E.
Prompt for the VIM Evaluator
Sec.
E.2
Prompt for the Problem Generator
Sec.
Prompt for Geometry Decomposition
Sec.
Prompt for Action Planning
Sec.
Prompt for Code Generation
Section F
Illustrative Data Example
A USE OF LARGE LANGUAGE MODELS
In the preparation of this manuscript, we utilized large language model (LLM), specifically GPT-5 (Ope- nAI 2025). as a writing assistant. The role of the LLM was strictly limited to language enhancement and did not extend to any aspect of the rescarch ideation scientific methodology. Our process involved providing the LLM with drafts, specific sentences, or high-level concepts already formulated by the au- thors. We then used the model's outputs refine sentence structure, improve clarity and fluency, and ensure grammatical correctness in the final English text. is important to state explicitly that all core scientific contributions-innluudnn the formulation of the graph-structured geometric decomposition, the design of the structure-aware progressive curriculum learning mechanism, the experimental design, and the analysis and interpretation of results are solely the work of the human authors. The LLM was not used generate scientific claims, hypotheses, or conclusions. In accordance with ICLR policy, the authors have meticulously reviewed, edited, and validated all content this paper. We take full responsibility for the final manuscript, including its scientific accuracy and integrity.
B LIMITATIONS
Inference Time. Our three stage inference sequentially predicts a structure graph, an action plan, and executable code. This increases the number of generated tokens and leads to an average inference time of about 1.7 minutes per sample, which is longer than the subminute times reported for models such as BlenderLLM (Du et al. 2024). The detailed average inference time on CADBench is reported in Table 4 In the context of CAD authoring this latency is small relative to typical design iteration and is offset by higher geometric fidelity and better constraint satisfaction, which reduce downstream edits and additional regeneration. In practice, the overall time to usable model is often lower than when faster method produces an output that requires extensive manual correction. We did not target latency optimization in this work, and complementary techniques including efficient management of key and value cache to support larger batch sizes (Kwon et al. (2023). speculative or blockwise parallel decoding that proposes and verifies multiple tokens per step (Leviathan
further reduce runtime without changing the core approach,
16

---

Published as a conference paper ICLR 2026
Table 4: Inference time breakdown of different pipeline variants. Stagel, Stage2, and Stage3 correspond to the three components of our Graph-CAD inference pipeline. Total time is the sum of the stages used by each method.
Training pipeline
Stage1 I (s)
Stage2 (s)
Stage3 (s)
Total (s)
End-to-end
64,861
w/o Graph Decom
12.603
66.913
79,516
w/o Action Planning
25.549 24.345
66.281
91.830
Graph- CAD (SFT)
15.141
65.269
104.755
et al., 2023 Stern al. 2018 Cai et al. 2024). and knowledge distillation to compact backbones (Hinton
et al. 2015
Failure Cases and Model Scalability. As shown in Figure our method can struggle to generate assemblies with extremely complex geometric structures. This limitation primarily stems from two factors: the inherent capabilities the current LLM backbones and the scarcity publicly available training data for such highly sophisticated designs. We posit that this is not fundamental flaw in our graph-based approach but rather reflection of the current resources available. The framework itself is designed to be scalable. As more powerful base models are developed and more diverse, complex CAD datasets become available, anticipate that the performance of our framework on these challenging cases will naturally improve. Future work will foeus exploring these scaling properties and curating more complex datasets further push the boundaries of automated CAD generation. Beyond these scaling considerations, practical deployment in real industrial settings also requires stronger privacy protection for sensitive domain data, which we view as an important direction for future extensions of this work (Zhong et al.).
C ADDITIONAL METHODOLOGY DETAILS
C.I DATA ANNOTATION FOR GEOMETRIC DECOMPOSITION
To support the training and evaluation of our three-stage Graph-CAD framework, we meticulously con- structed BlendGeo dataset that contains I2K quadruplets of user instructions, geometric decomposition graphs, action sequences, and executable bpy code. The overall data construction pipeline is illustrated in Figure In the Data Generation stage, designed three distinct prompt sets, one for each stage of the Graph-CAD framework, to guide LLM-based data generation. Specifically, the Geometry Decomposition Prompt formalizes the principles of top-down geometric decomposition, rules for establishing geometric constraints between nodes, and structural specifications for the output text format. The Action Planning Prompt specifies how convert a geometric decomposition graph into a CAD operation sequence, while the Code Generation Prompt defines translation rules from actions to bpy code, along with standard func- tion definitions. Subsequently, we extracted 12K user instructions spanning 1.4K object categories from the BlendNet (Du et al.) (024). Using an LLM (e.g., GPT-5), we applied stage-specific prompts to perform the three-stage conversions, thereby generating preliminary quadruplets.
In the Data Validation stage, we employed a dual human-AI verification pipeline to ensure high-quality generated data. The generated bpy code for each instance was executed Blender, producing four dis- tinct multi-view rendered images. A Vision-Language Model (VLM) (c.g.. GPT-5) then evaluated whether these renderings semantically matched the original user instructions. The samples approved by the VLM further validated by professional industrial designers guarantee absolute accuracy. Those samples that failed the VLM evaluation were comprehensively corrected by designers, who synchronously rectified the geometric decomposition graph, action sequence, and bpy code. Ultimately, these rigorously validated
17

---

Published as a conference paper ICLR 2026
have been trying to model ant queen. can you help me to make this 3D model?
Help me please, create bike with round grap.
aa)
(b)
Figure 7: Examples of Failure Cases on Highly Complex Geometries. This figure illustrates current limi- tations of our method when tasked with generating objects with extremely intricate structures. (a) An "ant queen" model, which requires complex, organic curves and high part count. (b) A "bicycle" model, which involves a large number of parts with precise mechanical and transmission-related constraints. both cases, while the model attempts capture the overall form, struggles with the fine-grained geometric details and the complex inter-part relationships, leading to structural errors. These failures highlight the need for more powerful base models and more diverse, complex training data.
samples, originating from the BlendNet instructions, form the BlendGeo dataset. Furthermore, to enable rigorous evaluation of geometric decomposition graph accuracy and geometric constraint satisfaction, we applied this same annotation pipeline to the CADBench benchmark (Du et al. 2024).
C.2 STRUCTURE-AWARE PROGRESSIVE CURRICULUM LEARNING
To provide a detailed, step-by-step specification our training strategy, we present the pseudocode for the Structure-Aware Progressive Curriculum Learning (SAPCL) mechanism in Algorithm The algorithm for- malizes the iterative process described in the main text, which alternates between Supervised Fine-Tuning (SFT) and Structure-Aware Progressive Curriculum Exploration (SAPCE). It provides concrete imple- mentation for the key procedures within the SAPCE module, including the sampling of seed exemplars, the generation of graded problem variants, the identification of the model's capability boundary using Discriminator, and the synthesis of new data at this frontier.
C.3 MORE IMPLEMENTATION DETAILS OF SFT
We selected Qwen3-8B Yangg al. 2025
the backbone for all three models within the Graph-CAD framework, utilizing a maximum token length of 8192. For efficient fine-tuning, we employed the Low- Rank Adaptation (LoRA) method (Hu et al. 2022 within the LLamaFactory training framework (Zheng
18

---

Published as a conference paper ICLR 2026
Data Generation
Goomary lesorppatton Prorqe
Planing Perept
Cock Geterttin Proceee
PV </>
LLM
LLM
LLM
BlenderL.1.M
User Instruction
Geometry Decompusition
Action Sequence
Byy Code
Danaser
Data Validation
Manual Confirmation
NOWWED
VLM
Manual Mediffiction
Multiviiw
Blander
Dataset
Verified divta
Renderings
Figure 8: Data annotation pipeline. Our annotation process begins with user instructions sourced from the BlenderLLM dataset. It proceeds through a three-stage generation workflow, where distinct prompts guide a LLM to sequentially produce geometric decomposition graphs, action sequences, and executable bpy code. Subsequently, a VLM evaluates whether the multi-view renderings generated from the bpy code align with the original instructions. Finally, industrial designers perform second round of verification, reviewing the VLM's judgments, confirming correct samples, and refining erroneous ones. The validated quadruplets are then integrated into our dataset.
et al., 2024). using hyperparameters rank = 64. Each model was trained on two Nvidia A800-80GB GPUs. We set the batch size with gradient accumulation steps of 8, and learning rate of x.0 10-4 Training proceeded for 7 epochs, taking approximately 3 days. The model weights that achieved the lowest validation loss were selected the optimal weights.
C.4 MORE DETAILS OF METRICS
CADBench metrics. We adopt the CADBench metries introduced in BlenderL.LM (Du et al. 2024 for open-ended CAD generation from text. The benchmark decomposes evaluation into three complementary dimensions tailored to CAD renderings: Attr. (object-attribute accuracy), Spat. (spatial-relation accuracy), and Inst. (instruction-followii)) verified criteria covering one-grained sub-dimensions (e.g., color/material/size for attributes; relative place- ment, contact, alignment and symmetry for spatial relations; and faithfulness to user specispe operations for instruction following). For every criterion, a binary score is produced by an MLLM-as-judge, using both the multi-view renders (four views per object) and, where appropriate, the generated script itself (script-based checks are used for objective properties that are hard to judge visually). Sub-dimension scores are averaged into dimension score. and the Avg. column reports the uniform average over the three dimensions, yielding an overall fidelity measure. In addition, we report the syntax eтror rate Esynixx defined as the proportion of generated scripts that fail to execute to valid rendering, which captures robustness and executability of the outputs. For completeness, CADBench is instantiated on two test suites CADBench-SS and CADBench-
accuracy). Concretely, each test prompt is paired with set of human-
(synthetic) (real, out-of-distribution forum questions)-and scores are computed separately on each. This protocol yields multi-dimensional, execution-grounded assessments that align well with human judgments while remaining scalable and reproducible.
Geometric Constraint Satisfaction (GCS). Beyond visual fidelity, developed novel metric to evaluate the structural integrity of the generated models, which we term Geometric Constraint Satisfaction (GCS). This metric assesses whether CAD model's structure satisfies common geometric constraints (e.g., table- top must be above and contact with the top surface of its legs). For this purpose, we manually annotated approximately 500 geometric constraint ground truths across 280 samples from the CADBench test set that
19

---

Published as a conference paper at ICLR 2026
feature common geometric relationships. During evaluation, we first extract the name and geometric pa- rameters (e.g., bounding box, position, rotation) of each CAD part within Blender. An LLM is then used to map these part names to the corresponding names in our evaluation standards (e.g., table surface might be named 'table_top." "table_base or "base".. Finally, numerical computations determine if these mapped parts satisfy the specified geometric constraints, yielding a score of or for each constraint. For every sample, an average score is computed across all its geometric constraints represent its GCS score. The final GCS metric for the model is the average of these scores across all evaluated samples.
Node-Level Accuracy (NLA) and Hierarchy- Accuracy (HLA), To assess the correctness of gener- ated geometric decomposition graphs, we introduce two dedicated metrics: NLA and HLA. NLA evaluates whether the system identifies the correct set of parts under one-to-one correspondence with ground truth. Concretely, we first build an Ll-based cost matrix per class (size, position, orientation, and optional at- tributes; see Algorithm 2), then apply LLM-guided aliasing to canonically rename predicted nodes the ground-truth namespace and perform class-wise Hungarian assignment (Algorithm 3). We report the mean LI assignment cost across all matched pairs as the NLA score (lower is better).
HLA, in contrast, evaluates the structural integrity of the graph by examining the parent-child relationships. This metric combines two critical checks: first, whether the predicted edges (representing relationships) between nodes are correct (Algorithm 4) and second, whether each part appears at the correct depth in the hierarchy, followed by a weighted aggregation into the final score (Algorithm
This metric combines two critical checks: first, whether the predicted edges (representing relationships) between nodes are correct, and second, whether each part appears the correct depth in the hierarchy. In summary, while NLA assesses if the model predicted the right pieces, HIA assesses if it arranged those pieces correctly.
C.5 ANALYSIS OF PARAMETER EFFICIENCY
potential consideration regarding our three-stage framework the total parameter count, as utilizes three separate models. One might hypothesize that the performance gains are a consequence of an increased num- ber of trainable parameters compared to a single end-to end-to-end model. However, a closer analysis of our training methodology suggests this is not the case.. We employ the Low-Rank Adaptation (LoRA) method (Hu et al. 2022) for efficient fine-tune -uning. With a rank of 64, the number of trainable parameters for each of our three models is approximately 174.6 million. This constitutes only 2. 13% of the total parameters of the Qwen3-8B --BB backbone (Yang et al., 2025). The total number of trainable parameters across all three models is therefore approximately 524 million, which is still a small fraction of the base model's total size and comparable or less than what a full fine-tuning of a single, smaller model might require. This high degree of parameter efficiency indicates that our framework's 's success is not attributable to a massive update of the base model's s weights. Instead, our approach effectively leverages the vast, pre-existing knowledge embedded within the L.M.. The performance improvements are derived from teaching the model to apply this knowledge within our structured, multi-stage problem-solving paradigm. Therefore, we attribute the observed gains primarily to the architectural and data-centric contributions of our work work-namely, the decoupling of the problem via the three-stage pipeline and the power of the graph-structured intermediate representation rather than to an increase in the scale of trainable parameters.
C.6 GRAPH REPRESENTATIONS IN CAD AND RELATION TO THIS WORK
few works have introduced assembly graphs into CAD, typically by constructing a part-part graph on top of an existing CAD model and using for predictive tasks such as material prediction recommenda- tion (Bian et al., 2024 2022). Compared to these assembly graphs, our hierarchical, geometry-awan graph differs in two key aspects: its source and its role in the overall pipeline.
20

---

Published as a conference paper ICLR 2026
Table Quantitative results the human evaluation. The table shows user preference scores for CAD models generated by different methods. App. indicates the preference rate based visual appearance and alignment with the user's 's instruction. GP indicates the preference rate based on the geometric plausibility of the final assembly.
BlenderL.LM
GPT-5 (c2c)
GPT-5 (3 stages)
Clunde-opus-4-1 (c2c) Clande-opus-4-1 (3 stages)
Ours (SFT)
Ours (SAPCL)
App. GP.
2.7
%
3.8 %
0.4 %
5.2 %
0,55 %
6,5 %
16.3 %
67.25 %
First, the source the graph is different. prior work, the assembly graph is a descriptive structure con- structed from pre-defined, human -pennn-de relationships within existing CAD file, and thus re-expresses information that is already present in a fully specified design. This setting is fundamentally different from Text-to-CAD, where CAD model assembly structure is available at inference time. In Graph-CAD, the hierarchical, geometry-aware graph is a learned intermediate representation that is predicted directly from natural-language instructions, before any geometry exists. It is specifically designed to bridge the gap between ambiguous text and structured CAD programs under this generative setting.
Second, the role of the graph is different. In previous work, the assembly graph serves as an analytical input to predictive model (for example, GNN) that reasons about a fixed assembly. In Graph-CAD, the graph acts as a prescriptive blueprint or structural prior that guides generation: nodes define the assembly hierarchy and part attributes, and edges represent actionable geometric constraints that the subsequent action-planning and CAD code generation stages must satisfy. The graph is thus a causal intermediate that tells the model how to build the assembly, rather than passive descriptor of an existing design.
To the best of our knowledge, this is the first work that learns a hierarchical, geometry-avee assembly graph from text and uses it as central generative constraint for CAD code generation in the Text-to-CAD setting. Our experiments show that this graph-guided formulation yields clear improvements in geometric fidelity, constraint satisfaction, and code executability over strong end-to-end LLM baselines, supporting both the novelty and the effectiveness of the proposed representation.
D ADDITIONAL RESULTS
D.1 HUMAN EVALUATION
To evaluate user preference for our method compared to the baselines, we conducted user study. The form of conducting user study refers to the papers (Xu et al. 2024; Gong et al. 2025). We recruited 40 volunteers, all with prior experience CAD design, to participate in questionnaire based evaluation. Each participant was presented with 50 randomly selected examples from our test set. The evaluation for each example was based on two criteria: how well the geometric appearance matches the user instruction (Appearance, App). and whether the model satisfies common-sense geometric constraints (Geometric Plausibility, GP). The aggregated results of this study are summarized in Table 5] indicating that our method, Graph-CAD (SAPCL), achieves the highest user-rated quality for both appearance and geometric plausibility.
D.2 ADDITIONAL QUALITATIVE RESULTS
For a more extensive qualitative comparison, we provide additional side-by-side results against baseline methods in the appendix (Figure g These examples further illustrate common failure modes in baseline outputs, such as generating misaligned parts, violating geometric constraints, or failing to capture complex assembly structures. In contrast, these results consistently show that method, Graph-CAD, produces
21

---

Published as conference paper ICLR 2026
Tex2CAD
LM
GPT-5 (e2e)
GPT-5 stages)
Clusde-opus-411
Claude Cluude-opus-411 stages)
Ours (SFT)
Ours (SAPCL)
Design an armehair......
Could you create 3D model bedside table?
Can you help me to model an airplane, basic structure finc.
Let's build 3D model alarm clock......
Design bookshelf with adjustable shelves......
New Blender, trying create hammer......
X
I'm designing glusses......
54-8
Hi. I'm working on modeling this camera......
Hey, can you 3D model of desktop computer....
Figure Additional Qualitative Comparison with Baselines. This figure presents more qualitative examples comparing our method, Graph-CAD, with baseline approaches on challenging prompts from the CADBench benchmark.
more geometrically plausible and structurally coherent assemblies that better align with the user instructions, underscoring the robustness of our approach.
22

---

Published as conference paper ICLR 2026
Base Model (Qwen3-8B)
SFT
SAPCL Iteration
SAPCL Iteration
SAPCL Iteration 3
SAPCL Iteration
Hey there, could you create 3D model of cargo crane me......
Please create 3D model of cargo truck......
Can you render 3D model for the 'Duve&BBanbi character?
Can you create 3D model of guitar....
My task to renovate oven......
Figure 10: Visualization of Progressive Improvement with SAPCL. This figure illustrates the evolution of the model's generative capabilities on single, challenging user instruction across different stages training.
D.3 VISUALIZATION OF PROGRESSIVE IMPROVEMENT WITH SAPCL
To provide an intuitive understanding of how our Structure-Awant Progressive Curriculum Learning (SAPCL) mechanism improves model performance, this section visualizes the evolution of the model's s generative capabilities. In the Figure 10 we present a side-by-side comparison of outputs generated for the challenging user instruction at different stages of training pipeline. This comparison begins with the base pre-trained model, followed by the model after the initial Supervised Fine-Tuning (SFT) phase, and finally, the outputs after four successive iterations SAPCL. This sequence is designed qualitatively demonstrate the progressive refinement of the model's 's ability to handle complex assembly structures and satisfy geometric constraints.
D.4 VALIDATION OF
EVALUATION
Vision-Language Model (VLM). The VLM serves two critical functions: first, as an automated filter for preliminary data screening during our annotation pipeline, and second, the "Discriminator" that assesses the quality of newly synthesized examples during
In methodology, employ GPT-5 OpenAl 2025
23

---

Published as a conference paper ICLR 2026
the curriculum learning phase. To ensure that the VLM's judgments are a reliable proxy for human assess- ment in these roles, we conducted a cross- validation study. We compared the VLM's automated judgments against those provided by our professional industrial designers on a representative subset of the generated samples. The results of this comparison are presented in a confusion matrix in Table 6 We observed high degree of consistency between the two assessments. The VLM and the human experts were in agreement on 93.37% of the evaluated cases. This figure is composed of 30.84% consistency on "Pass" judgments and a 62.53% consistency on "Fail" judgments. Conversely, the assessments differed in only 6.63% of cases. This strong correlation demonstrates that the VLM serves reliable and scalable proxy for human judgment for this specific task. Therefore, we consider its use for large-scale, automated evaluation throughout our experiments to be well-justified.
To further validate the use of our VLM-based evaluation protocol, we conducted a human evaluation on a 30% subset of samples randomly drawn from both CADBench-Sim and CADBench-Wild, We recruited 10 volunteers with professional design experience and asked them to score the generated models according to the official CADBench scoring guidelines. This protocol was designed to directly align with the prompt and criteria provided to the VLM. The results of this human evaluation are presented in T A direct comn- parison reveals a strong correlation between the human scores and our main VLM-based results from Table and 2 Crucially, the relative performance ranking of all evaluated models remains consistent between the two methods, supporting the use of the VLM as a reliable proxy for human judgment in our experiments
Table 6: Cross Validation with GPT-5.
Human
Pass
Fail
VLM
Pass
30.84%
3.64%
Fail
2.99%
62.53%
D.5 IMPACT OF FEW-SHOT EXAMPLES ON GENERAL LLMS
To further analyze the behavior of our three-stage inference paradigm on general-purpose LLMs, we con- ducted study on the impact of varying the number of few-shot examples from zero to three. For these few-shot prompts, we selected examples with a similar level of complexity to the test instances to ensure a fair comparison. The results are detailed in Table g In the zero-shot setting, both the end-to-end and our three-stage paradigms struggle, cxhibiting high code eπror rates. The three-stage approach performs particularly poorly in this scenario. This is expected, the model has no prior exposure to our specific graph-strus -raph-structured representation and cannot reliably generate it without guidance. However, with the intro- duction of just one three few-shot examples, clear trend emerges. The three-stage inference process consistently outperforms the end-to-end approach, with the most substantial improvements observed in the Geometric Constraint Satisfaction (GCS) metric. This demonstrates that once the model understands the target format, the structured pipeline is more effective method for generating geometrically sound models. We also note that increasing the number of examples from two to three provides only marginal perfor- mance gain. Furthermore, even with three-shot prompting. the performance of the general- purpose LLM remains below that of our specialized, fine-tuned Graph-CAD (SAPCI)) model, highlighting the benefits of task-specific training and our curriculum learning strategy.
D.6 EFFECT OF DIFFRRENT BASE MODELS
To assess the impact of the underlying LLM backbone framework's performance, conducted an additional experiment by substituting the Qwen3-8B model (Yang et al.) (025) with Llama3-8B (Dubey
et al. 2024). We repeated the full training and evaluation process using this alternative backbone. The
24

---

Published as a conference paper ICLR 2026
Table 7: Human Evaluation Scores on 30% Subset of CADBench. The table shows the average scores assigned by 10 human evaluators. The performance ranking of the models is consistent with the VLM-based results in Table and 2 supporting the reliability of our automated evaluation.
CADBench-Shi (human)
CADBench-
Wild (human)
Models
A
Spat.
Inst.
Avg.
Attr.7
Spal.
Inst.
Avg.
BlenderI.I.M
0.6914
0.6862
0.3759
0.5845
0.6722
0.6509
0.4651
0.5914
GPT-5 (end-to-end)
0.7146
0.7281
0,4507
0.6311
0.6894
0.7107
0.5902
0.6634
GPT-5 (Graph-CAD)
0.7351
0.7237
0.4398
0.6328
0.7682
0.7475
0.5460
0.6872
Claude-opus-4-1 (end-to-end)
0.7185
0.7298
0,5460
0.4458
0.6923
0.7285
0.6072
0.6760
Claude Maude-opus-4-11 4-1 (Graph-CAD)
0.7521
0.7434
0.4962
0.6639
0.7462
0.7356
0.6907
0.7242
Ours (SFT)
0.7308
0.7326
0,4753
0.6462
0.7045
0.7268
0.5971
0.6761
Ours (SAPCL)
0.7693
0.7509
0.5482
0.6894
0.7746
0.7607
0.6139
0.7164
Table 8: Impact of Few-Shot Examples on the Performance of General-Purpose LLMss. The table compares the direct End-to-end paradigm against our Ttree-stage Graph-CAD inference as the number of few-shot examples is varied from zero to three. This analysis is conducted on the CADBench benchmark to evaluate how each paradigm benefits from in-context learning.
CADBench-Sim
CADBench Wild
Models
Atte:
Spai.1
Inst.
Avg.T
GCST
Alt..
Spat.7
Inst.7
E
GCS1
GPT-5 (end-to-end informeee with
0.5632
0.58%
0.3764
0.5097
20.8%
0.3467
0.5338
0.5610
18.0%
0,2522
GPT-5 (Grngh--AA CAD inference
0.2465
0:2211
31.68
0.2663
0.2582
0.2733
37.5%
0,2038
tend-to-cnd inferescee with l-shot)
0.6422
0,5745
7.0%
0.9911
0.6713
0.6519
0.4675
0.3294
GPT-5 (Griph- CAD inference with I-shot)
06615
0.6620
0:4108
0.5814
844
0.5984
0.6526
0.6935
0.4621
0.6027
12.5%
0.5211
GPT:5 (end-to-end inference with 2-shot)
0,7013
0.7347
0.4250
0.620
2.8%
0.3846
0.6858
0.7091
0.5595
0.6515
5.5%
0.4017
GPT-5 (Grigb-CM) CAD inference with 2-shot)
0.7342
0.7199
0.4451
0.6270
2.2%
0.000
0.7677
0.7523
0.5377
0.6859
4.0%
0.5849
GPT-5 (end-te end inference with 3-s 3-shot)
0.7039
0.7325
0.1268
0.6211
3.2%
0.3961
0.6869
0.6903
0,5108
0.6393
4.5%
0.4235
GPTS5 (Graph CAD inference with 3 3-shot)
0.7351
0.7007
0.4369
0.6242
2.8%
0.6431
0,7624
0,7438
0,5193
0,6752
6.0%
0.5971
Graph-CAD
0.7295
0.7265
0.4733
0.6431
2.4%
0.7830
0.6944
0.7270
0.5861
0.6692
4.5%
0,8025
Graph-CAD (SAPCL)
0,7681
0.7423
0.5546
0.6883
2.0%
0,9018
0,7695
0,7590
0.6057
0,7114
2.5%
0,8943
results, presented in Table 9. indicate that the choice between these two base models has a minimal effect on the final performance. The Llama3-8B- model achieves results that highly comparable to those of the Qwen3-8B-bast gains demonstrated in our main experiments not specific to single model architecture. Instead, they are primarily attributable to our proposed Graph-CAD framework and the SAPCL training strategy, which provide robust and model-agnostic approach to improving Text-to-CAD generation.
model across all evaluation metrics. This finding suggests that the performance
Table 9: Performance Comparison of Different LLM Backbones on CADBench. The table shows the results of our full Graph-CAD framework when built upon two different 8B-parameter base models: Qwen3-8B and Llama3-88 8B. The highly comparable performance across all metries indicates that our approach is robust to the choice of the underlying LLM.
CADBench-Siin
CADBench Wild
Models
Attr.
Spat.
Inst.1
Avg.T
Fagnture
GCS1
Attr.1
Spat.1
Inst.
Avg.1
Exgetuz
GCS1
Qwen3 8B (SFT)
0.7295
0.7265
0.4733
0.6431
2.4%
0.7830
0.6944
0.7270
0.5861
0.6692
4.5%
0.8025
Llama3 8B (SFT)
0.7146
0.7080
0.4941
0.6389
3.2%
0,7732
0.6894
0.7107
0.5902
0.6634
5.5%
0.8126
Qwen3-8B (SAPCL)
0.7681
0.7423
0.5546
0.6883
2.0%
0.9018
0.7695
0.7590
0.6057
0.7114
2.5%
0.8943
Llama3-8B (SAPCL)
0.7693
0.5248
0.6765
2.6%
0,9142
0.7639
0.7651
0.7034
0.8817
25

---

Published as conference paper ICLR 2026
Text2CAD
CADFusion
Ours (SAPCL)
GT
Create first part the CAD model, a three- dimensional rectangular prism with rectangular opening.
The CAD model contains curved shape with hollow center
Figure Qualitative Comparison with Sketch-and -eetch-and-Extrude Methods on the DeepCAD Dataset. This figure compares outputs from Graph-CAD method with representative Aketc--andeetrue (SEM) baseline on the DeepCAD test set.
D.7 COMPARISON WITH SKETCI-AND-EXTER METHOSS
A prominent paradigm in Text-toCCAD generation involves modeling objects through series of sketch- and-extrude (SEM) operations, as seen in methods like Tex12CAD and CADFusion (Khan et al. 2024b
highly effective for generating single-part objects where 2D sketch can be logically extruded into a 3D form. However, they are often less suited for creating complex, multi-part assemblies, as their underlying structure does explicitly model the hierarchical relationships and geometric constraints that govern how multiple parts connect and interact. The DeepCAD dataset (Wu) ctt al. 202T common benchmark used evaluate these SEM-based methods. Although our Graph- CAD framework is not fundamentally a sketch-ande -ibb-and--ettdee system, we evaluated its performance on the DeepCAD test set to provide a direct point comparison. As illustrated in Figure [T] our method achieves competitive performance, effectively generating both single-part and multi-part objects. This suggests that our graph-based representation offers more general and flexible approach to CAD generation that not limited to single modeling paradigm.
Wang et al. 2025a These approaches
D.8 EFFECT OF GRAPH REPRESENTATION UNDER VARYING OBJECT COMPLEXITY
To further analyze when the proposed graph representation becomes critical, we conduct an additional study on CADBench Du et al. (2024) by varying the complexity of target objects. We quantify complexity using the Unique Part Count, i.e., the number of distinct parts the assembly excluding repeated instances created via loops. We compare the Graph-CAD (SFT) model in Table 3 with an ablated variant that removes the intermediate graph representation and directly predicts CAD code from text.
Figure 12 reports the evaluation metrics Attr, Spat, Inst, Avg, and GCS as function of the Unique Part Count. For simple objects with about unique parts, both variants achieve very similar scores across all metrics. As the Unique Part Count increases, however, the gap between the two models widens steadily. Around 10-15 parts, the graph-based model begins to exhibit a clear advantage, particularly on instruc- tion execution (Inst). Beyond 20 parts, the model without graph representation degrades sharply across all metrics, whereas the graph-based based model degrades much more gracefully and maintains substantially higher scores, especially Geo and the overall Avg metric. These results suggest that the graph representation
26

---

Published as a conference paper at ICLR 2026
(a) Attr. vs Part Count
(b) Spat, vs Part Count
(c) Inst. Part Count
0.6
With Graph Repererbarion
Uauut Ca up teprosatation
0.5-
0.6
Att:
Spat.
Inst.
0.4
0.6
0.5-
WenhGrath Aoprese
0.4
Wtn Graph Reamerrtaiin Witrout Crugh Reprismmation
0.2
Witrout Rizznonttation
10
20 Part Count
20 Part Count
Part Count
(d) Avg. V5 Part Count
(e) GCS vs Part Count
Graph Nearosentadinn
0.85
Represencaioo
0.6
0.80
0.5
5 0.75
0.4
0.3
0.65
With G-uph hag cxcntation Emahh
0.2
0.60
10
20 Part Count
30
10
20
30
Part Count
Figure 12: Object-level metrics as function of the Unique Part Count on CADBench. We report (a) Object Attributes (Attr), (b) Spatial Understanding and Structure (Spat), (c) Instruction Execution (Inst), (d) Overall Average (Avg), and (e) Geometric Constraint Satisfaction (GCS). Blue curves correspond to Graph-CAD with the intermediate graph representation; orange curves correspond to the ablated model without graph representation.
provides little benefit for very simple assemblies but becomes increasingly important as object complexity grows, and is effectively essential for reliable Tex--to-CA generation once the number of unique parts exceeds roughly 15-20.
Figure 13 provides qualitative examples at different complexity levels. The columns correspond objects with 5, 10, 15, 20, 25, and 35 unique parts. For each object, we show the result of the model with graph representation (top row) and the ablated model without graph representation (bottom row). For low part counts (e.g., the pen with lid), both methods produce similar and reasonable shapes. As the assemblies be- come more complex (printer, cargo ship, living room), the non-graph model frequently exhibits unreasonable shapes and assembly errors, such as floating intersecting parts, missing supports, and misaligned subcom- ponents (highlighted by red circles). In contrast, the graph-based model is able to organize many parts into coherent, well-aligned assemblies that better satisfy the intended geometric and functional relations. These qualitative observations are fully consistent with the quantitative trends in Figure 12 and further support the claim that the graph representation is crucial for handling medium- to high-complexity CAD assemblies.
D.9 CAPTIONING COST AND COMPARISON WITH OPEN-SOURCE LVLMS
Captioning and evaluation cost. We report here the monetary cost of using GPT-5 for generating www.uuitiiiigaaa--aattioooooooee
quadruplets in BlendGeo and computing the Attr/Spat/Innt metrics in CAD- Bench. All costs are computed according to the official GPT-5 API pricing at the time of our experiments, namely US$1.25 .225 per 1M input tokens and US$10.00 per 1M output tokens.
27

---

Published as conference paper ICLR 2026
Unique Part Count
5
10
15
20
25
35
Object Name
pen with lid
wall clock
desktop printer
cargo ship
cozy living room
1
With Graph Representation
Without Graph Representation
Uercssorable stape
slope
Asszmbly cine
Unecaomuble supe
Unecasotuble shupe
Assembly erTrr
Figure 13: Columns show objects with 5, 10, 15, 20, 25, and 35 unique parts. For each object, the top row shows results generated with the graph representation, and the bottom row shows results from the ablated model without graph representation. Red eircles highlight typical failure modes of the non-graph model, including unreasonable shapes and assembly errors (c.g., floating or intersecting parts, missing supports).
For the evaluation metrics (Attr, Spat, Inst), each successfully generated CAD sample requires on average 5,513 input tokens and 44 output tokens for the GPT-5 evaluator. Under the above pricing. this corresponds to an average cost of approximately US$0.0073 per evaluated sample. For data annotation in BlendGeo, we use GPT-5 in three stages. the first stage, the average usage 4,011 input tokens and 704 output tokens, which translates to average cost of about USS0.0121 per sample. In the second stage, the average usage is 4.598 input tokens and 708 output tokens, with an average cost of about US$0.01 010000120 per sample. the third stage, the average usage is 9,014 input tokens and 3,008 output tokens, yielding an average cost of about US$0.0413 per sample. Summing over the three stages, the mean annotation cost per fully annotated sample is therefore roughly US$O.0662.
The annotated BlendGeo dataset contains 12,059 samples. Using the per-sample estimate above, this corre- sponds to total annotation cost of approximately USS800. The CADBench benchmark used for evaluation comprises 700 samples, so the total evaluation cost about US$5.1. In aggregate, the GPT-5 usage for dataset annotation and benchmark evaluation is therefore on the order of US$805, which we consider a rea- sonable cost for constructing and evaluating dataset of this scale. We hope this makes the trade-off between annotation quality and monetary cost transparent for future work.
On the use of open-source LLMs/VVMMs. We also analyze the role of open-source LLMs and VLMs in our pipeline and explain why we do not adopt them as the primary annotators and evaluators the current stage.
On the generation side, the main paper includes strong open-source reasoning LLMs as Text-to-CAD gen- erators in Table including DeepSeek-R1 and Qwen-Plus (Qwen3-Plus). Under identical task settings and prompts, these models exhibit substantially higher syntax еrror rates and markedly lower visual metrics (Attr, Spat, Inst, Avg) than closed-source models such as GPT-5 and Claude-opus-4-11 This performance gap indicates that current open-source LLMs still struggle to produce reliable, executable CAD code at the level required for large-scale automatic data annotation. Using them the main engines for generating instruction-gre -rwpp-aaction--eeeeeee
quadruplets would likely introduce a significant amount of noise into the dataset and weaken the supervision signal for downstream models.
28

---

Published as a conference paper ICLR 2026
Table 10: Cross Validation with Qwen-VL.
Human
Pass
Fail
VLM
Pass
28.54%
4.07%
Fail
12.86%
54.53%
Table 11: Performance comparison of the three-stage pipeline (Graph-CAD (SFT)) versus a unified multi- task single-moder modell baseline on CADBench.
Method
CADRendh-Sin
CADRench-Wid
AlixT
1pa.1
Ins.
Arg.T
Exsterd
CLIPT
GCS1
AltrT
Spui.1
Inst.
Avg.T
Emntee
CLIPT
GCST
Unitsed single model
0.7035
0.6951
0.1122
0.6153
5.6%
0.6371
0.7019
0.68-10
0.6921
0.5386
0.6383
11.5%
0.6182
0.754
Graph-CAD (SFT)
0.7295
0.7265
0.6544
0.7830
0,7270
0.6692
0.638
0,8025
On the evaluation side, we reports an experiment that directly compares GPT-5 and Qwen- VL as automatic judges under the same evaluation protocol as Table IO For representative subset of generated samples, we compare each VLM's binary Pass/Fail decisions against the judgments of professional industrial designers. GPT-5 reaches agreement rate of 93.37% with human experts, whereas Qwen-VI VI. attains 83.07% under exactly the same setup. This sizable difference in human agreement suggests that GPT-5 provides more reliable and stable evaluation signal than Qwen-V VL in our setting. Narrowing this reliability gap may require not only better coampting/aligmmenn but also stronger low-level and multi-scale visual feature extraction in lightweight evaluators (Gong & Zheng 2023). Considering that full evaluation pass the 7ampl CADBench benchmark costs only about USS5 with GPT-5, the monetary savings from switching to an open-source evaluator would be marginal relative the loss in reliability.
D.10 COMPARISON WITH A UNIFIED SINGLE MODEL
To further understand the effect our modular three-stage design, we additionally consider a unified variant in which single owen-based model is fine-tuned on the union of all training data from the three stages. Concretely, we simply mix all peaph--pediction.. aation-planning and oode-generation examples into a single training corpus and fine-tune one model on this pooled dataset. At inference time, this unified model is invoked three times, using the same stage-specific prompts as in our main pipeline, to sequentially produce the decomposition graph, action sequence, and CAD code.
Quantitative results for this unified model are reported in Table 11 Across CADBench metrics, the unified model performs consistently worse than three-model pipeline, with lower scores in Attr, Spat, Inst, Avg, and GCS, as well as a higher syntax еπrо rate. The degradation is particularly pronounced on more challeng- ing prompts, where assemblies involve many parts and dense geometric constraints. Qualitative examples in Figure 14] show that, in such complex cases, the unified model more frequently generates structurally flawed or geometrically inconsistent designs, including missing or floating parts, misaligned subassemblies, and incomplete geometry, whereas the modular Graph-CAD pipeline still produces coherent and visually plausible assemblies.
We attribute this gap to negative transfer between heterogeneous objectives that share single set of pa- rameters. The three sub-tasks differ substantially input-output structure and difficulty: local action prediction and simple graphs relatively short-horizon, whereas CAD code generation for complex as- semblies requires long-range reasoning about constraints and part interactions. When all objectives are optimized together in a single model without explicit mechanisms balance them, gradients from easier or shorter-horizon examples can dominate the updates and interfere with learning robust long- nong-horizon con- straint reasoning. This phenomenon is consistent with observations gradient conflict and task interference
29

---

Published as conference paper ICLR 2026
Create broom suitable for household cleaning.....
Create a 3D model of test tube rack.....
Create a desktop monitor...
Unified single model
Graph-CAD (SFT)
Figure 14: Qualitative comparison between the three-stage pipeline (Graph-CAD (SFT)) and the unified single-model baseline CADBench prompts. The unified model frequently produces structurally flawed or incomplete assemblies (e.g., floating or missing parts, misaligned components), whereas the three- stage Graph-CAD generates coherent, geometrically consistent designs that better satisfy the textual instruc- tions.
in multi-task learning (Yu et al. 2020 Liu et al. 2021). More broadly, how stage-wise decisions interact, and whether collapsing them into unified process preserves desirable behavior, a worthwhile question for further study (Gong al. 2024).
These findings support our choice of a modular three-stage architecture, where each stage is specialized for its own structured prediction problem while communicating through explicit intermediate representations (graph and action sequence). More advanced unified designs, such as parameter-efficien multi-task adapters explicitly modular multi-task architectures, remain interesting directions for future work, but naive single-model baseline does not match the performance of our three-stage Graph-CAD pipeline.
D.11 ANNOTATION ACCURACY AND TYPICAL FAILURE CASES
To assess the quality of the automated data generation pipeline. we conduct a post-hoc audit of all automat- ically generated quadruplets the annotated BlendGeo dataset (instruction, decomposition graph, action sequence, CAD code). Each sample is reviewed by expert annotators and assigned to one of three cate- gories: (i) correct and directly usable without modification, (ii) usable after minor corrections (e.g., small fixes to part names or local geometry), or (iii) requiring a complete manual redesign by human annotators. Table repports the proportions of samples falling into each category over the entire annotated set, providing global quantitative measure of the raw accuracy of the LLM/VLL--bar pipeline and the extent of human intervention needed.
Overall, observe that substantial fraction of automatically generated samples either accepted is or only require light edits before inclusion, while a smaller portion must redesigned from scratch. This indicates that the automated pipeline already produces reasonably high-quality supervision at scale,
30

---

Published as a conference paper ICLR 2026
with human annotators mainly acting as a quality filter and corrective layer for difficult cases rather than rewriting the majority of data.
To better understand the remaining failure modes, we also collect representative examples of both high- quality and problematic annotations. Figure shows typical instances of (a) automatically generated data that passes human validation unchanged and (b) samples that are corrected or replaced during manual vali- dation, along with brief explanations of the underlying issues. From these examples and annotator feedback, two dominant error patterns emerge.
First, there are geometric placement errors, where the set of parts and their rough identities are correct, but the spatial configuration is flawed. Typical symptoms include floating or intersecting components, mis- aligned subassemblies, or incorrect relative positioning between functional parts (e.g., support structures that do not actually touch the objects they are meant to hold). Second, there are failures on highly complex geometries, where the model struggles produce visually reasonable CAD model for objects with intri- cate shapes or dense local details, even when the high-level structure is roughly correct. In such cases, the generated geometry often appears over-simplified, distorted, missing key fine-scale features, and human redesign is required to obtain usable supervision. These two failure modes suggest complementary bottle- necks in the current pipeline: the first mainly about correctly arranging parts that are already identified, while the second is about preserving fine-grained geometric detail under higher structural complexity. For the former, a useful direction may be more explicitly separate part-content decisions from spatial arrange- ment decisions, analogous to factorization and controllable variation strategies explored in other structured generation domains (Dai et al., 2023; 2024 2025). For the latter (and especially for placement-sensittee cases), robustness may also benefit from making spatial relations and geometric constraints more explicit in the intermediate prompt/ineefface representation, rather than relying entirely on implicit inference, which conceptually aligned with marker-bass based prompting for spatial understanding other domains (Zhang et al. 2025
Table 12: Annotation outcomes for the automatically generated BlendGeo samples. All numbers are per- centages over the full dataset. GPT-5 "auto pass" denotes samples initially judged correct by GPT-5 before human review; the remaining rows summarize the final human assessment outcomes.
Outcome
Proportion (%)
GPT-5 auto pass (before human review)
72.56
Hluman-accepted without modification Human- accepted after minor corrections
69.51
26.45
Requiring complete manual redesign
4.04
E THE PROMPTS USED IN THE EXPERIMENT
This section provides an overview of the key prompts used throughout our methodology, including those for data annotation, curriculum learning, and evaluation. For clarity and brevity, the prompts presented here are simplified templates designed to illustrate their core logic and structure. The full prompts used in our experiments may include additional formatting or more complex few-shot examples not shown here.
E.1
PROMPT FOR THE VLM EVALUATOR
Role
A rigorous 3D model evaluation expert
31

---

Published as conference paper ICLR 2026
Smartphone
Router
Umbrella
Wardrobe
Successful samples
Office Desk
Truck
Failed product
Corrected product
Failed product
Corrected product
Geometric placement errors (minor modifications)
Espresso Machine
Fish Tank
Failed product
Corrected product
Failed product
Corrected product
Failure on complex geometries (redesign)
Representative examples of automated annotations and human corrections. Top row: samples that are directly accepted without modification. Middle row: geometric placement errors that are fixed by minor edits. Bottom row: failures complex geometries that require complete redesign.
Figure 15:
Task
Judge only from the images and the criteria for one single parameter.
Return exactly one JSON object with two keys:
{param]: a list of 0/1 with the same length as the criteria
reasons: a list of one-sentence explanations aligned to each 0/1
Output Rules
1. Output JSON only (no extra text, no code fences).
2. Allowed keys: am) and reasons only (no extra/missing keys).
3. Both lists must match the number and order of criteria.
4. Score if the requirement is met or reasonably satisfied, else 0.
5. Each reason must be short, factual, and tied to visible evidence.
Do Not Penalize
Primitive simplifications (e.g., boxy panels, cylindrical handles), generally low detail
32

---

Published as conference paper ICLR 2026
Minor camera clipping/aliasing
Criteria With Absolute Units (inch/cm/mm)
Do not check absolute values; evaluate relative proportions only.
Example: if depth is clearly smaller than diameter, PASS; if comparable or larger, FAIL.
If uncertain or views are ambiguous, default to PASS (1).
Context (placeholders)
Project Name: (project.name)
Type: (project.type)
Instruction: (project.instruction
Dimension: (dimension)
Parameter: {param}
Return Skeleton (replace 0 with 0/1; replace empty strings with one-sentence reasons)
{ "<param>": [0, 0, ...J. "reasons": ["..."
..
}
Criteria Input (use exact order)
[ "requirement_1 1",
"requirement.
]
E.2
PROMPT FOR THE PROBLEM GENERATOR
Role
A CAD course question generator that creates one derived design question from a given MOTHER
ITEM.
Input (MOTHER ITEM)
category: original item category
mother_id: unique ID
mother -user .prompt: user's natural-language description
mother eepometrygggapee text graph (for understanding only; do not copy into output)
Generation Controls
level (1,2,3)
33

---

Published as conference paper ICLR 2026
delta strength 2,, (higher more/larger changes within the level)
max changes: soft cap number of edits
al lowed ops: allowed change types for this level
si size_ range: permitted range size_scale is used
Task
Produce exactly derived design question.
Return JSON only following the exact schema below.
Requirement Paragraph (natural language)
Write an absolute requirement paragraph: directly describe the new geometry's characteristics.
Do not write relative language (no comparisons the theme/MOTHER ITEM).
Forbidden Topics
Assembly order
Tolerances
Difficulty Levels
Level 1: Same category; only appearance/opacityssize tweaks; no structural/topology changes.
Level Same category, structural edits (layers, part shapes, arrays, holes, etc.); may add small subordinate parts.
Level 3: A related new category (similar function//orm); state key dimensiionspparts/ayyuu explic- itly.
Output Rules
1. Return JSON only. No extra text, comments, code fences.
2. Use the exact keys and structure shown in the schema.
3. Ensure level and delttassrenng th match the Generation Controls.
4. change ops items must align with allowed ops; keep count within max changes (soft cap).
Output Schema (exact)
{
"derived": {
"category": "<string>",
"user_prompt": "<one paragraph natural language>",
"level": 1,
"helltasstrength 2, "change_ops"
{ "type": " "target": "...t" "from": "...",
". "to": " "scale": 1.2
],
"parents": "omother_id>"))
34

---

Published as conference paper ICLR 2026
"rationale"; "<<=20 chars>"
}
}
User Prompt Template
MOTHER ITEM
category: (category)
-mother_id. {mid}
moothrr_ser__prooee [user_prompt]
mother_geometry
(for understanding only; do NOT copy into output): (graph)
GENERATION CONTROL
level: (level} # 1/2/3
deelta_strength: {ds} 1/2/3
-max_changes (soft cap): (max_changes)
alllwed change types for this level: {allowed_ops}
size scale range if size_scale is used: (size_range)
Generate exactly ONE derived design question. Return ONLY the JSON object with the schema defined by the system prompt.
E.3 PROMPT FOR GEOMETRY DECOMPOSITION
Role & Outputs
1. Emit exactly two blocks in order: (1) MATERIAL LIBRARY, (2) Decomposition Graph.
2. Output only these two blocks (no extra text).
Units
All linear dimensions in metres (m).
Decomposition & Graph Rules
Recursively decompose until leaves are single primitives or basic boolean/auto_commect..
Record build order only on parent: assembly.order=(group]]], [group2],...
No cycles: do not form loops with parent//after/deeends..om
Block Formats
MATERIAL LIBRARY
MATERIAL LIBRARY
mat_name
di (Rffuue__coloo::R,,,... MEED_MMAEERIALS
Decomposition GRAPH
35

---

Published as conference paper ICLR 2026
BEGIN_GRAPH
Lk: id=<id>
parent=<parent_orr_> |
type=<type>
/AUT=<
align=x.../>> /-> pos=<offset(//polarr)> connectz<.../>>
orjennation=<diircciv//>>>>>>>>>
mat=<<snaee_ase__or_.a create_method=
Sriiitiiee/boleensssbrrraddd....
assemblyy.orderrsgrruusoo.__ I constraint=<text.or_>>
after=<sibliiggs.or_=
tool_id=<.../>> depends_on=<<ids_orr
END_GRAPH
Layering & Presentation
Use headings: Layer 0 Root, Layer / 7 Primmary Structure,
Table per layer: |
ID Description Key attributes
placement
(include
create_method)..
Placement (Minimal)
Align-first: define which feature touches which feature.
(4ige(s <axes> in Y,) <target> in (B. <feature>>
to <target>
| B[*]. <feature
<fk].<fetture>
(vg(T1,T2,.....
Then offset (dx, fly,z) in local frame: optional pos=polar(O); dr=Ar).
Connect two attachment features:
connect
<A>, <featurea <B>.ffeaureeB>
Patterning
Use one template node + centtenn=onlly.
patternagrid(rows.h cols:C, x_spacing:dx, y-spacing:dy, start_offsed (x0,y0)) pattern=polar (count:N, radius:r, start_angle: angle_step: delta_theete
Shape & Description
Leaf: start with primitive + size (m). If extrude.from.sketdh put sketch essentials in constraint.
Non-leaf:
"Composite of <children>; brief assembly phrase".
Dimensions
1. Convert given units to metres.
2. If partial/none: infer reasonable metre values.
Orientation & Rotation
36

---

Published as conference paper ICLR 2026
Primitives born in native pose (local +Z up). orientation remaps local +Z:
orientation = axis: / +Y / -Z
<obj> orientation = +X_face: normal <obj>
orientation axis: axis:
axis: tangenttott <obj>
+Z_ aliggn
<other>. +acface
orientation = normal:starget_otte
Optional rotation after orientation (free-angle tilt/spin).
No Shorthand
No repeat= or similar; only pattern= allowed. Each non-pattern node on its own line.
Deliverables (Order Strict)
1. MATERIAL LIBRARY
2. Decomposition Graph
E.4 PROMPT FOR ACTION PLANNING
Role I/O
System role: CAD Action build-script generator; output strictly in the specified format.
Input (each run): MATERIAL LIBRARY block multi-layer knowledge graph (FORMAT v4; includes orientation and offset (dx, dy, dz) in metres; no repeat= shorthand).
Output (each run): one plain-text Action script with exactly three top-level blocks (BLOCK 0/1/2).
Units
All linear dimensions in metres (m).
BLOCK 0 - Scene Reset & Units (always first)
1. Delete all existing objects (clean scene).
2. Set length unit to metres.
BLOCK Materials
For each material: Define material <mat_name>;
diffuse.color (R,G,B,A).
BLOCK Stage-by-Stage Operations
Follow each parent's assembly oorder, group by group.
Insert heading per group: -- SECTION <n> { <summary>
Command Rules (STRICT)
1. Name every new object in its creation sentence.
2. Orientation before placement the exact sequence for each node:
37

---

Published as conference paper ICLR 2026
(a) Create primitive and name it <id>.
(b) Rotate <id> so local +Z satisfies orientations.
(C) Anchor/Align <id> to reference features.
(d) Then apply offset//pllar/commet..
3. Iterative patterns (when pattern= is present): emit a natural-language loop for grid or polar arrays.
4. After core steps, write additional single-line actions as needed: Goolean-umion/subtraa Bevel, Auto-connect, Snap/Align, Validate.
5. If parent specifies guideline: quote, validate, end with "Assembly guideline satisfied."
6. Close each section with "Stage <n> complete." End with "All stages complete."
Placement & Assembly
Prefer assembly placement; use independent world pos/orientation only when necessary.
Align before final placement:
ASign(Saxes>) "ccis>><featuuee to <target>
<axes> in (x, Y,,]; <target> in (B.<feature> B[*]. <feature> B[k] <fettrret Avg(...))
Then offset
in aligned frame: optional pos=polar dr=Ar) or pos=spherical (0, 6; dr=Ar).
Connect: connect <A>, <feature>> <B>, <featureB>.
Optional rotation= after orientation (free-angle tilt/spin).
Absolute world XYZ is forbidden unless already present in the graph.
Sizing- Mizing-Only Anchors (if create.eeeteeeeee greate..mthho=grrop and size * AUTO)
Create an invisible Empty helper named exactly as the node ID; match its origin/orientaaiionssiee the node; use as anchor for children.
Output Policy
Return only the script text (no markdown, extra tokens).
Sentence Templates
Material: Define inee material <mat name>; diffuse color = (R,G,B,A)
Section heading: SECTION <n> { <summary>
Command verbs: Create Rotate Align Anchor Offset / Polar / Connect Boolean-subtract Bevel Snap Validate
E.5
PROMPT FOR CODE GENERATION
Role I/O
System role: Blender-Python code generator.
38

---

Published as conference paper ICLR 2026
Input (each run): BLOCK 0 (Scene Reset & Units), BLOCK (Materials), BLOCK (Stage
Sections as action sentences: verbs, sizes, anchors, offset (dx, dy, dz), orientation hints).
Output (each run): one self-contained Python script that recreates the model in Blender 3.x.
Output Policy
Return only valid Python (no Markdown, no prose).
Units
All linear dimensions are in metres (m).
Script Skeleton (fixed order)
1. Helper functions: make_materraalbbollann..bbb
doolean_union add_bevel, orient.hclpers.
2. Materials from BLOCK 1.
3. Geometry by sections from BLOCK
Sentence >>
Action (minimal mapping)
Create primitive (csVlllccccab///ooce//////eeeeec - add primitive, orient, place.
Bevel/Chamfer add bevel (target, radius, segments).
Boolean-subtraactunii + voolean_subtrant boolean_unne uniion.
Cut/hole/drill/lott build cutter Boolean.
Automatically connect Connect A.f B.f + connect points (auto length).
Snap/Align orfentatioorfecauureddieeeeee "Rotate its ... orient.helpers.
PbjeCt Step Order (STRICT)
1. Create primitive (or cutter) & name it by action ID.
2. Orient (local +Z per orientation=).
3. Anchor/Align to reference features (feature names must be explicit: if only reference ID is given, default to centre-to-centre).
4. Place with (dxx, dy, .z) or pos=polar (0; dr=Ar) or connect A. B.
Placement & Alignment (concise)
Prefer anchor-relative placement; use global world pos/orientatin only when necessary.
to in textual order; move only along listed axes; keep separate # align block followed by separate # offset block.
Emit one alignment block per Al Align(<xxes>>
Polar uses reference local +Z; Offiset is in reference local axes.
Absolute world XYZ only if present in the graph.
Loops
If action sentences describe repetition/pattern generate a real Python for-loop; compute offsets inside the loop.
Naming
Every created object uses the action ID; auto- autt-generated cutters append _cutter.
39

---

Published as conference paper ICLR 2026
F ILLUSTRATIVE DATA EXAMPLE
To provide a concrete illustration of our data structure, this section presents complete annotated quadru- plet from the BlendGeo dataset. The example demonstrates how simple user instruction is translated into structured intermediate representations- the geometric decomposition graph and the action quence-befioe before being realized as executable code. We use the example of a simple four-legged table.
User Instruction
Let's design dining table. The tabletop should be rectangular and large enough to seat six people comfort- ably. The legs should be simple and positioned at the four corner.
Decomposition Graph
MATERIAL LIBRARY
table_wood
dif
wood_dark
LEND_MATERIALS
#
BEGIN_GRAPH
### Layer
Root
ID
Description
Key attributes / placement
dining_ table
Composite of tabletop + four legs
anchor=-; pos=-;
or irientation=;; mat=-; greate_metho-=grouu
assembly a order=[[taaleeopp] [leg_fl, feg,fr, leg_bl, leg_br]]
### Layer 1 Table Components
ID
Description
Key attributes placement
tabletop
Rectangular tabletop 2.0x1. 04
pos=(0,0, 0, 0. 75); orientation=axis:t2
mat=table_won wood; wreate_method-primittii
leg_fl Leg (front-left) 0. 08x0.72 m
Align frg_fl.top_ffl to tabletop.bottom_feee wwttto_facccee.....otooooaa-aate
offset(-0.96. 0.46, 0); mat=wood_daa _droo create_me
leg_fr Leg (front-right) 0.08x0.08:0 08x0.
Align
to tabletop.botton bottom_facc;;
offset(0. 96, 0.46, 0); mat=wood_darkk create__eet leg_bl Leg (back-leftt 0. 00*0000*0.....................8. 72 Align teg_bl.top_fee offset(-0.96. 96, -0.46, 0); htt=-wood_darde create_method-primmitvee I leg_br br Leg (back-right) 0. 0.08x0.000 0xx0.08x0.72 m
to tabletop.bottom.... bottom_facce
tabletop.botttm_faa Align leg_br. br. face to tabletop. bottom_facee
offset 96, -0.46, 0); mat=wood_dark; create_methodfpriiittii
#
END
Action Sequence
BLOCK [ Scene Reset Units
40

---

Define material table_wood; diffuse_color (0.60, 0.40, 0.25, 1). Published as conference paper ICLR 2026
Delete every existing object start from a clean scene. Set the length unit to **metres**.
BLOCK { Materials
Define material wood_dark; diffuse_color = (0.35, 0.20, 0. 10, 1).
BLOCK 2 { Stage-by-Stage Operations
SECTION 1 { Create tabletop Create primitive tive cuboid with size 2.0x1.0x0.0 Rotate tabletop so its axis aligns +Z (world). Anchor tabletop to world.origin.
00.00.0044 and name it tabletop.
Then move by offset(0, 0, 0.75). Assign material table_wood to tabletop. Stage complete.
SECTION 2 Attach four table legs Create primitive cuboid with size 0.08x0.000 08x0. 72 m and name it leg_fl. fl. Rotate leg_fl so its axis aligns +Z (world). Align leg_fl. fop_face to Then move by offset(-0.96 0.46, 0). Assign material wood_dark to leg_fl.
Create primitive cuboid with size 0. 08x00 08x0. 72 and name it leg_fr. fr. Rotate feg_fr fr so its axis aligns +Z (world). Align leg_fr. fape to tabletop.botton face. Then move by (0 96, 0.46, 0). Assign material wood_dar dark to frr_fr.
Create primitie tive cuboid with size 08x0. 08x0. 72 and name it leg_bl. Rotate leg_bl so its axis aligns +Z (world). Align leg_bl. top_face to tabletop. bottom_facee Then move by offset -0.46, 0). Assign material dark leg_bl.
Create primitive cuboid with size 0. 08x0. 08x0. 72 m and name leg_br. Rotate leg_br its axis aligns +Z (world). Align leg_br. face to tabletop.bottom_fe.. face. Then move by offset(0... 96, -0.46, 0). Assign material wood_dark to leg_br. Stage complete.
SECTION 3 Complete dining table assembly
Validate that all legs are securely attached to the tabletop at their designated corners.
41

---

Published as conference paper ICLR 2026
Assembly guideline satisfied. Stage complete.
All stages complete.
Bpy Code
import bpy
import math
from mathutils import Vector, Matrix import mathutils as mu
#
# Helper Functions #
def makk_materiall (name, rgba): mat bpy. data. materials nnamee mat di fuse_collllrr rgba return mat
def cubue
size_Me size_xyz_m):
bpy. bpy.ops ops. mesh. www.:priiiieeeeueeeeeee (
obj = bpy. cowp.ot.......m
obj. name = obj_name
size_xyz_m[1], size_xyz_m[2]) obj. scale [size_xyz_m[o]]
ops. orostt...t...om
return obj
def
local_axis, target_vec):
axis_vec = V(c 0,,0), Veector((0,111) 0)), 'z' V 0, [ox][_cca_xxxs]]
tgt_vec Vector (taagee_.vec..ormaatl
angle = axis_vec. angle(tgt_vec)
if angle < 1e-6:
return elif abs(angle math.pi) pi) 1e-6:
if abs(axis_ved) vec.xs_eee.x) x) 0.99:
rot_axis Vector((1,5) 0, 0)) cross normalzze() else:
rot_axis Vector ( 0)) .arss)))ssssssi normalized()
else:
rot_axis axis_vec.cross(ttttvee)..... )oommaaazze)).
rot_matrix Matrix. (onaiixxotaaiiinnnngle,,, 4, rot_axis)
obj mat.rrxxwooolddd rot_matrix @ obj matrrix_woolld
FFACE ('left': ('X', 'min'), 'right': ('x', 'max'),
42

---

Published as conference paper ICLR 2026
'ackk: CYY', 'min'), ) 'front': (YY', 'max's ),
'botoom' : ('Z', "min') ) 'top' ('Z', "max )}
class Locator:
def __iiiit__. (self, obj: bpy. hyppes.bjecct self obj obj
()
def _make_bbooxeece (oxxe__box(seef))
if self self.obj.type in ('MESH', 'CURVE', 'SURFACE', 'META', 'FONT'):
dg = bpy. contex. conttexteealluted evaluated eea
eval_me self. evaluated xs = [v. for v in e vertices]
to_m)))
ys [v.co.y for in eval_me. vertices]
zs = [v.co.z for in eval_me. vertices] self. self.obj.a. eeajjjevveaeeeeette...... if xs:
self. bb = {
'minX': min(xs), 'maxX'; max (xs)
mmnnY' min(ys), 'maxY': max (ys).
"minZ': min(zs), 'maxZ': max(zs),
}
return
dim getattr obb "dimensions", Vector (0,0000) hx, hy, hz dim. x*0.5 5, dim. 0 self.bb = {
'minx': -hx, maxx' hx,
'minY:: : -hy, maxY" hy,
'minZ': : -hz, "maxZ' hz,
def
face_key: str):
key sacc_keeylower
if key == 'center'
return (eff.ccente__oold()
axis, ext __AAC[Cke]
val = self bb[lbb[ff (xxx)(xx(]
if axis 'x':
p_local = mu, Vector
iself.bbl minY ]+self bbG m) +0.0.5 (self. (llf.bb[[ne (a'bbbb'''''''eet..m '+self bb[ 'maxZ'a +) 5))
elif axis == 'Y':
p_local mu. Vew.ee bb[ mmni ]+self. bbe 'maxX" m 5, val,
(self. minZ (b maxZ' ())x5))))))
else:
p_local www.Veettor(seleee bbC min' 'Iself bbb maxx 00.5
(self bbc minY " wttpsselffbbblllee mmxma (axxY")+00. val))
return self obj marrd p_local
#
#
Scene Reset Units
43

---

Published as conference paper ICLR 2026
#
ops. aps.object..omm ops.
bebeecttsslec....... select_all (actionnn
bpy. context. scene.
scen. uni snit_sstttings. system 'METRIC' bpy.context www.enettttetee............. uni meiit_seetings.... scale_length
# Materials
mat_table__ __wood make_material ("table_wooll (0.60, 0.40, 0.25, 1))
mat_wood_dare _ark make_material "wood_ddorr"""""" (0.35, 0.20, 0. 10, 1))
#
# SECTION 1 Create tabletop
#
tabletop add_cube ("ttabeete,,,pp, (2.0, 1.0, 0.04))
align_axis __a__aiis_t____ dasssto_uiee to_ pector((abletoog 'z', (0, 0, 1))
tabletop. location = Vector ((0, 0. 75))
tabletop. datet.tppdaa...... www..daaaa.aaaaaaeaaaaa www.mmaataaaa....mma. append (aallaase.ppeeeettttteeeeeeeeeoe
#
# SECTION Attach four table legs
#
# leg_fl f1
leg_f1 fl add__ube (0.08, 0.08, 0.72))
align_axis axin__ii____ (1eg_ 'Z', (0, 0, 1))
ref Locator(tableto)) www.rreceeeeee_worrrr_eeeee wwrpewowoldllboooooooo
offs = (leg_ for delta ref offs
leg_fl. location delta
feg_fl. += Vector((-0.0) 0.46, 0)) leg_fl.data l (mteriaass.appeemmmat...
ampt (ood__ood__dark)
# leg_fr
leg_fr fr add_cube (0.08, 0. 08, 0.72))
'Z', (0, 0, 1))
fwwefaannteeeaeeeeeeeeaaareeee wedeewwwooolddtdoooo ref Locator face offs Locator faweteeeeeeeeeeeeeeeeeeeaeeeeeee center_ "iatter__wodd("tpp""" delta ref offs
leg_fr. location delta
leg_fr. location += Vector((C) ((0.96, 96, 0.46, 0)) dww.faaaat... leg_fr. data. www.maalete...mmm (mad__ooddd_wwdddaaa
# leg_bl bl
leg_bl bl add_cube cuwe bl", (0.08, 0.08, 0. 0.72)) align_axis to vector 'z', (0, 0, 1))
44

---

Published as a conference paper ICLR 2026
ref Locator(tabletoo) face_ "fae__eeterrwor11("""ttmmm"" offs = Locator (leator(eeg_bll bl).
delta ref offs
leg_bl location += delta
leg_bl bu..b..locce location Vector((-0.9e 96, -0.46, 46, 0)) leg beg_bl.das dat.. materials append a _
# leg_br
leg_br add_cubee"leg__r", (0.08, 0. 08. 0.72))
(tr___xxi_tt__eeoorr((t align_axis_to to_ vector vector (leg_br, 'z', (0, 0, 1))
ref Locator (tabletop)
(nntterwworlddoeee (obotttmm") "enc___ette_woord(""" top")
offs Locator(leg_br))
delta = ref offs
leg_br. location delta
leg_br location += Vector((e 96, -0.46, 0))
leg_br, data, wateriallssss... aapteraal..apeed (mat_ cesttt_ooddddrrddeed _arr)
45

---

Published as conference paper ICLR 2026
Algorithm 1: Structure-Aware Progressive Curriculum Learning (SFT + SAPCE)
Input:
Initial training dataset D1, base model Mo, sampling proportion a, threshold 7, #variants per
level
Output: Final model Minal
t f 1; D; t- D1; final + Mo:
while not converged do
// Stage A: Supervised Fine-Tuning (SFT)
M, t- -F,(M;,,,,..)
// Stage B: SAPCE (Capability Exploration)
+ CattggryAuurreSmmplle.. a); L + 0:
foreach I, do Generate K variants P.[1..3] + KG,
I; + 0:
for 8 = to do total K; foreach E PiLe do
correct
out - (oole(M,, I, p); ok Disclout,p) p); if ok = Match then correct + correct +
acc + correct/ K;
if acc 2 then
Lit
else
break:
// Stop exploration for I,
+ L.)
// Data Generation at Capability Boundary Snew 0: foreach (T, L3) E do
targets +-
if L; 2 then
targets + targets {Li}
if L, < 3 then
targets t targets (Li + 1}
foreach l E targets do *CCoGen(4y E);
Soatid + E Disc(s.outpuul s.prompt) == Match]; Snew Snew Svatid:
1/ Merge Iterate
D++1 + D, U Unewi
if StopCondition/ L, Snew, t) then
Minat + Múi
break;
t ++t+1; M D, t D411i
return Minat
46

---

Published as conference paper ICLR 2026
Algorithm Per-class cost matrix construction for node alignment (LI-based components).
Input Pred nodes of class P. {pr}: }: GT nodes of the class G. {9)): Global GT scale Smax = m&X
weights (Wa, Wp, Wos wa) and attribute penalty ?
Output: Cost matrix C' P.)
Function SizeVec(n):
if n has box size (lz, (2,)))))))) then
return (1r,)y.12)
else if n has cylinder size (d, h) then
return (d, d, h)
else
return 0,)
end
Function (riVe
Map -X, +Y,
unit vectors; default +Z
return mapped unit vector
Function BuildCostMatrix(PP Ge, Smax; Wss up: Way Wa: ?)
Initialize C as a Pal x (G.l zero matrix
for + 1 to Pa do
p P:
Ps - SizeVec(p)/Smaa
РN +- p.pose.pos
P,, - Drivec(p.pose.og or + Z)
for <- to |G.l do
f <- 9j
g. f- SizeVec(g)/SSnan
ga - g.pose.pos
go f- Ori OriVec(g.pooe.ort or Z)
|p. gall1
Gpos
Pa g. max(1,
Cari
AngDeg (P., 8.8/180
0, if materials are equal or missing
Catr
7: otherwise
Cli.j] - Csise + Wpppus + WoCori + WaCar
end end return C
47

---

Published as conference paper ICLR 2026
Algorithm 3: Nove-Level Alignment (NLA) with LLM-guided aliasing, class-wise Hungarian match-
ing, and L1 aggregation.
Input GT graph text Ta. Pred graph text Tp; weights (Wa, Wpp War Wa); attribute penalty " Output: NLA score (lower is better) and matched pairs P
+ ParseGraph(Tc): + ParseGraph(Tp)
Compute global Smax ma modes wai (hax(SizeVe((g))
M + LLM.AAliasHapoingg(G P)
// one-to-one mapping: pred.id + gt.id // sync IDs in
t WeenamePreddittMMpppiinn P. M, ,.s..,,aso.set.caasssttoo
nodes//eedes/consstraanss
TotalCost +- 0; TotalPairs 0; P <-
C + union of classes G and P
foreach C do
Pe - {p P.nodes p.cls = c}
Ge {gg E G.nodes g.els c}
if Pc| = or |G.l = 0 then
continue end
C BuildCostMatrix(2. Goy Smax, Wsy Wp: Way Wa 7)
(r, t) f- Hungarian(()) for k |r| do
11 row/col indices of optimal assignment
TotalCost + TotalCost + C[r[k], t[k]]
TotalPairs TotalPairs +
+ P ((Pa[r(k]] G. [t(]]]] id)}
end end
NLA + TotalCost/ max(1, TotalPairs)
// mean L1-based assignment cost
return (NLA, P)
48

---

Published as conference paper ICLR 2026
Algorithm Depth computation and edge consistency for HI.A
Input GGaph X (Vx. Ex); Node mapping M
Output: Depth map dx. EdgeF1 score
Function ComputeDepths (X = (Vx: Ex)):
C {c (u, Ex }: R {u Vx C)
if R = then R {v Vx layer(v) 0} or Vx end
Initialize depth map with d(r) for all R: queue Q + R while Q not empty do
u - pQ
foreach (u, v) E Ex do
if 0 then d(v)= = d(u)) + 1; push
end
end
end
foreach
e E Vx do if then d(u) 0
end end
return d
Function EdgeF1 (Ep, Eg, M):
hits 0; np = EEpl nG = Eal
foreach (Ppar, Pch)
Ep do if Ppar: Peh E M then
9par Mipparli Jch MiPoal if (gpar Ieh) E EG then hits +- hits +
end end
end Prec + hits/np if up > 0 else 0 Rec t hits/ng if ng 0 else 0
EdgeF1 + 2- Prec- Rec/ (Prec + Rec) if Prec + Rec > 0 else 0 return EdgeF1
49

---

Published as a conference paper ICLR 2026
Algorithm 5: Depth consistency and final aggregation for HLA.
Input : GT graph G. Pred graph P, Node mapping M, mixing weight a Output: HLA score, EdgeF1, DepthScore
Function Depthhonnsisttenyydddd.d.....
S x-1
foreach p Vp do
i E MM then
g Mpp A [dppp] dc|g]l
append exp( A)) S end end
return mf S > 0 else 0
Function HicrarccyyLeeeLAcccrrrCCG...... P,M a):
dG <- (omputeDepthss((); dp +- tp Comptteepppp))))
EdgeF1 t EdgeF1 Mc
DepthScore + DepthConsistency(de M) HLA + a FI + (1 (1- a) Depth.Score
return (HLA, Ed DepthScore)
50


Reviews:
[{"review_id": "e3CbOxl81y", "reviewer": "Reviewer_dp1Y", "summary": "The authors propose utilizing a hierarchical and geometry-aware graph that decomposes an assembly into its constituent parts (nodes) and explicit geometric relationships between them (edges). Furthermore, a curriculum learning approach is adopted for training a decomposition model. In addition to this, the authors also introduce BlendGeo dataset consisting of 12K quadruplets consisting of user instructions, geometric decomposition graphs, action sequences, and blender python code.", "questions": "1. The improvement from SFT to SAPCL in Table 2 for Avg is modest. Can you provide some reasoning for this?\n2. At what complexity or maybe part count does the graph representation become essential?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- the problem of lack of geometric reasoning and explicit structure is well motivated for Text-to-CAD application\n- Building the BlendGeo dataset for the research community", "weaknesses": "- the representation novelty is overstated to some extent. The hierarchical geometry-aware graph closely mirrors the assembly graph representation established in [1], [2]\n- the gains from SAPCL appear modest and it is unclear to me how much the curriculum learning contributes\n- key metrics (Attr, Spat, Inst) rely on GPT-5 for evaluation and I’m concerned about objectivity and reproducibility.\n\n[1] Hierarchical Graph Learning for Material Prediction and Recommendation in Computer-Aided Design\n[2] Material Prediction for Design Automation Using Graph Representation Learning", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "yn6xHqG5jN", "reviewer": "Reviewer_vFoT", "summary": "This paper tackles the challenge of text-to-CAD code generation, a long-horizon reasoning task prone to cascading errors. The authors propose a hierarchical, geometry-aware graph as an intermediate representation. A structure-aware progressive curriculum learning mechanism further enhances graph generation by gradually increasing structural complexity. The authors also introduce a new dataset. Experiments demonstrate significant improvements in geometric fidelity and constraint satisfaction over existing baselines.", "questions": "Please address the weaknesses above.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The paper is overall well-written and easy to follow.\n2. The proposed method is conceptually simple and clearly presented.\n3. The motivation for capturing geometric constraints in CAD generation is well justified.\n4. The hierarchical graph decomposition appears practical and effective.", "weaknesses": "1. The captioning cost using closed-source LLMs should be reported. Moreover, it would be valuable to evaluate the performance of free, open-source LLMs such as the Qwen-VL series for captioning.\n2. Table 3 shows that the three-stage pipeline outperforms the end-to-end baseline; however, the time cost should also be compared to provide a clear trade-off analysis.\n3. The curriculum learning algorithm is rather common, and this paper appears to present only an application of it to CAD generation, which limits its novelty.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "URel7wLvaL", "reviewer": "Reviewer_mST1", "summary": "This work proposes a method for text-to-CAD generation. It decomposes the problem hierarchically, addressing different levels of abstraction in the design process. CAD code is generated progressively in three stages: an abstract graph, sequences of operations, and detailed CAD code. This generation process is achieved by three dedicated language models, finetuned by a proposed training strategy. A new dataset is curated for this task.", "questions": "Please refer to the weaknesses section. I'm willing to increase my score if the authors can adequately address those concerns.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1. Proposes a novel hierarchical and geometry-aware graph as an intermediate representation for Text-to-CAD, clearly improving structure and constraint handling.\n2. The experiments are comprehensive.\n3. The proposed dataset is a valuable contribution to the field.", "weaknesses": "1. Lack of visualizations of the generated CAD models to better assess quality.\n2. Evaluation heavily depends on LLM/VLM judgments, which may introduce bias.\n3. The generation process heavily relies on large language models. Since generation of CAD code requires precise generation of numerical values, which may be difficult for LLMs, it is unclear how well the method generalizes to more complex designs. The authors should provide more analysis on this aspect, justifying the robustness of their approach. \n4. The proposed method can be viewed as a chain-of-thought strategy. It's unclear how much the hierarchical decomposition contributes to the performance compared to a simpler CoT approach or a zero-shot approach with a strong reasoning LLM.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "yVhA6TEC26", "reviewer": "Reviewer_rBRF", "summary": "This work introduces GraphCAD, a three-stage framework for the text-to-CAD generation task, that includes a hierarchical, geometry-aware graph as an intermediate representation between text and executable CAD code. By explicitly modeling assembly hierarchy and geometric constraints, and by employing a structure-aware progressive curriculum learning scheme, the method achieves higher geometric fidelity and better constraint satisfaction than previous end-to-end baselines.", "questions": "1. Will the proposed dataset (BlendGeo) be released publicly? Since the dataset is one of the key contributions of this paper, it would be important to clarify the release plan and accessibility for future research.\n\n2. Why are three separate models fine-tuned for the three stages of the pipeline? This design significantly increases the overall complexity, computational cost, and memory footprint. Could the authors explain why a single unified model (e.g., fine-tuned jointly or multitask) was not adopted, and whether they explored this alternative?\n\n3. What is the accuracy of the fully automated data generation process before human filtering? Specifically, what proportion of the automatically generated data was filtered or corrected by human annotators? It would be informative to show examples of (a) automatically generated data and (b) samples that were rejected or corrected during manual validation. I am particularly curious about the typical types of errors made by the LLM/VLM in the automated annotation pipeline.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- This work proposes a novel and well-motivated formulation of the Text-to-CAD generation task by treating it as a structured reasoning problem rather than a direct text-to-code mapping. This reformulation is conceptually clear and empirically validated, leading to improvements in CAD generation performance.\n\n- A new dataset (BlendGeo) is curated that pairs textual instructions with hierarchical geometric decomposition graphs, action sequences, and executable CAD code. This dataset is a valuable contribution that could facilitate future research in structured 3D reasoning and program synthesis.\n\n- The manuscript is clearly written and well-organized, with intuitive figures (e.g., Figures 2 and 7) that effectively illustrate the hierarchical decomposition process and the overall data annotation pipeline.", "weaknesses": "1. The ablation studies confirm that each stage (graph, action planning) helps, but they do not fully explore why or where the improvements arise. For instance, showing qualitative failure cases when geometric constraints are omitted or visualizing how curriculum iterations expand the model’s capability boundary could make the training dynamics more interpretable.\n\n2. The three-stage pipeline introduces latency (≈1.7 min per sample) and multi-model coordination complexity. Although the authors argue that this cost is acceptable, a more quantitative trade-off analysis between inference time and geometric fidelity would strengthen the claim.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)