CAD-Coder: Text-to-CAD Generation with Chain-of-Thought and Geometric Reward
Authors: Yandong Guan
Xilin Wang
XiMing Xing
Jing Zhang
Dong Xu
Qian Yu
Venue: NeurIPS 2025 poster ()
Keywords: CAD generation
text-to-CAD
LLM
Primary area: applications

Abstract: In this work, we introduce CAD-Coder, a novel framework that reformulates text-to-CAD as the generation of CadQuery scripts—a Python-based, parametric CAD language.
This representation enables direct geometric validation, a richer modeling vocabulary, and seamless integration with existing LLMs. 
To further enhance code validity and geometric fidelity, we propose a two-stage learning pipeline: (1) supervised fine-tuning on paired text–CadQuery data, and (2) reinforcement learning with Group Reward Policy Optimization (GRPO), guided by a CAD-specific reward comprising both a geometric reward (Chamfer Distance) and a format reward.
We also introduce a chain-of-thought (CoT) planning process to improve model reasoning, and construct a large-scale, high-quality dataset of 110K text–CadQuery–3D model triplets and 1.5K CoT samples via an automated pipeline. Extensive experiments demonstrate that CAD-Coder enables LLMs to generate diverse, valid, and complex CAD models directly from natural language, advancing the state of the art of text-to-CAD generation and geometric reasoning.

CAD-Coder: Text-to-CAD Generation with Chain-of-Thought and Geometric Reward
Yandong Guan School of Software Beihang University Beijing, China yd_ rd__gannbuaaa.. edu.cn en
Xilin Wang School of Software Beihang University Beijing, China wang_xi vang_xilin@bua..c edu.cn
Ximing Xing School of Software Beihang University Beijing, China
ximingxing@quaa. edu. cn
Jing Zhang
Dong Xu
Qian Yu* School of Software Beihang University Beijing, China qianyu@buaa edu. cn
School of Software
The University of Hong Kong Hong Kong, China
Beihang University Beijing, China zhang-jing@buaa. edu. cn
dongxuêcs hku. hk
Abstract
In this work, we introduce CAD-Coder, a novel framework that reformulates text-to-CAD the generation of CadQuery scripts-a Python-based, parametric CAD language. This representation enables direct geometric validation, a richer modeling vocabulary, and seamless integration with existing LLMs. To further enhance code validity and geometric fidelity, we propose two-stage learning pipeline: (1) supervised fine-tuning on paired text-CadQuery data, and (2) rein- forcement learning with Group Reward Policy Optimization (GRPO), guided by CAD-specific reward comprising both a geometrie reward (Chamfer Distance) and a format reward. We also introduce chain-of-thouse (CoT) planning process improve model reasoning, and construct large-scale, high-quality dataset 1 10K text- Sat-CadQuery-33 model triplets and 1.5K CoT samples via an automated pipeline. Extensive experiments demonstrate that CAD-Coder enables LLMs generate diverse, valid, and complex CAD models directly from natural language, advancing the state of the art of text-to-CAD generation and geometric reasoning.
1 Introduction
Computer-Aided Design (CAD) systems are fundamental tools in engineering and manufacturing, enabling the creation of precise 3D models. However, traditional CAD workflows often demand significant expertise and are time-consuming (1 6), which limits broader accessibility and hampers rapid iteration. Recent advancements in Large Language Models (LLMs) 28), particularly their profi- ciency in natural language understanding and code generation
present promising opportunity streamline CAD processes (5) 26 based on natural language descriptions. The ability generate or modify CAD models via textual instructions 2
13 16 could lower the entry barrier for novices
and enhance the efficiency of experienced users.
However, generating CAD from textual descriptions remains a nontrivial challenge. To leverage progress in natural language processing, researchers have proposed representing CAD models using pre-defined command sequences and formulating text-to-CAD as machine translation problem-i.e.. autoregressively predicting CAD command tokens conditioned input text 32 13
"Corresponding author.
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

Despite their utility, these approaches face several limitations. First, verifying the validity of a CAD model represented by command sequences is challenging. Second, most existing methods support only limited set of operations, such as sketch and extrusion, restricting the diversity of generated CAD models. Third, CAD command sequences are often difficult to interpret and edit, complicating both understanding and debugging.
To address these issues, we advocate for a new proxy representation CAD models. In this paper, we utilize CadQuery [7], a Python-based parametric CAD scripting language, as the target representation. CadQuery is particularly suitable for the following reasons: (1) It provides inherent geometric validation, as CadQuery scripts can be directly executed to verify the validity of the resulting CAD model. (2) It offers rich vocabulary for CAD modeling, enabling the representation of diverse and constructs, making them more interpretable than low-level command sequences. (4) Importantly, as CadQuery implemented in Python, it allows us to leverage the code generation capabilities of modern LLMS that are already proficient programming tasks.
complex geometries. (3) CadQuery scripts are composed of semantic. function-
Consequently, we reformulate the text-to-CAD task as generating CadQuery code from natural language input. While this representation enables the use of LLMs for CAD generation, adapting LLMs to reliably produce high-quality CAD models remains challenging. The core difficulty arises from the dual requirements of CadQuery code: syntactic correctness (from a programming perspective) and geometric plausibility (from 3D modeling perspective). While supervised fine- tuning (SFT) on paired text and CadQuery code can teach the model syntactic patterns, it insufficient to guarantee both code validity and geometric correctness, as it lacks explicit 3D knowledge and reasoning capabilities [39 g 38
To overcome these challenges, we draw inspiration from recent advances where reinforcement learning (RL) has improved LLM reasoning and planning across various domains. In particular, we integrate Group Reward Policy Optimization (GRPO), an efficient RL algorithm, into the text-to-CAD code generation pipeline. Our approach consists of two stages: (1) We begin by supervised fine-tuning an LLM with paired natural language descriptions and CadQuery code to establish basic syntax and mapping. (2) We then enhance the model's 's planning and reasoning ability via RL, introducing a novel CAD-Specific reward function.
Specifically, since multiple distinct CadQuery scripts can produce geometrically equivalent CAD models a challenge for SFT to capture- we introduce a chain-of-thought (CoT) process that encourages the model to plan before code generation. Our CAD-Specific reward comprises two components: a geometric reward, which uses the Chamfer Distance (CD) between generated and target 3D geometries ensure geometric accuracy, and a a.format reward, which enforces the reasoning process and syntactic correctness of the generated code.
To facilitate research in this area, construct large-scale, geometrically verified dataset comprising 1 11K text- Sitr-CadQuery-33 model triplets and 1.5K high-quality CoT samples. We also propose an automatic data construction pipeline to accelerate dataset creation and ensure high quality. Extensive experiments demonstrate that our method unlocks new capabilities for LLMs, enabling the generation of complex, functional CAD models directly from high-level textual intent. In summary, our contributions include the following:
We propose a novel approach CAD-Coder that reformulates the text-to-CAD task as generating CadQuery code from natural language descriptions. Leveraging the Python- based CadQuery enables more interpretable, diverse, and valid CAD model generation, while fully utilizing the code generation capabilities of existing large language models.
We introduce two-stage pipeline that combines supervised fine-tuning with reinforcement learning using GRPO. Our method incorporates chain-of-thouu thothh (CoT) planning process and novel CAD-Specific reward, which jointly enforce both syntactic correctness and geometric plausibility in the generated CAD models.
We construct a high-quality, large-scale dataset consisting of 1 110K verified eext-CaQueery- 3D model triplets and 1. 1.5K CoT samples via an automated pipeline, facilitating further research in text-to-CAD generation and geometric reasoning.

---

2 Related Work
2.1 Large Language Model for Code Generation
Large language models (LLMs) have revolutionized code generation, with models like GPT-4 [20 and specialized rode-focused LLMMs such as Codel 27 showcasing impressive capabilities in translating natural language into various programming languages [3] I. Standard training typically involves supervised fine-tuning (SFT) on extensive code corpora and instruction datasets. To better align LLM behavior with specific goals or complex tasks, reinforcement learning (RL) techniques have been increasingly employed. Reinforcement learning with human feedback (IL is widely used for general alignment. For more task-specific optimization, policy gradient algorithms like Proximal Policy Optimization (PPO) [23 are commonly utilized, though these often require training a separate critic network, which adds computational overhead.
Our approach leverages Group Reward Policy Optimization (GRPO) 24 more recent and efficient RL algorithm that estimates baselines through relative rewards within sample batch, removing the need for a critic and making RL fine-tuning more feasible for complex tasks like ours. Generating structured and logically coherent code, especially for multi-step procedures common in CAD model- ing, requires advanced reasoning. Chain-of-Thought (CoT) prompting [30] has proven effective in improving the reasoning and planning capabilities of LLMs by prompting them to generate interme- diate steps. We leverage CoT to enhance the model's ability to decompose complex natural language instructions into coherent CadQuery code sequences.
2.2 CAD Generation
Generative modeling for CAD systems commonly employs two main representations: boundary representation (B-rep) [4] and command sequence representations [32 31. B-rep models combine geometry and topology to offer high precision and accuracy; however, their complexity presents significant challenges for generative modeling. To address this, various models separate latent spaces and decoders for geometry and topology [10 8). Notably, HoLa [17] introduces a unified latent space for B-rep generation. Despite their advantages, direct generation of B-rep models from text remains computationally intensive, as it involves capturing intricate geometric features and interrelationships. Alternativeyy, command sequence representations, such as those proposed by DeepCAD (32), model the procedural nature of CAD design by encoding the design process as series of commands, e.g., sketch creation extrusion. Several approaches 212 4 have demonstrated the ability to generate command sequences from point clouds or images. CAD-MLLM (55 leverages multimodal large language model (MLLM) to enhance the performance of this generation process. In the context of text-to-CAD generation, methods like Text2CAD [13 and CAD- Trannssatt [16] use encoder-decoder architectures to translate textual descriptions into command sequences. Additionally, CAD-Llama [15] and CADFusion (29 employ LLMs to further address the complexity of this task. Recent efforts also study controllability in CAD generation: FlexCAD 41 unifies control across construction hierarchies via structured-tex serialization and LLM fine-tuning, while GeoCAD [40] targets local geometry controllability with mask-and-predde paradigm over captioned local parts. While command sequence representations simplify CAD model generation, they often lack direct connections to the geometric accuracy of the resulting models.
In contrast, our approach leverages CadQuery (7] Python-based parametric library that facilitates programmatic CAD model generation. This representation offers significant advantages, including enhanced editability, better interpretability, and compatibility with LLMs. CAD-Recode (22) gener- ates CadQuery scripts from point clouds, while Quer [2) directly prompts LLMs to produce CadQuery code from text. CAD-A -AD-Asssitant [19, instead, adopts a tool-augmented VLLMM setup built on the FreeCAD Python API to execute modeling operations. These works follow different technical routes; we focus on CadQuery as an intermediate code representation for text-to- -C-DD Beyond 3D CAD, vector graphics (SVG) constitute closely related parametric and programmatic design space. Recent studies on SVG understanding and generation leverage executable code representations and learning signals, e.g., L.L44VV [4 and Reason-SVG (33), underscoring the value of interpretable, code-like geometry- an idea that resonates with adopting CadQuery in our setting.
3

---

3 Methodology
3.1 CadQuery: CAD Representation as Python Code
We adopt CadQuery, Python-based parametric CAD scripting language, as the core representation for 3D modeling in our framework. CadQuery can be executed directly without any external software dependencies. CadQuery allows models to be constructed using chainable geometric operations (e.g.. box O) circle O,, extrude ()), encoded as modular and readable Python code. Each script corresponds to complete, executable modeling procedure that can be rendered directly via the OpenCascade kernel into high-fidelity 3D geometry.
(a) Description
DeepCAD Representation
CadQnery Representation
Ioperation 11 This circutar flange is
20 Cirile a de Cirsta 0.8.25
a aotal conponent featuring a flat
base place with diaseter of 128 and thickness
2k carcle carste 20-5 32 Citcle
va. The design
ludes central. neasuring 50 loperation
sur e- 4 a
holes reasuring equidistant mounting diaseter arranged in circular pattern with dianeter of 99 an around the periphery. loperation 11 The rlange design surrounded by raised concentrie ring an nuter diareter height of that inner dianeter as central, bore.
vs. curite cirite a5
result 8 flarge
the same
Makaple Htlc
Operation 1
Operation
Operation
Figure (a) Text description of CAD model. (b) Corresponding sketch-extrusion command sequence used in DeepCAD. (c) Corresponding CadQuery code used in our method. The bottom row shows the resulting 3D models generated by each of the three sequential operations.
Traditional methods such as DeepCAD
32 represent model structures using sketch-extrude command sequences. As illustrated in Fig. D these representations are typically linearized and low-level, lack modularity, and cannot be directly executed. They often require additional post-preessing produce 3D shapes. This not only increases modeling complexity but also hinders the model's ability to learn structured modeling semantics. In contrast, CadQuery is interpretable and executable. CadQuery provides expressive and flexible geometric operations, ranging from basic primitives to complex modeling procedures. Meanwhile, CadQuery scripts can be directly executed for validation. The provided high-level API can also better align with the input textual description.
Considering the Python nature, CadQuery is well-suited for generative modeling with language models. Nevertheless, a crucial challenge lies in generating code that is both syntactically correct and produces geometrically accurate and valid 3D designs. To address this, our approach employs two-stage training strategy. First, an initial Supervised fine-tuning (SFT) phase teaches the model the specific CadQuery syntax. Then, reinforcement learning (RL. phase is introduced further enhance the geometric accuracy and validity of the generated 3D output.
3.2 CAD-Coder
Overview. We adopt Qwen2.5-7B 2---5-7---nnttre 37
a strong
Code
shhnk,
open-source language model pre-trained on mixture of web text and code, as the base model for CadQuery code generation. The input to the model is natural language description L of the 3D design intent. The output is an executable CadQuery script C' which is executed to pro- duce a 3D geometry M Execute(C'.. The model is fine-tuned and optimized in autoregressive decoding setup, where CadQuery tokens are generated sequentially, conditioned on the input and previous tokens.
daceription Anslyti:
Cocetinute Syster Nurning:
Statch Sonetruction Strateed
Oporation
alen craling Carllorr
</tinks
"Pyythnn
inport cudeuary log loqtter xr1
SFT LLM
wwwnsformellooutee...o
orteen=l0,
192, 142) dlevel 192) stread..1 12'
outnnat 75)1
To better generate CAD models, our method leverages two-stage training strategy. In the first stage, we SFT the LLM with paired data, which enables the model to learn CadQuery's fundamental syntax and common programming patterns. To further enhance the
GRPO
Figure CAD-Coder Training Pipeline

---

geometric reasoning ability of the model, which improves the accuracy of the final 3D model, we introduce the second RL stage with reward specifically designed for CAD.
Stage I: Supervised Fine- Tuning for CAD Code Generation. We begin by performing SFT to equip the model with the basic capability to translate natural language descriptions into executable CadQuery code. Unlike generic code generation, CAD code must follow strict syntactic and geometric constraints. This phase serves as a foundation that enables the model to understand the CadQuery's syntax and learn the basic mapping between high-level descriptions to low-level modeling operations in structured format.
We train on a synthetic high-quality dataset containing 8k examples generated through our data annotation pipeline (see Section 4p. Each training sample is pair (L, Cge), where L is natural language prompt and Cgt is the corresponding ground-truth CadQuery code that has been verified for executability and filtered by geometric correctness.
The model learns to generate a predicted CAD program C = [ token- beeeeeby-token, aiming to approximate the groundtruth program Cgt as closely as possible. We adopt standard autoregressive decoding framework, where the model learns to predict each token of Cgt sequentially given the prompt I. and the preceding tokens. Formally, the loss function is:
Ie log (ee Get, L)
(SF B(L,Cge)DDam
where L denotes the input prompt, Cgt = {ce) represents the ground-trutt code sequence, Cet refers the preceding tokens before step t, To denotes the model policy with parameters and [Cyal is the length of the code sequence.
This allows the model to follow the syntax of CadQuery and establish preliminary mappings between common shape-related language patterns and CAD primitives (e.g. "create a hole" - .hole(), "draw a circle" + ccircle))).
After this stage, the model shows promising capabilities in generating valid CadQuery code for standard and relatively simple modeling cases. However, we observe two major limitations: The generated code sometimes lacks geometric accuracy compared to the target shape, and the model struggles with complex structures that require multi-step or spatial reasoning.
Stage 2: Reinforcement Learning with CAD-Specific Rewards. To address these challenges, introduce a CCAD-Speciff RL stage using Group Reward Policy Optimization (GRPO) to improve the geometric reasoning capability, enhanced with chain-of-thought (CoT) prompting guide structured reasoning. We first cold-starting the model with designed CoT samples to enhance basic reasoning ability. Then, during RI. phase, we specifically introduce Chamfer Distance(CD), common geometric metric, into the reward signal to directly optimize the model based on the 3D output quality instead of token-level loss.
CoT Design. Unlike direct prompt-to-code pairs used in standard SFT, CoT samples are formatted as (Luw, C), where Lew includes step-wise plan embedded in natural language before the final modeling instruction. Considering the hierarchical and compositional nature of CAD modeling, design Leat to simulate engineer's planning process, including component decomposition, coordinate system assignment, sketch design, and extrusion operations each outlined succinctly within cthinko...</thinkks tags. This structured reasoning format helps the model map textual descriptions to executable geometry. These intermediate reasoning steps guide the L.M to break down complex shapes into simpler components aligned with textual description.
Reward Design. During GRPO training, for each input Leots the current policy Te generates A diverse CadQuery candidates components: geometric reward R and format reward Rf
}. The final CAD-Specific reward R; includes two
In contrast to program synthesis tasks where GRPO uses exact match-based rewards, CAD modeling lacks a unique ground-truth code. Multiple solutions can yield identical geometry. To address this, we design a geometric reward based on CD between the rendered 3D model and the target geometry Mgt- For each generated code candidate C, we first attempt execution using the CadQuery engine. If successful, the resulting mesh M, is uniformly sampled into a dense point cloud. Similarly, Mgt is
5

---

also sampled. The CD is then computed between these two point clouds as:
QD(P.Q) = Pl
Σ ZEP
min
- 2l +
Σ
min sEP
|| - v11
(2)
yEQ
where P and are sampled from the predicted shape, and Q and y from the ground-truth shape: |P] and [Q2] denote the number of points in each set.
This metric quantifies the geometric discrepancy between the generated shape and the ground-truth model. Smaller CD values indicate closer geometric alignment.
To convert CD values into reward signals, we define a piecewise geometric reward R Specifically, if the CD is smaller than x 10-5, the candidate is assigned the maximum reward of 1.0. When the CD greater than 0.5, or the code fails to execute, the reward is set For CD values between these thresholds, the reward decreases linearly: CD of 0.5 corresponds to minimum non-zero reward of 0.01, and smaller CD values yield proportionally higher rewards. This design ensures that the model receives continuous geometrie feedback, encouraging approximate yet geometrically close solutions even when exact reconstruction is difficult.
To compute format reward R. we apply regular expression matching to detect whether the output C, contains both <think>... <ittp,..///tin>>>> reasoning block and a properly formatted Python code block (delimited by triple backticks "python ........ () If both are present. R. = 1; otherwise, R! O.
To compute final reward, each CadQuery candidate C, is executed, valid outputs converted into 3D models, and CD is computed with respect to Mgt- The combined reward Rg Ageu R,,00 Amm R. is used compute the relative advantage, and the model is updated via the GRPO loss (Eq. 3
CaRFO (f) = E LaaDD, (Cilter (-mme))
Ic. min (0). Are, clip(r...(),, - 1 1+ 1 33DIL (mo (
(3)
where Leu the input prompt, C2 is sampled code sequence, is the number of samples per prompt, t the token index, the current policy parameter, Osia is the old policy parameter, Ai, is the advantage estimate, e is the clipping threshold, B is the KL penalty weight, ma. Taay and Tee are the current, old, and reference policies.
This training strategy allows the model to continuously refine its code generation towards executable, semantically meaningful, and geometrically accurate CAD outputs.
4 Dataset Construction
We build our dataset based on the Text2CAD dataset [33, which contains 178K natural language descriptions I. paired with ground-truth 3D geometries Mgt- However, Tex12CAD lacks executable CadQuery code aligned with Myt. which poses a major obstacle for training models that generate script-based CAD representations.
To address this, we design a CadQuery data annotation pipeline, as shown Fig. 4 For each sample, we take the CAD command sequence S provided by Tex12CAD (which is structurally aligned with Mge) and prompt a code-generation LLM (DeepSeek-V. -3 (4) generate multiple candidate CadQuery scripts. We attempt to execute each candidate using the CadQuery engine and discard failures. The successfully executed models Meand are compared against Mgt using CD, and we select the candidate with the lowest CD as the final Cge. Note that the mapping from a command sequence (or Mgt) to CadQuery code one-to-many: multiple syntactically different scripts can produce geometrically equivalent shapes. Our selection by minimum CD explicitly preserves geometric equivalence while allowing script diversity; thus Cgt is a verified executable surrogate aligned to Mgt rather than unique textual ground truth.
In total, this pipeline produces 110K valid triplets (L, Cg, Mgt). We further divide them into three subsets based geometric quality: 8k high-quality samples with CDgt 1 x 10 10-4; 70k medium- quality samples with CD2t 1 x 10-3, and the remaining 32k hard cases with CD > 1 x 10

---

Tex12CA
Deepseek-V3
Claude:3.7 sonnet
SFT
Ours w/o SFT
Ours wio CoTT
Ours (Full)
PrTrL
Prrrt
Figure 3: Qualitative comparison between baseline methods and different model variants under various training strategies. Texi22ADDTT is Claude-3.7 represent open-source and proprietary LLMs, respectively. The right columns show our ablations and ull model, which best preserve structure and geometry.
baseline; Deepseek- V3 and
To bootstrap reinforcement learning and enhance structured reasoning, we further construct a set of CoT- foT-mormtteed samples complex shapes. Specifically, we select the hard cases from the dataset, use their description L to prompt DeepSeck-Ve V3 for CoT-style CadQuery code. We leverage the same filtering strategy Fig. 4 retaining samples that executable and exhibit high geometric accuracy based on CD. Each valid candidate is further manually refined for correctness. The final CoT dataset contains 1.5K high-quality CoT samples.
5
Experiments
Metrics. For the Text-to-CAD task, we use metrics adapted from prior 3D generation works [3 (1) Mean CD measures the average geometric discrepancy between the generated and ground-truth models over sampled point clouds. (2) Median CD captures the typical geometric error and is more robust outliers.
(3) Invalidity Ratio (IR) denotes the proportion of generated CadQuery programs that fail to be executed to yield valid 3D geometry. These metrics jointly capture geometric fidelity and executable correctness. We evaluate on official Text2CAD test split. Let L denote the Mataset-provider text prompt. Given L,, our model generates CAD program Cpred and its mesh Mprad Following [13], we apply the same normalization and compute CD between Mpred and the ground-truth mesh Mg. Importantly, our translated CadQuery scripts are never used test ground truth.
Implementation Details. We use Qwen2.5-78 ---2---7-BInstruee 37 as the base model for all experiments, given its strong cesstuctionn-ollowinn and code generation capabilities. For the stage of SFT, we fine-tuned Qwen2.5-7B I--sruuttt for 3 epochs with batch size of 64 and a learning rate of x 10 using the AdamW optimizer
[18]. Training was performed using full-parameter fine-tuning with DeepSpeed ZeRO Stage 2. For the GRPO phase, we initialized the model with SFT weights and trained for epoch with a batch size of 384. To enable cold-starting reasoning during SFT, additionally fine-tuned the model on the 1.5K high-quality CoT-format samples for 2 epochs.
7

---

Syetem prompt
propeey.
LL
Canerated Models
Cq
Modkla
Surple
To Dutoset
Teat
Our Danaont
cq
Python code
Srrund-- nuth Macee
Discord
Puint Medel
CarcCuery
Figure 4: Overview of our annotation pipeline. Given CAD command sequences and natural language DeepSeek- V3 synthesize multiple CadQuery
descriptions from the Tex12CAD dataset, code candidates. These candidates are executed and compared to the ground-trute truth 3D models using the Chamfer Distance (CD). Scripts that execute successfully and achieve the lowest CD are retained. Finally, we construct a dataset comprising text Satt-CadQuery-11 model triplets.
The batch size was set to 384. Each input prompt generated A: = candidate completions. The KL divergence coefficient set to 0.001. All geometric computations, including model execution via CadQuery [7]. point cloud sampling, normalization, and CD calculation, following the Text2CAD 13 implementation to ensure consistency. We utilized the Hugging Face Transformers library, GRPO implementation from Verl [25]. and DeepSpeed for distributed training.
Extended Ablation Studies
For SFT, the 8K high-quality samples. For cold-starting, the 1.5K CoT-format samples. For GRPO, we use all 150K training descriptions and geometries from Tex12CAD. For evaluation, we apply the same synthesis pipeline the official Tex12CAD test set to obtain corresponding triplets.
Baselines. We compare our full method (SFT+COT+GRPO) against several baseline methods for text-to-CAD generation. Tex12CAD 13 directly generates CAD models from natural language descriptions. We also evaluate several LLMs by prompting them directly with natural language descriptions to generate CadQuery code, without any fine-tuning. The baseline LLMs include open-source models Qwen2.5-72B, Qwen2.5-7B, DeepSeek- V3, as well as the proprictary models Claude-3. 7on-entt,, M.aude-3.--ooneet, GPT-4o. For parity, all L.M baselines are prompted with the same CoT-style format used by CAD-Coder; the full prompt is provided Appendix C.
Table 1: Quantitative comparison on the test set. CD metrics are x x00 IR. % indicates Code Invalidity Ratio. Lower CD and lower IR. better.
Method
Mean CD
Median CD
IR.%
Claude-3.7-sonne
186.53
134.16
47.03
GPT-4o
143.5
40.96
70.5
Deepseek-V?
186.69
107.57
51.96
Qwen2.5-72B
209.41
153.81
82.64
Qwen2.5-7B
202.35
169.86
98.83
Tex12CAD [3]
29.29
0.37
3.75
CAD-Coder (Ours)
6.54
0.17
1.45

---

6.1 Main Results
Table summarizess the quantitative performance on the test set. Our full method achieves the best results across all metrics, significantly outperforming prior works in terms of geometric accuracy. Specifically, it reduces the Mean CD to 6.54 and the Median CD to 0.17, 17, both by large margins compared the strong baseline Tex12CAD [33], surpassing all existing L.Mss. Fig. exhibits the qualitative results. We can observe that LLMs frequently fail to generate valid code. Our method can better align with the target shape. These results highlight the effectiveness of our geometry-aware optimization and CoT-enhanced reasoning in generating precise and structurally valid 3D CAD models. Our method also maintains a lower code invalidity ratio, demonstrating that reinforcement- driven learning does not compromise executability.A. experiments were conducted on 8 NVIDIA A800 80GB GPUs. Additional hyperparameter details are provided the Appendix. With vLLM- based serving and KV caching, average decoding latency remains below 1 on mainstream GPUs (H800, A800, RTX 4090, V100) for both CoT-eenaled and SFT decoding. The reported timings reflect token generation only and exclude code execution. Per-GPU results are provided in Table 2
Table 2:
Per-sample inference latency (seconds; lower is better). CoT denotes CoT-enabled decoding; SFT denotes plain decoding without COT.
GPU Model
CoT (8)
SFT (8)
H800 80G
0.06
0.03
A800 80G
0.18
0.12
RTX 4090 24G
0.28
0.16
V100 32G
0.64
0.29
6.2 Ablation Study
Table isolates the effect of each component in the training pipeline, Starting from a model trained solely with SFT, we observe limited geometric fidelity (Mean CD 74.55, Median CD 0.33). This baseline demonstrates that SFT alone cannot adequately capture spatial reasoning for complex CAD structures. However, the model also performs poorly (Mean CD 76.20) without SFT, showing the necessity of using prior knowledge. Even without COT,, the GRPO alone dramatically boosts performance (Mean CD 17.34, Median CD 0.20), confirming that CAD-Specific reward supervision is essential for improving 3D accuracy. Our full method, adding CoT prompting for cold-starting, further improves results (Mean CD 6.54, Median CD 0.17), indicating that structured multi-step reasoning enhances the model's ability to handle complex geometric prompts. Fig. 5 iillustrates the CD distributions the generated model under different training strategies. We can observe that more effective training strategies result in distributions that are skewed towards smaller CD values and fewer invalid results. Fig. reveals the visualization results with different components. Experimental results demonstrate the effectiveness of each component.
Table Ablation study results on the test set us-
ing Qwen2.5-7B-Innstee CD) metrics are x 10
Table 4: Ablation study: effect of sft training data quality.
Training Strategy
Mean CD,
Med CDJ
IR %1
Dataset
Mean CDJ,
Med CDJ.
IR %
SFT
74.55
0.33
5.33
Ours w/o SFT
76.20)
0.95
5.33
Ours w/ 70K
9.89 6.54
0.18 0.17
3.21
Ours w/o CoT
17.34
0.20
4.95
Ours w/ 8K
1.45
Ours (Full)
6.54
0.17
1.45
In Table 4 we explore how different SFT training data affect final model performance. Training with the full 70K medium- -uallity dataset during SFT leads to substantial improvement over existing methods (Mean CD 9.89). However, training with smaller but high-quality 8K dataset yields the best result (Mean CD 6.54, Median CD 0.)7), outperforming the larger dataset. These results reveal key insight: quality outweighs quantity. High-precision data offers better foundation for CAD-Specific RL, considering that small inconsistencies in code can lead to significant errors in CAD geometry.

---

CD Disribution Jos6s To Rithood owtr margod
040
163-1a2
184-100
Jut
1030
X03
300 400E
5900
(a)
(b)
Figure 5: (a) Chamfer Distance (CD) distributions of generated CAD models trained with different strategies. (b) Visualizations of predicted CAD models across three CD intervals. Gray shapes represent ground-truth models, while brown shapes denote generated models. The first row shows results with CD
10-1, indicating that the generated CAD models differ substantially from the ground truth. The second row presents models with 1 x 10 < CD I x x10-1, and the third row displays models with CD < 1 10-4 indicating that these models are nearly identical the ground -round-truth truth models.
7 Conclusion
In this paper, we have presented novel approach to text-to-CAD generraion by leveraging CadQuery as an intermediate representation. By combining the strengths of Python-basee code generation and the inherent interpretability of CadQuery, method overcomes key challenges associated with traditional command sequence-based approaches, including model validity and limited operation sets. We propose two-stage training strategy combining supervised fine-tuning (SFT) with reinforcement learning (RL). The integration of Group Reward Policy Optimization (GRPO) and CAD-Speciie reward function ensures that the generated CAD models are both syntactically correct and geomet- rically plausible, while the Chain-of Thain-of-Thought (CoT) process allows for improved reasoning and planning. Our large-scale, geometrically verified dataset facilitates further research in this domain, and the experimental results show that our method significantly advances the capabilities of LLMs in generating complex CAD models from natural language descriptions. This work opens the door to more accessible, efficient, and flexible CAD generation, making it easier for both novice and experienced users create high-quality 3D models based on textual input.
Limitations and future work: While CAD-Coder achieves strong performance, several limitations remain. First, the model currently does support multimodal inputs such as images point clouds, which restricts its applicability in real-world design scenarios. Second, although CoT prompting enhances reasoning, remains shallow and often fails on extremely complex spatial compositions. Third, the reward design primarily relies on Chamfer Distance and format checks, limiting fine- grained structural supervision. Future work could extend the framework to broader set of CAD operations and further optimize LLM planning and reasoning.
Acknowledgments
This work was supported in part by the National Key Research and Development Project of China (No. 20222D01 17801) and the Young Elite Scientists Sponsorship Program by CAST, in part by the National Natural Science Foundation of China (Nos. 62572039, 62461 160331, and 62132001), and in part by the Fundamental Research Funds for the Central Universities. This work was also supported by the NSFC/RGC Collaborative Research Scheme (CRS HKKKH/2KU3//) Dr. Xu's research work described in this paper was conducted in the JC STEM Lab of Multimedia and Machine Learning, funded by The Hong Kong Jockey Club Charities Trust.
10

---

References
[1] Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang. Carrie Cai, Michael Terry, Quoc Le, et al. Program synthesis with large language models. arXiv preprint vrXiv:2108.07735 2021.
[2] Akshay Badagabettu, Sai Sravan Yarlagadda, and Amir Barati Farimani. Query2cad: Generating cad models using natural language queries. arXiv preprint arXiv:2406.0014 2024.
[3] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert- Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Josh Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, llya Sutskever, and Wojeiech Zaremba. Evaluating large language models trained code, 2021.
[4] Tianrun Chen, Chunan Yu, Yuanqi Hu, Jing Li, Tao Xu, Runlong Cao, Lanyun Zhu, Ying Zang, Yong Zhang, Zejian Li, et al. Img2cad: Conditioned 3d cad model generation from single image with structured visual geometry. arXiv preprint arXiv:2410.0344
2024.
[5] Haoxuan Deng, Samir Khan, and John Ahmet Erkoyuneu. An investigation on utilizing large language model for industrial computer-aides design automation. Procedia CIRP, 128:221-226 2024.
[6] Yuanzhe Deng, James Chen, and Alison Olechowski. What Sets Proficient and Expert Users Apart? Results of Computer-Aide Design Experiment. Journal of Mechanical Design, 146(1):011401, 10 2023.
[7] CADQuery Developers. Cadquery: A python parametric cad scripting framework. www.thedocs..c.ee. 1 2024. Accessed: 2024- 10-22.
https
[8] Haoxiang Guo, Shilin Liu, Hao Pan, Yang Liu, Xin Tong, and Baining Guo. Complexgen: Cad reconstruction by b-rep chain complex generation. ACM Transactions Graphics (TOG), 2022.
[9] Jiangyong Huang, Baoxiong Jia, Yan Wang, Ziyu Zhu, Xiongkun Linghu, Qing Li, Song- Chun Zhu, and Siyuan Huang. Unveiling the mist over 3d vision-language understanding: Object-centric evaluation with chain-of-analysiee arXiv preprint arXiv:2503.224200 2025.
[10] Pradeep Kumar Jayaraman, Joseph G Lambourne, Nishkrit Desai, Karl DD Willis, Aditya Sanghi, and Nigel JW Morris. Solidgen: An autoregressive model for direct b-rep synthesis. Transaction in Machine Learning Research, 2023.
[11] Timo Kaufmann, Paul Weng, Viktor Bengs, and Eyke Hüllermeier. A survey of reinforcement learning from human feedback, 2024.
[12) 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, pages 4713-4722, 2024.
[13) Mohammad Sadil Khan, Sankalp Sinha, Talha Uddin, Didier Stricker, Sk Aziz Ali, and Muham- mad Zeshan Afzal. Text2cad: Generating sequential cad designs from beginner-to-expertt level text prompts. Advances in Neural Information Processing Systems, 37:7552-7579, 2024.
[14] Sebastian Koch, Albert Matveev, Zhongshi Jiang, Francis Williams, Alexey Artemov, Evgeny Burnaev, Marc Alexa, Denis Zorin, and Daniele Panozzo. Abe: A big cad model dataset for geometric deep learning. In Proceedings of the IEEF/CVF conference on computer vision and pattern recognition, pages 9601-9611, 2019.

---

[15] Jiahao Li, Weijian Ma, Xueyang Li, Yunzhong Lou, Guichun Zhou, and Xiangdong Zhou. Cad-Ilama: Leveraging large language models for computer-aided design parametric 3d model generation. arXiv preprint urXiv:25005. 04481, 2025.
[16] Xueyang 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 on Multimedia, pages 8461-8470 2024.
[17] Yilin Liu, Duoteng Xu, Xingyao Yu, Xiang Xu, Daniel Cohen-Or, Hao Zhang, and Hui Huang. Hola: B-rep generation using a holistic latent representation. arXiv preprint arXiv:2504. 14257, 2025.
[18] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.
[19] Dimitrios Mallis, Ahmet Serdar Karadeniz, Sebastian Cavada, Danila Rukhovich, Niki Foteinopoulou, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. Cad-assistant: Tool- augmented vlims as generic cad task solvers? arXiv preprint arXiv:2412.1388 2024.
[20] Josh OpenAL, Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Floren- cia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 2023.
[21] David Robertson and Thomas Allen. Cad system use and engineering performance. IEEE Transactions on Engineering Management, 40(3):274-282, 1993.
[22] Danila Rukhovich, Elona Dupont, Dimitrios Mallis, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. Cad-recode: Reverse engineering cad code from point clouds. arXiv preprint arXiv:2412. 14042, 2024.
[23] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov, Proximal policy optimization algorithms. arXiv preprint arXiv:1707.066 707.06347, 2017.
[24] Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song. Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint Xxxv:22402.033000 2024.
[25] Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework. arXiv preprint arXiv: 2409. 19256, 2024.
[26] Yuewan Sun, Xingang Li, and Zhenghui Sha. Large language models for computer-aided design (1m4cad) fine-tuned: Dataset and experiments. Journal of Mechanical Design, pages 1-19, 2025.
[27] Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timo- thée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2202.11397 2023.
[28] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.
[29] Ruiyu Wang. Yu Yuan, Shizhao Sun, and Jiang Bian. Text-to-cad generation through infusing visual feedback in large language models. arXiv preprini arXiv:2501. 2025.
[30] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, brian ichter, Fei Xia, Ed H. Chi, Quoe V Le, and Denny Zhou. Chain of thought prompting elicits reasoning in large language models. In Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho, editors, Advances in Neural Information Processing Systems, 2022.
12

---

[31] Karl DD Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G Lambourne, Armando Solar-Lezama, and Wojciech Matusik. Fusion 360 gallery: A dataset and environment for programmatic cad construction from human design sequences. ACM Transactions on Gruphics (TOG), 10(4))1-24, 2021.
[32] Rundi Wu, Chang Xiao, and Changxi Zheng. Deepcad: deep generative network for computer- aided design models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 6772-6782, 2021.
[33] Ximing Xing, Yandong Guan, Jing Zhang, Dong Xu, and Qian Yu. Reason-svg: Hybrid reward for aha-moments in vector graphics generation. arXiv preprint arXiv:2505.24499 2025.
[34] Ximing Xing, Juncheng Hu, Guotao Liang, Jing Zhang, Dong Xu, and Qian Yu. Empowering Ilms to understand and generate complex vector graphics. arXiv preprint 1rXiv:2412.11102, 2024.
[35] Jingwei Xu, Zibo Zhao, Chenyu Wang. Wen Liu, Yi Ma, and Shenghua Gao. Cad-mllm: Unify- ing multmmodaity-condiiioro cad generation with milm. arXiv preprint arXiv:2411.04995 2024.
[36] Xiang Xu, Joseph G Lambourne, Pradeep Kumar Jayaraman, Zhengqing Wang, Karl DD Willis, and Yasutaka Furukawa. Brepgen: A b-rep generative diffusion model with structured latent geometry. ACM SIGGRAPH, 2024.
[37] An Yang, Baosong Yang. Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan
Li, Dayiheng Liu, Fei Huang, Haoran Wei, Huan Lin, Jian Yang. Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxi Yang, Jingren Zhou, Junyang Lin, Kai Dang, Keming Lu, Keqin Bao, Kexin Yang, Le Yu, Mei Li, Mingfeng Xue, Pei Zhang, Qin Zhu, Rui Men, Runji Lin, Tianhao Li, Tingyu Xia, Xingzhang Ren, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yu Wan, Yuqiong Liu, Zeyu Cui, Zhenru Zhang, and Zihan Qiu. Qwen2.5 technical report. arXiv preprint arXiv:2412.15115, 2024.
[38] Jirong Zha, Yuxuan Fan, Xiao Yang, Chen Gao, and Xinlei Chen. How to enable IIm with 3d capacity? a survey of spatial reasoning in Ilm. arXiv preprint arXiv:2504.05786, 2025.
[39] Weichen Zhang, Ruiying Peng. Chen Gao, Jianjie Fang. Xin Zeng, Kaiyuan Li, Ziyou Wang, Jinqiang Cui, Xin Wang, Xinlei Chen, al. The point, the vision and the text: Does point cloud boost spatial reasoning of large language models? arXiv preprint 24Xi5:2504.045500 2025.
[40] Zhanwei Zhang, Kaiyuan Liu, Junjie Liu, Wenxiao Wang, Binbin Lin, Liang Xie, Chen Shen, and Deng Cai. Geocad: Local cootetty-controllbbee cad generation. arXiv preprint arXiv:2506. 10337, 2025.
[41] Zhanwei Zhang, Shizhao Sun, Wenxiao Wang. Deng Cai, and Jiang Bian. FlexCAD: Unified and versatile controllable CAD generation with fine-tuned large language models. In The Thirteenth International Conference on Learning Representations, 2025.
13

---

NeurIPS Paper Checklist
The checklist is designed encourage best practices for responsible machine learning research, addressing issues of reproducibility, transparency, research ethics, and societal impact. Do not remove the checklist: The papers not including the checklist will be desk rejected. The checklist should follow the references and follow the (optional) supplemental material. The checklist does NOT count towards the page limit.
Please read the checklist guidelines carefully for information on how to answer these questions. For each question in the checklist:
You should answer [Yes], [No], or [NA].
[NA] means either that the question Not Applicable for that particular paper or the relevant information is Not Available.
Please provide short (1-2 sentence) justification right after your answer (even for NA).
The checklist answers are an integral part of your paper submission. They are visible to the reviewers, area chairs, senior area chairs, and ethics reviewers. You will be asked to also include (after eventual revisions) with the final version of your paper, and its final version will published with the paper.
The reviewers of your paper will be asked use the checklist as one of the factors their evaluation. While "[Yes] is generally preferable to "[No]" ", it is perfectly acceptable to answer "[No] providedd proper justification is given (e.g.. "error bars are not reported because it would be too computationally expensive" or "we were unable to find the license for the dataset we used"). In general, answering binary way, we
"[No] or "[NA]" is not grounds for rejection. While the questions are phrased acknowledge that the true answer is often more nuanced, please just use your best judgment and write justification to elaborate. All supporting evidence can appear either in the main paper or the supplemental material, provided in appendix. If you answer [Yes] to a question, in the justification please point to the section(s) where related material for the question can be found.
IMPORTANT, please:
Delete this instruction block, but keep the section heading "NeurIPS Paper Checklist",
Keep the checklist subsection headings, questions/answers and guidelines below.
Do not modify the questions and only use the provided macros for your answers.
1. Claims
Question:
Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results be expected to generalize other settings.
is fine include aspirational goals as motivation long is clear that these goals are not attained by the paper.
2. Limitations
Question:
Does the paper discuss the limitations the work performed by the authors?
Answer: [Yes]
Justification: [Yes]
14

---

Guidelines:
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create a separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, c.g., if the approach was only tested few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect on the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails handle technical jargon.
The authors should discuss the computational efficiency the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer:[NA)
Justification: [NA]
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proofs can either appear in the main paper the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide short proof sketch provide intuition.
Inversely, any informal proof provided in the core of the paper should complemented by formal proofs provided in appendix supplemental material.
Theorems and Lemmas that the proof relies upon should properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that it affects the main claims and/or conclusions the paper (regardless whether the code and data are provided or not)?
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the paper does not include experiments.
15

---

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurlPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily new algorithm, the paper should make it clear how to reproduce that algorithm. (b) the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.
(c) If the contribution is new model (e.g., a large language model), then there should either be way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome describe the particular way they provide for reproducibility. the case of closed-source models, it may be that access to the model is limited in some way (e.g., registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described in supplemental material?
Answer: [No]
Justification:
[No]
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS code and data submission guidelines (nttps://nips.co
for more details.
While we encourage the release of code and data, we understand that this might not be possible, so "No" an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines (https
7 /ttppp.cc/pbllc/guudeeee http://oddbbbbiiiooooooooooooooo
for more details.
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
16

---

Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Question:
Answer:
[Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented the core the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results accompanied by error bars, confi- dence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
It should be clear whether the error bar is the standard deviation or the standard error of the mean.
OK to report 1-sigma error bars, but one should state The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that out of range (e.g. negative error rates).
If error bars reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
Question:
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the paper does include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
17

---

The paper should provide the amount of compute required for each of the individual experimental runs as well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics htttps///eerriss..cppbbbbc/iiiie
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.
The authors should make to preserve anonymity (e.g.. if there special consid- eration due to laws or regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that there no societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release models, providing defenses in addition attacks, mechanisms for monitoring misuse, mechanisms to monitor how system learns from feedback over time, improving the efficiency and accessibility ML).
11. Safeguards
Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, scraped datasets)?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper poses such risks.
18

---

Released models that have high risk for misuse or dual use should be released with necessary safeguards to allow for controlled use of the model. for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Are the creators original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Question:
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the paper does not use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset used and, if possible, include URL.
The name of the license (e.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.
If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswi thcode. com datasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
For existing datasets that are re- re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
If this information is not available online, the authors are encouraged to reach out to the asset's 's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent obtained from people whose asset is used.
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well details about compensation (if any)?
Answer: [NA]
Justification: [NA]
19

---

Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included the main paper.
According to the NeurIPS Code Ethics, workers involved in data collection, curation, other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Depending on the country in which research is conducted, IRB approval (or equivalent)
may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods this research? Note that if the L.M used only for writing, editing, or formatting purposes and does not impact the core methodology. scientific rigorousness, or originality the research, declaration is not required.
Answer: [Yes]
Justification: [Yes]
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs any important, original, non-standard components.
Please refer to our LLM policy (ttp::////errrppccccooofrrrreerp for what should or should not be described.
20

---

Overview of Supplementary Material
This supplementary material provides additional details in support of our main paper, CAD-Coder: Text-to-CAA CAD Generation with Chain-of-Thought and Geometric Reward. The contents are organized as follows:
In Section we describe the hardware and software configurations, training durations for different stages, and the Chamfer Distance (CD) evaluation protocol.
In Section we show that using only Chamfer Distance as reward leads to training failure, emphasizing the importance of multi-faceted reward design.
we present detailed breakdown of the CAD generation process, including the user prompt and CoT prompt, CoT reasoning steps, and the final CadQuery output.
In Section C
In Section D
we provide additional qualitative comparisons between different methods.
In Section
present several examples to show that CAD-Coder supports CAD editing. we analyze failure cases where our method underperforms.
In Section
A
Additional Implementation Details
All experiments were executed on a cluster equipped with 8 NVIDIA A800 (80GB) GPUs. The SFT stage trained for 7 hours, while the GRPO stage required 146 hours, both utilizing distributed training with standard data parallelism techniques, facilitated by DeepSpeed and Ray. For efficient model inference, employed vL.LM, and used CadQuery (version 1.3.1) for CAD script execution and validation.
Chamfer Distance (CD) was computed using the same implementation as in Tex22CD [3] ensuring a fair and reproducible comparison. The CD calculation relies on the normalization of the generated 3D mesh models, which is critical for consistent metric evaluation. While CAD-Translator [6] and CAD-LLaMA [1]] address similar tasks, their implementations are not open-sourced, and the details of their normalization procedures remain unclear. As a result, although their papers report CD scores, the values differ by an order of magnitude compared to those reported by Text2CAD, making direct comparison infeasible.
B Extended Ablation Studies
To further analyze the impact of our proposed reward design, we conducted an ablation study by disabling all auxiliary components and retaining only the Chamfer Distance (CD) as the reward func- tion during the GRPO training phase. All other settings, including model architecture, optimization strategy, and data pipeline, remained unchanged.
However, as training progressed, we observed that the model began to generate invalid CadQuery code after approximately 200 steps. This led to frequent failures during the reward evaluation stage, as the CD computation relies on successful execution of the generated scripts to produce mesh outputs. Once invalid syntax or structural inconsistencies occurred, the reward pipeline could longer provide feedback, which ultimately caused the reinforcement learning to halt prematurely.
These results highlight the critical role of robust code supervision and reward shaping beyond pure geometry-bast based metrics, especially in code- sede-generation scenarios where exccutability directly impacts learning stability.
21

---

C Step-by-Step CoT Reasoning in CAD Generation
To illustrate the step-by-step reasoning performed by our model prior to generating CadQuery scripts, we present an example corresponding to the first CAD model shown in Fig. [ The user-provided prompt specifies precise geometric operations, which our model parses into a structured CoT (Chain- of-Thought) reasoning sequence. This sequence includes part decomposition, coordinate planning, sketch construction, and extrusion logic. The CoT reasoning is followed by executable CadQuery scripts that constructs the final 3D model. This example demonstrates the model's ' ability to convert complex, multi-step textual descriptions into valid, parameterized CAD scripts through interpretable and systematic reasoning.
Input
User Prompt: "Start by creating new coordinate system for the first part, setting the Euler angles to 10.0, 0.0, -90.0] and the translation vector to [0.0, 0.0, 0.0]. Next, draw a two-dimensional sketch on a new face, forming loop with with lines: the first line starts at (0.0, 0.0) and ends at (0.375, 0.0); the second line starts at (0.375, 0.0) and ends at (0.375, 0.375); the third line starts (0.375, 0.375) and ends at (0.0, 0.375); and the fourth line starts at (0.0, 0.375) and ends at (0.0, 0.0). Apply a sketch scale of 0.375 to this loop. Rotate the scaled sketch using the Euler angles [0.0, 0.0, -90.0] and translate it using the translation vector [0.0, 0.0, 0.0]. Finally, extrude the sketch 0.375 units in the direction opposite to the normal to create a solid body with final dimensions of 0.375 units in length, width, and height. For the second part, create another new coordinate system, setting the Euler angles to [-90.0, 0.O. -90.0] and the translation vector to [0.375, 0.125, 0.0]. Draw new two-dimensional sketch the first line starts at (0.0, 0.0) and ends at (0.25, 0.0); the second line starts (0.25, 0.0) and ends at (0.25, 0.25); and the third line starts at (0.25, 0.25) and ends at (0.0, 0.0). Apply a sketch scale of 0.25 to this loop. Rotate the scaled sketch using the Euler angles [-90.0, 0.0, -90.0] and translate it using the translation vector [0.375, 0.125, 0.0]. Extrude the sketch 0.375 units in the direction of the normal and add this extruded shape to the existing cube. The final dimensions of this rectangular prism are 0.25 units in length, 0.25 units in width, and 0.375 units in height." "
new face, forming loop with three lines:
Please create CadQuery Python code to generate model based on the following description. The reasoning process MUST BE enclosed within <think> </hink> tags. The final CadQuery code MUST BE put in "pyython code with ONLY the executable code inside the python box, nothing else. The final model represented by In the <think> section, simulate the thought process of an engineer converting text descriptions into a CAD model. Follow these steps:
CoT Prompt:
Stage 1: Description Analysis. Break down the description into different parts components. Identify key parameters for each part (coordinate systems, Euler angles, translation vectors). Understand the spatial relationships and assembly sequence between parts.
Stage 2: Coordinate System Planning, Determine the coordinate systems used for each part. Parse how Euler angle rotations and translation vectors are applied. Ensure understanding of local-to-global coordinate system transformations.
Stage 3: Sketch Construction Strategy. Analyze how to create each 2D sketch (loops, lines, points). Determine scaling factors for each sketch. Plan how to transform sketches into 3D space.
Stage 4: Extrusion Operation Planning. Identify extrusion parameters for each part (direction, distance). Understand how to add extrusions to existing solids (new or merge). Verify dimensions after extrusion match the description.
Stage 5: Code Implementation Strategy. Plan the sequence of CadQuery operations. Determine necessary CadQuery functions and methods. Consider how to organize code for clarity and readability.
22

---

Stage 6: When scaling in CadQuery. Directly scale the size, define a scaling factor variable, and apply the scaling factor directly to all coordinates and dimensions. Don't t try to use a non-existent ".scale()' method on Workplane objects.
After your thinking process, provide clean, working CadQuery Python code to create the 3D model. Think step by step, but only keep minimum draft for each thinking step, with 50 words at most. description:
Output
CoT Reasoning Steps (Generated by CAD-Coder):
1. ** Description Analysis**:
Two parts: first rectangular prism, second triangular
prism
First part has dimensions 0.375+0.375*0 375, rotated -90 about 2
375, rotated -0 about X and z 2. Coordinate System Planning**:
Second part is
translated
0.375,0.115.
First part uses identity Cs, second rotated -90 x/-90 at 30.375,0.125,4
Both parts translate to origin initially
3. Sketch Construction Strategy**;
First part: 4-line rectangle sketch Second part: 3-line triangular sketch
Apply scaling factors (0.375 and 0.25) to coordinates
4. Extrusion Operation Planning**:
First part extruded -0.3752
Second part extruded +0.3752
Combine using union operation
5. Code Implementation Strategy**: Create base sketches Apply rotations and translations Extrude combine
Generated CadQuery Script:
import cadquery part
Firat
part1
(eg. Workklare ('IY")
nooveTo (0.0 0.0)
-iinnTo 0.375)
IilnTTo 0.375)
-clexe (-0.375)
rotate (10,000), (1,0,0), 90) (tranllat((00.00 0.0, 0.0))
port
part2
(eq. ("EV)) (0.00 0.0)
-lieeTo (0.25, 0.0)
.1inaTo
ccooo
eextrude (0.375)
rotate ((0,0,0)
(1,0,0). 90)
Figure S1: Generated CAD Model
rrotate (0,0,1),
tranelate (r005)aate(003375 370.375, 0.125, 0.03)
Combsne
23

---

D
Additional Qualitative Comparisons Across Methods
Fig. S2
presents additional qualitative comparisons of CAD models generated by different methods. For methods that do not produce valid 3D models, placeholders are shown in their respective results.
GT
Tex12CAD
Deepseek .V3
Claude-3.7 sonnet
SFT
Ours w/o SFT
Ours CoT
Ours (Full)
Figure S2: Additional qualitative comparisons of CAD models generated by different methods.
24

---

E Performance on CAD Editing
Although our model was not explicitly trained on CAD editing data, it demonstrates promising capabilities in handling simple CAD editing tasks based on user instructions. This suggests that the model has acquired a degree of structural understanding of CadQuery code and can generalize beyond the training objective of generation generation-from-scaath from-scratch.
As shown in Fig. S3 the model successfully performs lightweight operations such as modifying object dimensions, removing a component, or adjusting translation and rotation parameters in response to natural language prompts. These preliminary results highlight the model's 's potential to be extended toward interactive or instruction-following CAD editing scenarios.
Lattering Rl litt
SAY within care 24 ptranttry netitied ThE codet Cartun data SAUR reace
Ca 1:ST
paristerr den S0 seaptrr Liartin Sca wot.aaa Frecunly Laare
and sale
maa,, but city sicies crers and SHEmiy Ins, tost.
coe Concit Cartent CaMMro Karapaa Onl Copp
correcooes 10n0) ot ant by
al GaESS
Grigiial Cats:
teciteriaal sarel
2011
300 wcc.
cpnnet sete
with 1947)
with soded
-ore clat To, diol, Pabll, 601
-claaal
Figure S3: Examples of simple CadQuery code editing based on instructions.
F
Failure Cases
As shown in Figure S4. our method still struggles with certain challenging cases. As illustrated in Fig. Wig.(S4a), a). our method still struggles with complex structures composed of multiple sub-components, where inaccurate spatial alignment between modules can lead to visible dislocations or offsets. Moreover, shown in Fig. b), the model may misclassify operations such extrusion and cutting, resulting in geometries that deviate from the intended design. In addition, Fig. [5fc) highlights the challenge posed by very thin structures internal cavities, where sparse point sampling may induce reward hacking behavior, revealing limitations in handling overlapping features and tight geometric tolerances.
GT
Ours
GT
Ours
GT
Ours
(a)
(b)
(c)
Figure $4: Examples of failure cases.
25


Reviews:
[{"review_id": "3qzG53Nz3U", "reviewer": "Reviewer_vKK8", "summary": "This paper presents CAD-Coder, a text-conditioned large language model (LLM) for generating CAD models in the form of CadQuery code. The proposed pipeline first undergoes supervised fine-tuning, followed by Group Reward Policy Optimization using a geometry-aware reward based on Chamfer Distance and an auxiliary format-consistency reward. To support training, the authors introduce a dataset of 110k triplets created by translating Text2CAD command sequences into CadQuery code. CAD-Coder achieves lower Chamfer Distance compared to Text2CAD and general-purpose LLMs.", "questions": "- Could the authors address the concerns on the data synthesis pipeline (first mention weakness above)?\n\n- Could the authors provide details on how the GPT-4o baseline was constructed, including prompt design and use of examples? What explains the relatively low 93% instruction rate, given recent improvements in LLMs?\n\n- Could the authors elaborate on the training setup for the SFT baseline and explain its underperformance, especially in simple cases? Is this potentially linked to limitations in the data synthesis process?", "limitations": "The limitations are addressed in a dedicated paragraph.", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 3, "strengths_and_weaknesses": "**Strengths** \n\n- Text to CAD is rapidly gaining attention and the community needs stronger baselines on popular LLMs. The reviewer thinks that this paper is well aligned with current interests.     \n\n- Switching from CAD token sequences to a Pythonic CAD API such as CADquery brings multiple benefits. CADquery is well suited for generation via LLMs, compact and editable by engineers.     \n\n- The authors adapt proven LLM techniques to CADQuery generation, showing how methods like SFT, CoT, and GRPO can be effectively transferred to structured code tasks, offering useful insights for both CAD and ML research.\n\n\n**Weaknesses**\n \n-  The data synthesis pipeline appears suboptimal. Intuitively, this translation task is not especially difficult, given that the LLM is provided with the full input sequence. However, the quality of the translated data significantly impacts the reported performance throughout the paper. The proposed translation method yields near-identical results for only a small subset of the samples (8k out of 178k with very low Chamfer Distance). The authors themselves note that training on a larger dataset of medium-quality translations leads to worse performance. Moreover, the test set is generated using the same translation pipeline, which fails for a large portion of the data (32k out of 178k, or about 17%). This raises concerns about the fairness of comparisons with Text2CAD, given that the evaluation relies on noisy test data.\n \n-  The quality of the baseline comparisons raises concerns. In the reviewer's experience, GPT models are increasingly capable of generating valid CadQuery code. However, in Table 1, the authors report only a 93% instruction rate (IR) for GPT-4o, which suggests suboptimal prompting, potentially due to inadequate instructions or a lack of in-context examples. Moreover, the paper provides no details on how the LLM baselines were constructed, making it difficult to assess the validity of the comparison.\n \n- The reviewer is also concerned about the results in Table 2, particularly the poor performance of the supervised fine-tuning (SFT) baseline. It is surprising that SFT underperforms, especially considering that Text2CAD, which uses a significantly smaller model than Qwen2.5-7B-Instruct, achieves better results without any reinforcement learning. This discrepancy is also visible in Figure 3, where the SFT variant fails to generate simple geometries in response to straightforward prompts, such as those shown in the first row. These unintuitive results may be linked to the limitations of the data synthesis pipeline.\n\n- Given the paper's focus on Pythonic CAD generation, the proposed data synthesis approach could be extended to other aspects of code quality, such as adding comments, choosing meaningful variable names, or structuring code more clearly.     \n\n- CADAssistant is incorrectly described as using CadQuery, whereas it actually relies on the FreeCAD Python API.\n \n- Authors do not clarify if they will release the constructed CADQuery dataset", "was_revised": true, "final_justification": "The authors addressed most of the concerns raised in the rebuttal (SFT performance and data quality). The reviewer recommends that the authors incorporate the clarifications and the discussions in the updated version of the paper.", "rebuttal": "# Response to Reviewer vKK8\nThank you for your thorough review and constructive feedback. We appreciate your recognition of our work’s alignment with current research trends, the benefits of using CadQuery as a Pythonic CAD API, and the effective adaptation of LLM techniques (SFT, CoT, GRPO) to structured CAD code generation. These comments are encouraging and helpful. We address your concerns in detail below and will incorporate all suggestions in the next version of the paper.\n## W1 & Q1: Data Synthesis Pipeline\n**Challenge of Identical Model Generation**: Obtaining identical models by translating from command sequences to CadQuery scripts is not straightforward. The mapping between CAD command sequences and CadQuery scripts is inherently one-to-many: a given command sequence can be implemented through various syntactically different, yet functionally equivalent, CadQuery scripts. Consequently, translated CadQuery scripts may differ from the original command sequences, leading to potential discrepancies.  \n\n**Data Quality**: It is important to clarify that the 8k samples we use are the highest-fidelity subset. We strategically selected this subset for the initial Supervised Fine-Tuning (SFT) stage to ensure the model acquires a robust syntactic and semantic foundation. Our experimental results (Table 3) validate our choice, and we believe this insight is valuable for future work, i.e.,  for SFT, especially when followed by post-training, data quality overweights quantity.  \n\n**Test Set Fairness**: We apologize for any confusion. The evaluation set remains identical to that of the Text2CAD[1] dataset to ensure fair comparison. Specifically, during evaluation, we compute the Chamfer Distance between the generated models (from predicted CadQuery scripts) and the ground truth CAD models provided by DeepCAD. Thus, the comparison across methods is fair and consistent.\n## W2 & Q2: Baseline Comparison Quality\n**Baseline Details**: To ensure a faire comparison, we use the same CoT prompt for all LLM baselines, as described in Sec. C of the Supplementary Material.  \n\n**GPT-4o Performance**: Regarding GPT-4o’s performance, we attribute its results to several factors. (1) The primary challenge is the domain-specific complexity of our data, which consists of expert-level prompts that general-purpose models often struggle to interpret. (2) We also observed that deprecated CadQuery syntax (due to API updates) may negatively affect GPT-4o’s outputs. To address this, we re-evaluated GPT-4o by accepting generated CadQuery code as valid if it is functionally correct, even when using deprecated syntax. Under this criterion, its invalid rate (IR) drops to 70.5%. Notably, a similar invalid rate (74.26%) was reported for GPT-4o in the recent CADFusion[2] paper, indicating a broader limitation of general-purpose LLMs on CAD-specific generation tasks. Furthermore, following your suggestion, we experimented with in-context learning by providing an example to GPT-4o; however, this resulted in even lower performance.\n## W3 & Q3: SFT Performance\nThank you for raising this point. The underperformance of our SFT-only model is expected, as it serves merely as a lightweight initialization for our core GRPO stage, not as the final model. We deliberately train SFT on a small, high-purity dataset (8k samples) to teach basic CadQuery syntax, providing a solid foundation for subsequent reinforcement learning. Therefore, comparing the SFT-only model’s performance to the fully supervised Text2CAD model (trained on 178k samples) is not a fair comparison.\nAs shown in Fig. 3, most examples represent complex cases, demonstrating the superiority of our final model after incorporating the GRPO stage. Fig. 5(a) indicates that the SFT-only model performs well on simpler shapes, with over 4,500 samples achieving a Chamfer Distance below 1e-3, confirming that it learns a solid foundational understanding.\n## W4: Code Quality Extensions\nThank you for your suggestion. As shown in Sec. C of the Supplementary Material, our CoT prompts encourage code comments during data synthesis, which we found improves the model’s understanding of geometric intent. We agree that using meaningful variable names and clearer code structuring would further enhance data quality, and we plan to incorporate these improvements in future work.\n## W5: CADAssistant Clarification\nThank you for pointing this out. We will correct it in the next version. \n## W6: Dataset and Code Release\nWe are committed to fully open-sourcing the following upon paper acceptance: the constructed CADQuery dataset, model weights, and inference code.\n\n[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. NIPS 2024.  \n\n[2] Text-to-CAD Generation Through Infusing Visual Feedback in Large Language Models. ICML 2025."}, {"review_id": "NgMeSt2kpx", "reviewer": "Reviewer_Sray", "summary": "This paper introduces CAD-Coder, a new framework that translates natural language into CadQuery scripts. It features a two-stage training approach combining supervised learning and reinforcement learning with GRPO, along with a chain-of-thought planning process. The results show that CAD-Coder improves the ability of LLMs to generate accurate, complex CAD models from text.", "questions": "There are some experimental details that need to be confirmed.\n1. How does the method adapt to multi-component, highly-constrained assemblies (including complex features like rotation, lofting, chamfering, etc.)? What are the anticipated key technical challenges?\n2. After generating \\<think\\> reasoning, how much does the average latency per sample increase? In editing scenarios, how does time consumption scale with script length?", "limitations": "yes", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 4, "originality": 4, "strengths_and_weaknesses": "Strengths:\n1. The paper is well-written and logically structured, with clear explanations.\n2. The proposed method is straightforward and technically sound, with accessible implementation details.\n3. The geometry reward in GRPO training appears to be a notable and reasonable contribution, as it shifts from language-level loss optimization to direct end-to-end optimization of geometric quality.\n4. I think Converting CAD command sequences into CadQuery code is a practical and intuitive approach, enabling direct manipulation of geometric parameters through code.\n\nWeaknesses:\n\n1. Although topological rewards are introduced, quantitative results still do not adequately reflect multi-dimensional indicators, making it difficult to comprehensively assess industrial applicability.\n2. Lacks direct comparison with recent CAD-specific generators (such as CAD-Translator, CAD-LLaMA), somewhat weakening experimental persuasiveness.\n3. RL fine-tuning requires 8×A800 GPUs and 146 hours. The paper does not yet discuss lightweight approaches or migration strategies for small-to-medium models, or impacts on actual deployment.\n\n[1] Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. ACM MM 2024.  \n[2] Cad-llama: Leveraging large language models for computer-aided design parametric 3d model generation. CVPR 2025.", "was_revised": true, "final_justification": "The authors have adequately addressed most of the points raised regarding the evaluation metrics and the comparison with SOTA methods. The reviewer has no further questions.", "rebuttal": "# Response to Reviewer Sray\nThank you for your constructive and encouraging review. We appreciate your recognition of our method’s technical soundness, the practicality of translating CAD command sequences into CadQuery scripts, and the value of introducing geometry-aware rewards in GRPO for direct optimization. These insights affirm the relevance of our contributions to the CAD and LLM community. We respond to your comments below and will incorporate your suggestions into the next revision.\n## W1: Evaluation Metrics\nOur choice of the Chamfer Distance (CD) metric is motivated by the core requirements of the Text-to-CAD task, where the primary goal is achieving sample-level geometric fidelity. While metrics such as MMD or JSD are useful for assessing diversity, they do not capture the accuracy of individual CAD models. In contrast, CD directly quantifies the geometric error between the generated shape and the ground truth, which is crucial for the high-precision demands of CAD applications. Adopting CD also ensures fairness and comparability with existing methods, such as Text2CAD[1], which also use CD as the primary metric.\n## W2: Lack of Comparison with CAD-Translator and CAD-LLaMA\nA direct comparison with CAD-Translator [2] and CAD-LLaMA [3] is currently infeasible as their models and code are not publicly available. In addition, their mesh normalization and preprocessing strategies (e.g., scaling and alignment) differ significantly, resulting in Chamfer Distance values that differ by an order of magnitude from ours. As a result, we are unable to fairly or reproducibly compare against the metrics reported in their papers. To ensure a rigorous evaluation, we instead adopt the established Text2CAD pipeline to compute Chamfer Distance (CD) for our method and all baselines.\n## W3: Lightweight Strategies and Model Portability\nWhile our full-scale RL tuning utilizes 8×A800 GPUs, the framework (LLaMA-Factory + VERL) supports flexible scaling.   \n\n**Lightweight Strategies**: Smaller models (1B–3B) can be trained on a single GPU in 20–40 hours.   \n\n**Model Portability**: At deployment, we support 4-bit/8-bit quantization and vLLM-based acceleration. Inference latency remains within seconds, enabling real-time usage. Our current setup serves as full-scale validation; lightweight adaptation is fully supported.  \n\nWe also provide inference latency measurements across different GPU types (per sample):\n| GPU Model  | CoT Latency | SFT Latency |\n|------------|-------------|-------------|\n| H800 80G   | 0.06 s      | 0.03 s      |\n| A800 80G   | 0.18 s      | 0.12 s      |\n| 4090 24G   | 0.28 s      | 0.16 s      |\n| V100 32G   | 0.64 s      | 0.29 s      |\n## Q1: Adaptation to Assemblies\nThank you for your question! Our framework is well-suited for modeling complex assemblies. CadQuery supports advanced features (e.g., rotation, lofting, chamfering), and our Chain-of-Thought planning naturally enables hierarchical modeling of components and their spatial relationships. The primary challenges are data-related: existing datasets predominantly contain single-component objects and lack annotated assemblies. Additionally, assemblies involve strong constraints (e.g., tolerances, fits) that are not captured by geometry-only metrics such as CD. In summary, while our modeling architecture is extensible to assemblies, scaling to realistic assembly tasks will require richer datasets and constraint-aware learning.\n## Q2:  Latency and Editing-Time Scaling\nThe latency impact of the `<think>` reasoning step is already addressed in W3, where we provide detailed measurements across different hardware setups.  \n\nEditing capability is an early-stage exploration of our model's potential and is not a primary focus of this work. We have not yet conducted a systematic evaluation of how inference time scales with script length in editing scenarios. However, because most edits involve localized changes, input/output sequences are typically much shorter than for full-script generation. Therefore, the end-to-end generation latencies reported above can be viewed as a conservative upper bound for editing tasks.\n\n[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. NIPS 2024.  \n\n[2] Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. ACM MM 2024.   \n\n[3] Cad-LLAMA: Leveraging large language models for computer-aided design parametric 3d model generation. CVPR 2025."}, {"review_id": "14gqGw2iwX", "reviewer": "Reviewer_rWzJ", "summary": "This paper bridges text-to-CAD by introducing an intermediate representation in the form of CadQuery scripts and leveraging a large language model to generate CadQuery code from text descriptions. To implement this pipeline, the authors construct data from the Text2CAD dataset by feeding command sequences and text descriptions into a pretrained LLM to generate multiple CadQuery script candidates. These candidates are evaluated by computing the Chamfer Distance between the executed 3D models and the ground-truth models. The input description, the selected CadQuery script, and the corresponding CoT are then assembled into a corpus and used to fine-tune the pretrained LLM. The fine-tuning process follows the standard SFT+GRPO approach, where Chamfer Distance is used as the reward signal in GRPO. Experiments demonstrate the effectiveness of CAD-Coder compared to the original LLMs.", "questions": "1.\tMax sequence length and compactness. Is there an issue with sequence length when using CadQuery scripts? For complex models, such as porous structures, how are long input and output sequences handled? What is the maximum sequence length supported by the LLM?\n\n2.\tUncertainty in data construction. While I fully appreciate the training process (it's clearly explaine), the data construction raises some questions. If I understand correctly, the dataset contains only command sequences and text descriptions, not ground-truth CadQuery code. Instead, the CadQuery code is generated by the LLM and then filtered based on its distance from the ground-truth point cloud. My concern is, shouldn't there be a human review step to ensure the correctness of the scripts? If not, how can the accuracy of the generated CadQuery code be guaranteed?\n\n3.\tWhy not generate CAD commands directly? As a follow-up to the previous question, why not directly generate the command sequence text instead of CadQuery code? Are there any experiments showing that using CadQuery code is superior to generating plain CAD command sequences?\n\n4.\tNatural language capabilities and conversational ability. Compared to prior work like Text2CAD, how well does this method preserve the LLM’s conversational and natural language understanding abilities?", "limitations": "As stated in the conclusion of the paper, the limitations include the lack of multi-modal input support, shallow CoT prompting, and the absence of fine-grained reward mechanisms.\n\nFrom my perspective, I also question the model's interactive capabilities and its ability to perform fine-grained edits.", "rating": 4, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 2, "strengths_and_weaknesses": "Strengths:\n\n1.\tA solid exploration of CAD code generation using large language models.\n\n2.\tThe metrics demonstrate that the proposed method outperforms the original large language model and Text2CAD in terms of geometry quality and generation success rate.\n\n3.\tThe paper is well-written and easy to follow.\n\nWeaknesses:\n\n1.\tTechnically sound but lacks novelty in the fine-tuning strategy. The paper directly adopts SFT+GRPO for refinement, so the main contribution lies in dataset construction rather than the training method. (However, this does not affect my overall rating.)\n\n2.\tThe experiments do not clearly justify the need for intermediate CadQuery scripts.\n\n3.\tBased on the authors' description, there seems to be some uncertainty in the CadQuery script generation process. Using Chamfer Distance for filtering may also fail in certain cases. This concern is discussed in more detail under the Question section.\n\n4.\tNatural language capabilities and conversation: The paper lacks evaluation of the model’s inherent language understanding abilities.", "was_revised": true, "final_justification": "I have carefully read the rebuttal and other discussions. I appreciate the rebuttal and decide to maintain the final rating.", "rebuttal": "# Response to Reviewer rWzJ  \nThank you for your thoughtful and constructive review. We appreciate your recognition of our method as a solid exploration of CAD code generation with large language models, and your acknowledgement that our approach outperforms both the original LLM and Text2CAD[1] in geometry quality and success rate. These comments affirm the contribution of our intermediate CadQuery-based representation and training framework. We address your concerns in detail below and will incorporate your suggestions into the next version of the paper.\n## W1: Novelty of the Fine-Tuning Strategy\nWhile our method does not introduce a novel reinforcement learning (RL) algorithm, we believe it makes a meaningful contribution by applying the pretraining + SFT + RL paradigm to structured code generation for 3D CAD models, a challenging task that requires both syntactic correctness and geometric fidelity. The design of our CoT prompts and reward functions is tailored to this task. To the best of our knowledge, this is the first work to validate RL with geometry-based rewards in the CAD domain. We hope this provides a strong foundation for future research on RL for CAD applications\n## W2 & Q3: Justification for using CadQuery over Command Sequences.\nCadQuery offers distinct advantages as an intermediate representation. As described in Lines 35–41 of the Introduction, CadQuery provides richer semantics, a more compact structure, direct executability, and strong compatibility with Python-based LLMs. In contrast, traditional command sequences tend to be verbose, less abstract, and often require custom parsers. CadQuery supports modular design, reusable functions, and high-level geometric primitives (e.g., box, cylinder), making it more suitable for modeling complex structures and enabling downstream editing.  \n\nDue to limited time and computational resources, we did not perform a direct comparison between generating CAD models as CadQuery scripts versus command sequences under identical experimental settings. As no prior works have conducted such a comparison, we agree that a controlled study under a unified setting would be a valuable direction for future research.\n## W3 & Q2: Data Construction Uncertainty and Script Verification\nThank you for your question. Your understanding is correct. Our CadQuery code is generated by the LLM and then filtered using Chamfer Distance (CD) and an executability check. We acknowledge that this automated pipeline may introduce some noise, as it does not involve comprehensive human review. However, manual evaluation is costly and subjective, since multiple scripts can yield the same geometry and script preferences may vary among annotators. CD offers an objective, geometry-based filtering criterion that scales efficiently and aligns with our downstream evaluation metrics.  \n\nFor constructing the CoT corpus, we do perform manual verification to ensure script correctness and clarity. In future work, we plan to explore human-in-the-loop or hybrid verification strategies to further improve data quality.\n## W4 & Q4: Evaluation of Natural Language and Conversational Capabilities\nWhile our model is not explicitly trained on editing data, we observe that it can handle basic CAD editing tasks such as modifying dimensions, removing components, and adjusting positions (see Appendix E, Fig. S3), suggesting a degree of structural understanding and editing generalization.\n\nMore broadly, our work focuses on improving geometric fidelity. Although we do not explicitly evaluate conversational or general-purpose language abilities, language understanding remains central to the task: the model must interpret prompts involving geometric intent, spatial constraints, and modeling actions, and generate structured CadQuery code. We build upon strong language models like Qwen2.5-7B-Instruct; while domain-specific fine-tuning may reduce generality to some extent, evaluating dialogue and fine-grained editing remains an open and underexplored direction across most prior works, including Text2CAD. We view this as an important opportunity for future research.\n## Q1: Sequence Length and Handling of Complex Models\nOur model supports up to 131,072 input tokens and 8,192 output tokens, following the capacity of Qwen2.5-7B-Instruct. This is sufficient to handle complex CAD structures. This is a significant improvement over earlier methods such as Text2CAD (which supports up to 512 tokens), and allows for richer modeling capabilities. Thanks to CadQuery’s compact syntax, most CAD models (including those with multiple sketches) remain within 400–600 tokens. For highly complex cases (e.g., porous structures), we employ modular functions, parameterized loops, and hierarchical modeling to ensure the overall sequence length remains within the supported limit. \n\n[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. NIPS 2024."}, {"review_id": "oH5Ty4wliY", "reviewer": "Reviewer_75fC", "summary": "In this work, the authors introduce CAD-Coder, a novel framework that reformulates text-to-CAD as the generation of CadQuery scripts—a Python-based, parametric CAD language. This representation enables direct geometric validation, a richer modeling vocabulary, and seamless integration with existing LLMs. To further enhance code validity and geometric fidelity, the authors propose a two-stage learning pipeline: (1) supervised fine-tuning on paired text–CadQuery data, and (2) reinforcement learning with Group Reward Policy Optimization (GRPO), guided by a CAD-specific reward comprising both a geometric reward (Chamfer Distance) and a format reward. They also introduce a chain-of-thought (CoT) planning process to improve model reasoning, and construct a large-scale, high-quality dataset of 110K text–CadQuery–3D model triplets and 1.5K CoT samples via an automated pipeline. Extensive experiments demonstrate that CAD-Coder enables LLMs to generate diverse, valid, and complex CAD models directly from natural language, advancing the state of the art of text-to-CAD generation and geometric reasoning.", "questions": "1. How about the failure cases of this method? What is the common failure case of this method looks like?\n\n2. How long does it take to generated a single mesh?\n\n3. How long does it take to train GRPO?", "limitations": "1. Currently, the generated shapes are rather simple, compared to SOTA 3D generation results like *Trellis: Structured 3D Latents for Scalable and Versatile 3D Generation*.\n\n2. The method only supports text-to-CAD, instead of sketch-to-CAD.", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 3, "strengths_and_weaknesses": "Strength:\n\n1. The idea is novel. Although the representation, CodeQuery, is not proposed by the authors, using CodeQuery for LLM is reasonable as it makes the LLM easier to learn this format of code.\n\n2. Introducing GRPO into the design of CAD is novel. Since RL is getting more and more attention in the research field of code generation of LLM, introduing into CAD design is reasonable and effective.\n\n3. In line 265-280, the authors have demonstrates the details of implementation, which is very useful for reproduction.\n\n\n\nWeakness:\n\n1. The training curves of GRPO are not shown in the work. Showing how the reward and generation length is growing during training is extremely important in this work.\n\n2. The authors does not show 3D meshes or rendered videos in supplementary results. I think using solely single-view images to demonstrate the results are not very good for demonstrate the full 3D results of this work.\n\n3. Although some baselines are not open-sourced, currently only one baseline (Text2CAD) is compared in Table 1, which makes it not very solid.", "was_revised": false, "final_justification": "", "rebuttal": "# Response to Reviewer 75fC\nThank you for your constructive review. We appreciate your recognition of the novelty of using CadQuery as a structured intermediate representation for text-to-CAD generation, the introduction of GRPO into CAD modeling, and the reproducibility of our implementation details. These insights affirm the relevance and practicality of our proposed framework. We address your questions and concerns below, and will incorporate all suggestions into the next version of the paper.\n## W1: GRPO Training Curve and Reward Progress.\nDue to rebuttal constraints, we are unable to include plots at this stage. Instead, we provide representative statistics demonstrating that the average reward increases while the generation length decreases during training, indicating effective policy learning. Although minor fluctuations are observed, the overall trend remains stable. We will include the full training curves and more detailed analyses in the next version.\n| train/global_step | RewardAPI | completion_length |\n|------------------:|----------:|------------------:|\n| **50**   | **0.41** | **538.98** |\n| 100   | 0.52 | 488.76 |\n| 150   | 0.43 | 524.22 |\n| 200   | 0.38 | 518.76 |\n| 250   | 0.38 | 540.30 |\n| **300**  | **0.50** | **480.01** |\n| 350   | 0.44 | 520.02 |\n| 400   | 0.44 | 510.65 |\n| 450   | 0.49 | 510.76 |\n| 500   | 0.57 | 504.23 |\n| **550**  | **0.60** | **515.47** |\n| 600   | 0.55 | 565.24 |\n| 650   | 0.61 | 508.30 |\n| 700   | 0.61 | 504.66 |\n| 750   | 0.55 | 522.70 |\n| 800   | 0.62 | 497.60 |\n| 850   | 0.66 | 497.33 |\n| 900   | 0.55 | 558.79 |\n| 950   | 0.58 | 525.95 |\n| 1000  | 0.63 | 503.71 |\n| **1050** | **0.67** | **505.29** |\n| 1100  | 0.62 | 517.74 |\n| 1150  | 0.60 | 496.27 |\n\n## W2: 3D Mesh and Rendering Visualization.\nDue to format restrictions during the rebuttal phase, we cannot include 3D meshes or videos. We agree that single-view images are limited and will add multi-view renderings in the next version. Additionally, we will provide full meshes and interactive visualizations on the project page to better showcase qualitative results.\n## W3: Limited Baseline Comparison in Table 1.\nThank you for your question. Table 1 includes only one CAD-specific supervised baseline (Text2CAD[1]) because other recent methods like CAD-Translator[2] and CAD-LLaMA[3] are not open-sourced. Furthermore, their evaluation protocols (e.g., mesh normalization and preprocessing) lack sufficient detail for reproducible and fair comparison. To compensate, we include multiple LLM baselines under a unified prompt setting and provide qualitative visual comparisons.\n## Q1: Failure Cases.\nAs detailed in Sec. F of our Supplementary Material, common failure cases include: (1) misalignment between sub-components in complex assemblies, (2) confusion between operations such as extrusion and cutting, and (3) errors in thin structures or internal cavities due to sparse sampling. These issues highlight the challenges of fine-grained geometry modeling and reward design, which we aim to address in future work.\n## Q2: Inference Time per Mesh Generation.\nWe report the average time to generate a single mesh, including both reasoning (<think>) and code generation stages. The results below are measured across different GPUs:\n| GPU Model  | CoT Latency | SFT Latency |\n|------------|-------------|-------------|\n| H800 80G   | 0.06 s      | 0.03 s      |\n| A800 80G   | 0.18 s      | 0.12 s      |\n| 4090 24G   | 0.28 s      | 0.16 s      |\n| V100 32G   | 0.64 s      | 0.29 s      |\n## Q3: GRPO Training Time\nAs stated in Sec. A of our Supplementary Material, the GRPO stage was trained for 146 hours on 8×NVIDIA A800 (80GB) GPUs.\n\n[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. Advances in Neural Information Processing Systems. NIPS 2024.  \n\n[2] Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. ACM MM 2024.   \n\n[3] Cad-LLAMA: Leveraging large language models for computer-aided design parametric 3d model generation. CVPR 2025."}]

Author rebuttal:

Meta-review: This paper presents CAD-Coder, a framework for text-to-CAD generation that reformulates the task as CadQuery script generation, supported by supervised fine-tuning, reinforcement learning with geometry-aware rewards, and chain-of-thought reasoning. The authors also contribute a large-scale dataset and show strong experimental results, outperforming Text2CAD and general-purpose LLMs on geometry fidelity and validity. While reviewers noted some limitations in data construction, baseline coverage, and evaluation breadth, the rebuttal provided convincing clarifications and additional evidence on fairness, data quality, efficiency, and generalization. The contributions are timely, technically solid, and well aligned with growing interest in text-to-3D and structured code generation. Overall, this is a clear accept.
Decision: Accept (poster)