Response to Reviewer 75fC

Thank 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.

W1: GRPO Training Curve and Reward Progress.

Due 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.

W2: 3D Mesh and Rendering Visualization.

Due 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.

W3: Limited Baseline Comparison in Table 1.

Thank 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.

Q1: Failure Cases.

As 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.

Q2: Inference Time per Mesh Generation.

We 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:

Q3: GRPO Training Time

As stated in Sec. A of our Supplementary Material, the GRPO stage was trained for 146 hours on 8×NVIDIA A800 (80GB) GPUs.

[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. Advances in Neural Information Processing Systems. NIPS 2024.

[2] Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. ACM MM 2024.

[3] Cad-LLAMA: Leveraging large language models for computer-aided design parametric 3d model generation. CVPR 2025.

Response to Reviewer rWzJ

Thank 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.

W1: Novelty of the Fine-Tuning Strategy

While 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

W2 & Q3: Justification for using CadQuery over Command Sequences.

CadQuery 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.

Due 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.

W3 & Q2: Data Construction Uncertainty and Script Verification

Thank 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.

For 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.

W4 & Q4: Evaluation of Natural Language and Conversational Capabilities

While 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.

More 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.

Q1: Sequence Length and Handling of Complex Models

Our 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.

[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. NIPS 2024.

Dear Reviewers,

Thanks for your efforts in reviewing this paper. We have tried our best to address the concerns and improve our work. Are there unclear explanations here? We can further clarify them.

Best wishes,

Authors

Response to Reviewer Sray

Thank 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.

W1: Evaluation Metrics

Our 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.

W2: Lack of Comparison with CAD-Translator and CAD-LLaMA

A 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.

W3: Lightweight Strategies and Model Portability

While our full-scale RL tuning utilizes 8×A800 GPUs, the framework (LLaMA-Factory + VERL) supports flexible scaling.

Lightweight Strategies: Smaller models (1B–3B) can be trained on a single GPU in 20–40 hours.

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.

We also provide inference latency measurements across different GPU types (per sample):

Q1: Adaptation to Assemblies

Thank 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.

Q2: Latency and Editing-Time Scaling

The latency impact of the <think> reasoning step is already addressed in W3, where we provide detailed measurements across different hardware setups.

Editing 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.

[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. NIPS 2024.

[2] Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. ACM MM 2024.

[3] Cad-LLAMA: Leveraging large language models for computer-aided design parametric 3d model generation. CVPR 2025.

Response to Reviewer vKK8

Thank 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.

W1 & Q1: Data Synthesis Pipeline

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.

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.

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.

W2 & Q2: Baseline Comparison Quality

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.

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.

W3 & Q3: SFT Performance

Thank 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. As 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.

W4: Code Quality Extensions

Thank 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.

W5: CADAssistant Clarification

Thank you for pointing this out. We will correct it in the next version.

W6: Dataset and Code Release

We are committed to fully open-sourcing the following upon paper acceptance: the constructed CADQuery dataset, model weights, and inference code.

[1] Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. NIPS 2024.

[2] Text-to-CAD Generation Through Infusing Visual Feedback in Large Language Models. ICML 2025.