acceptodds
Under review as a conference paper at ICLR 2027

Manufacturability as a Verifiable Reward for CAD Code Generation

Abstract

Design for Manufacturability (DFM) is a set of principles used by design and manufacturing engineers to optimize Computer-Aided Design (CAD) models for feasible and cost-effective product development. Recent work in text-to-CAD generation mostly optimizes for 3D similarity, ignoring manufacturing feasibility. To address this, we formalize manufacturability as a verifiable reward with deterministic and interpretable checks on the part's geometry based on DFM principles for three processes: Fused Deposition Modeling (FDM) printing, Computer Numerical Control (CNC) machining, and Injection molding. These checks are independent of any LLM acting as a judge and apply to any existing CAD dataset. We introduce a translator that converts CAD programs from FeatureScript to CadQuery, enabling training on a diverse set of objects and operations. Our post-training pipeline with SFT followed by GRPO on our DFM reward improves manufacturability scores across multiple datasets and manufacturing processes while preserving the original design intent.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
CAD, Text-to-CAD, RLVR, DFM, Design for Manufacturability, LLM post-training, GRPO, reward design, CAD code generation

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_nFrnOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies using GRPO post-training to improve the manufacturability of text-to-CAD generation. Instead of using an LLM as judge, the authors implement manufacturing DFM rules for three processes (CNC machining, FDM printing, and injection molding) as deterministic geometric checkers, and use them as part of the GRPO reward. CAD programs in the CADFS dataset are translated into CadQuery code, which serves as the SFT ground truth. The 3D solids obtained by executing these CadQuery code then serve as the reference geometry for the GRPO reward. Experiments are conducted on the original CADFS test set. Curriculum GRPO substantially reduces geometric violations over the SFT model, while keeping fidelity metrics largely unchanged. In comparison with open baselines, the proposed method clearly outperforms Text-to-CadQuery, CAD-Coder, and CADmium in both validity and DFM.

Critical strengths

The design of the reward mechanism is interesting and reasonable: gating the DFM term on faithfulness so that only the more faithful samples earns more manufacturability credit is an elegant safeguard against trading geometric fidelity for DFM score.

Critical weaknesses

The paper claims that rule-based DFM scoring is preferable to "using LLM as a judge" for training CAD generators, but does not support it by experiment. There is no experiment comparing GRPO with the proposed DFM reward against GRPO with an LLM (or VLM) judge reward. Without this comparison, the main contribution reduces to one untested design choice.

Questions for authors

How is the difficulty proxy trained? What are the input features and the regression target?

Are there ablations isolating the gain of key GRPO design choices (e.g., token-level loss, cyclic curriculum)?

2 comments
AuthorsOpenReview ↗

Response (1/2)

We thank the reviewer for the thoughtful feedback. Table, figure, and section numbers refer to the revised manuscript.


W1. No comparison of GRPO with the DFM reward against GRPO with an LLM/VLM-judge reward

"The paper claims that rule-based DFM scoring is preferable to 'using LLM as a judge' for training CAD generators, but does not support it by experiment. There is no experiment comparing GRPO with the proposed DFM reward against GRPO with an LLM (or VLM) judge reward."

We agree that our experiments do not establish that geometric-reward GRPO outperforms judge-reward GRPO. We have revised the manuscript to distinguish this untested training comparison from the practical choice of evaluator for our explicit geometric rules. The new appendix, "Static Evaluation of LLM Judges for DFM" (Appendix D), reports an offline comparison of coverage, analytical accuracy, repeatability, and evaluation latency; the main results are below.

Controlled solids (Table 14). GPT-6.1 Terra performs well when given CAD code and explicit rule definitions. On all 96 geometry–process cases with independent analytical severity references, the code conditions provide every target estimate, with per-rule MAE below 5×10−55\times10^{-5}. Views alone yield only 12/144 complete process scores, while repeated code-only judgments vary by more than 0.01 in 5/71 cases.

MeasureCAD code onlyRendered views onlyCAD code + rendered views
Cases with an estimate for the tested rule143/14420/144143/144
Cases with estimates for every process rule133/14412/144137/144
Analytical-reference cases with a judge estimate96/969/9696/96
Repeated cases with all three target-rule estimates71/72—72/72
Repeatability: cases with severity variation > 0.015/71—3/72
Largest max–min severity across repeated cases0.0811—0.2953

Saved GRPO outputs (Table 15). Across 96 saved GRPO completions from six groups at one training step, all judge responses are structurally valid, but only 76 provide complete scores; one molding group has wall-uniformity abstentions on all 16 completions. Using this judge as the sole source of the DFM term would therefore require a validated procedure for handling missing estimates.

MeasureCNCFDMMoldingTotal
Completions with all required rule estimates30/3232/3214/3276/96
Groups with complete scores for all 16 completions1/22/20/23/6

Evaluation latency (Table 16). On the same 96 completions, geometric scoring takes 40.9 ms on average, compared with 22.73 s for archived code-and-views judge responses. These are observed evaluation latencies for local computation and a remote service, not training-speedup measurements.

Evaluation and timed scopeMeanMedian95th percentile
Geometric evaluator: DFM scoring only, three processes40.9 ms38.5 ms57.6 ms
Geometric evaluator: CAD code to DFM scores, three processes73.4 ms63.7 ms104.8 ms
Terra API: CAD code and rendered views to response, one process22.73 s18.07 s55.44 s

Model dependence. Reliability depends on model choice under the tested rubric: with identical code-only requests, Qwen3-Coder-480B-A35B-Instruct provides 77/144 complete scores, versus 133/144 for Terra (Appendix D).

These static results motivate our practical choice of evaluator; they do not establish superior policy performance over judge-reward GRPO or demonstrate reward hacking.

AuthorsOpenReview ↗

Response (2/2)

Q1. How is the difficulty proxy trained?

"How is the difficulty proxy trained? What are the input features and the regression target?"

The difficulty proxy is fitted offline using L2-regularized logistic regression with continuous targets. Its inputs are log⁡(1+prompt length in characters)\log(1+\text{prompt length in characters}) and 13 binary indicators of operation types in the reference-program metadata.

The target measures the SFT model's reconstruction miss under greedy decoding. It is 1 for an invalid reconstruction and, for a valid reconstruction, is

1−exp⁡[−max⁡(CD−0.00045,0)0.01].1-\exp\left[-\frac{\max(\mathrm{CD}-0.00045,\\ 0)}{0.01}\right].

The floor accounts for same-part sampling differences. The fitted proxy remains fixed during GRPO and is used to order and sample training prompts; it is not an additional reward term. We do not claim that replacing it with construction-step count would produce equivalent training results.


Q2. Ablations isolating key GRPO design choices

"Are there ablations isolating the gain of key GRPO design choices (e.g., token-level loss, cyclic curriculum)?"

Token-level loss. Token-level loss aggregation follows DAPO (Yu et al., 2025). We have not performed a dedicated token-level versus sequence-level aggregation ablation, so we do not attribute a separately measured gain to this choice.

Cyclic curriculum. For sampling, the tested regular-sampling run deteriorates around step 240, whereas the cyclic configuration completes 3,000 steps. This documents a stability difference between the tested configurations.

Ablation results on the full CADFS test set (Table 3):

RunValidity ↑DFM ↑DFM (faithful) ↑Faithful ↑
SFT.786.678.589.716
GRPO, regular samplingcollapsed from step $\sim$240, generating garbage completions–––
Curriculum GRPO, full reward.850.729.634.776
Curriculum GRPO, no DFM term (λDFM=0\lambda_{\mathrm{DFM}}=0).834.716.655.761
Curriculum GRPO, no discount.833.717.620.756

Reward terms. The table also reports conditions without the DFM term and without the fidelity discount. Relative to the no-discount condition, the full method has higher DFM (0.729 versus 0.717) and DFM on faithful outputs (0.634 versus 0.620). The no-DFM condition has lower overall DFM (0.716), but higher DFM on faithful outputs (0.655). We therefore do not claim that the full method dominates every ablation on every metric. These results characterize the tested configurations, while a fully controlled isolation of every GRPO design choice remains outside the present experiments.


References

  • Yu et al. (2025). DAPO: An Open-Source LLM Reinforcement Learning System at Scale. arXiv:2503.14476.
Reviewer_UrgJOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies text-to-CAD code generation conditioned on a manufacturing process. The authors define geometry-based manufacturability scores for FDM printing, CNC machining, and injection molding, and combine these scores with geometric fidelity and program validity for reinforcement learning. To obtain executable training data, they translate FeatureScript programs from CADFS into CadQuery. The model is first trained with supervised fine-tuning and then with GRPO using a cyclic curriculum.

Critical strengths

The problem is practically relevant, and the geometric rules provide concrete feedback. Geometric similarity alone does not establish whether a generated CAD model is suitable for a specified manufacturing process. Including process-specific geometric checks in the training objective is a sensible direction.

Although training uses translated programs that pass verification, evaluation covers the full CADFS test set rather than only the objects that the translator can reconstruct. This avoids selecting test examples according to translation success. The authors also acknowledge the translator’s limitations on complex objects and show both translation and generation failures.

Critical weaknesses

The methodological contribution is limited, and the translator is primarily a data-preparation tool. The method largely consists of turning existing manufacturing guidelines into scores, adding those scores to GRPO after SFT, and introducing a cyclic easy-to-hard sampling schedule. The authors themselves describe the training objective as a slight variation of standard GRPO. These choices are reasonable, but the paper does not yet establish a clear methodological insight beyond their combination.

Key controls are missing for the reward design and curriculum. Table 3 and Figure 6 mainly compare SFT with the complete Curriculum GRPO method. This changes the training procedure, reward, and sampling schedule simultaneously, leaving the source of the improvement unclear.

Questions for authors

Can the authors report paired DFM changes and per-rule violation rates on the same test examples for which both SFT and GRPO produce valid parts? Please distinguish examples that become executable from those that were already executable and become more manufacturable.

Can the authors separately compare ordinary sampling against the cyclic curriculum, and a simple weighted reward against the fidelity discount in Equation (3)?

2 comments
AuthorsOpenReview ↗

Response (1/2)

We thank the reviewer for the constructive feedback on our manuscript and for helping us better analyze our method. We present our findings from the new experiments below and answer the questions and issues raised. Table, figure, and section numbers refer to the revised manuscript.


W1. Limited methodological contribution; the translator is a data-preparation tool

"The methodological contribution is limited, and the translator is primarily a data-preparation tool."

Although the main algorithm (GRPO with token-level loss and β=0\beta = 0) is heavily influenced by DAPO (Yu et al., 2025), our methodological contribution comes from the cyclic curriculum sampling strategy, which improves the model performance compared to regular sampling (Table 3). Our findings also show that our strategy alleviates the problem identified by Noukhovitch et al. (2026) with standard RLVR objectives, where our model gains substantially more with increasing difficulty of the prompts compared to SFT (Figure 6).

We agree that the translator is a data-preparation tool; however, we would like to highlight the data quality issue and the diversity in CAD operations represented in existing datasets that are usable. The translation pipeline tackles the data diversity issue in text-to-CAD and related tasks: the majority of research as of now uses DeepCAD-based datasets (Wu et al., 2021), which are limited in their diversity (limited to only sketch and extrude operations), which is a problem when scaling to complex geometries. The representation of the data itself is an important factor in its adoption, which is one of the motivations for Text-to-CadQuery (Xie & Ju, 2025) to make data available as Python scripts using CadQuery; however, Text-to-CadQuery also has limited representation of CAD operations, mainly derived from DeepCAD and Text2CAD (Khan et al., 2024). We come at the intersection of these two issues: (1) better representation of CAD operations to reflect real-life complex geometries, and (2) making the data available in open-source representations that will enable community adoption. We clearly mention our motivations for the translator pipeline, and we compare it against existing works (Text-to-CadQuery) that use LLMs to perform a similar task at a much higher computational cost with lower overall quality of translations (Section 5.1).

"...the paper does not yet establish a clear methodological insight beyond their combination."

With new ablations, we have updated the manuscript with a discussion of our methodological contributions (Section 6.2). In addition to making a fraction of generations more manufacturable (along with a fraction of generations that become less manufacturable), the model learns to build more valid parts, achieving $\sim$85% validity on the full CADFS test set (Pyatov et al., 2026) despite being trained on a smaller and easier subset than the original CADFS training set (Table 2).


W2 / Q2. Controls for the curriculum and the reward design

"Key controls are missing for the reward design and curriculum." / "Can the authors separately compare ordinary sampling against the cyclic curriculum, and a simple weighted reward against the fidelity discount in Equation (3)?"

Ordinary sampling vs. cyclic curriculum. GRPO with regular sampling collapses early in the training process. Our method successfully trains for 3,000 steps, achieving a 0.73 DFM score and a 0.85 validity rate, averaged over the four process prompts.

Simple weighted reward vs. fidelity discount (Eq. 3). We train our pipeline without the discount term (w≡1w \equiv 1), starting from the same SFT checkpoint and training for 3,000 steps.

Ablation results on the full CADFS test set (Table 3):

RunValidity ↑DFM ↑DFM (faithful) ↑Faithful ↑
SFT.786.678.589.716
GRPO, regular samplingcollapsed from step $\sim$240, generating garbage completions–––
Curriculum GRPO, full reward.850.729.634.776
Curriculum GRPO, no DFM term (λDFM=0\lambda_{\mathrm{DFM}}=0).834.716.655.761
Curriculum GRPO, no discount (w≡1w \equiv 1).833.717.620.756

References for both parts are at the end of Part 2/2.

AuthorsOpenReview ↗

Response (2/2)

Q1. Paired DFM changes and per-rule violation rates on parts both models build

"Can the authors report paired DFM changes and per-rule violation rates on the same test examples for which both SFT and GRPO produce valid parts? Please distinguish examples that become executable from those that were already executable and become more manufacturable."

Paired DFM changes (Table 8). GRPO changes the DFM of 16.4% of the pairs by more than 0.01. Our method improves the DFM score of CNC, FDM and none prompts; however, it also makes molding prompts less manufacturable. The pooled row first averages each part's paired change over the prompts for which both SFT and GRPO produce valid parts, then averages over parts.

PromptValid parts (both)DFM (SFT → GRPO)Paired change
CNC6,996.9087 → .9104+.0017
FDM6,998.9520 → .9521+.0001
Molding6,979.6215 → .6187−.0028
none7,006.9674 → .9676+.0002
Pooled27,979 pairs–+.0000

Per-rule violation rates (Table 7). Fraction of parts that trigger each rule, on the parts both models build under the prompted process.

ProcessRuleSFTGRPOΔ
CNCthin walls.211.213+.002
CNCpocket depth / width.028.026−.002
CNChole depth / diameter.062.062.000
CNCsharp internal corners.318.329+.011
CNCinaccessible surface.181.188+.006
CNCtrapped voids (critical).013.012−.001
CNCsetup count.196.191−.005
CNCminimum hole diameter.012.012.000
FDMsupport fraction.188.190+.001
FDMthin walls.174.176+.002
FDMbridge span.094.094+.001
FDMtrapped voids.013.013.000
FDMbed contact.096.096.000
Moldingdraft deficiency.838.841+.003
Moldingundercut.323.332+.009
Moldingminimum wall.162.162.000
Moldingtrapped voids (critical).012.013+.001
Moldingsharp corners.618.630+.011
Moldingwall uniformity.368.367−.001
Moldingmaximum wall.810.808−.001

References

  • Yu et al. (2025). DAPO: An Open-Source LLM Reinforcement Learning System at Scale. arXiv:2503.14476.
  • Noukhovitch, Ivison, Lambert & Courville (2026). Learning to Solve Hard Problems in RL for LLMs by Never Giving Up. arXiv:2609.13443.
  • Wu, Xiao & Zheng (2021). DeepCAD: A Deep Generative Network for Computer-Aided Design Models. ICCV.
  • Xie & Ju (2025). Text-to-CadQuery: A New Paradigm for CAD Generation with Scalable Large Model Capabilities. arXiv:2505.06507.
  • Khan et al. (2024). Text2CAD: Generating Sequential CAD Models from Beginner-to-Expert Level Text Prompts. arXiv:2409.17106.
  • Pyatov et al. (2026). CADFS: A Big CAD Program Dataset and Framework for Computer-Aided Design with Large Language Models. arXiv:2605.01925.
Reviewer_JZtUOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper introduces a reward function based on the Design for Manufacturability (DFM) practice in engineering to quantify the manufacturability of CAD models. It fine-tunes Qwen-2.5 using GRPO to improve its ability to produce code that generates more manufacturable CAD models with this designed reward. It also builds a translation pipeline from FeatureScript programs to CadQuery.

Critical strengths

The paper is generally well contextualized by relevant work. The visualization is easy to follow.

Critical weaknesses

The authors claim that previous work on CAD models generation ignores their manufacturability and position their work to address this gap. Yet, throughout the paper, they still have not demonstrated whether the models are actually manufacturable or not, beyond merely showing an increase in the designed DFM score after post-training. This leaves the core claim unproved and the DFM score less reliable. The investigated research questions lack sufficient significance. The translation pipeline and the GRPO post-training, two of the listed contributions, either target a problem of limited scope or show little improvement beyond the original algorithm. They do not bring much new conceptual and technical novelty.

Questions for authors

Could the authors provide practical evidence of manufacturability rather than just a DFM score? How do you justify it as an effective proxy without actually manufacturing the CAD models and measuring the cost? Are the three metric Fused Deposition Modeling (FDM), Computer Numerical Control (CNC) machining, and Injection Molding complete, optimal, or grounded? What is the rationale behind selecting specifically these three? What is the value of αpenalty\alpha_penalty in equation 2? If non-zero, wouldn't the reward be susceptible to hacking, where the model simply maximizes this penalty term? What does ScS_c represent equation 7? What is the key takeaway of Table 4? There appears to be no discussion or reference to it in either the main text or the appendix.

2 comments
AuthorsOpenReview ↗

Response (1/2)

We thank the reviewer for their clarifying questions on the manuscript. We address the issues raised below. Table, figure, and section numbers refer to the revised manuscript.


W1 / Q1. Evidence of manufacturability beyond the DFM score

"...throughout the paper, they still have not demonstrated whether the models are actually manufacturable or not, beyond merely showing an increase in the designed DFM score after post-training."

We have not fabricated the generated parts or measured manufacturing costs. Our experiments evaluate compliance with documented geometric DFM guidelines, which we use as a proxy for manufacturability rather than as experimental validation of manufacturing feasibility.

We qualitatively demonstrate the resulting objects with their corresponding violations based on the manufacturing process. For example, in Figure 1, we show how our method is able to perform targeted fixes to remove sharp internal corners, which are impossible to manufacture with CNC milling, and similarly for the other processes under consideration. The rules we use to score the objects are grounded in the literature that is standard among CAD design engineers and practitioners; the citations are in Tables 9, 10 and 11 (Appendix B). A more fine-grained analysis of the DFM score results has been added to the revised manuscript (Section 6.2, "Paired comparison", and Tables 7–8 in the appendix).


W2. Scope and novelty of the translation pipeline and GRPO post-training

"The translation pipeline and the GRPO post-training, two of the listed contributions, either target a problem of limited scope or show little improvement beyond the original algorithm."

Translation pipeline. The translation pipeline tackles the data diversity issue in text-to-CAD and related tasks: the majority of research as of now uses DeepCAD-based datasets (Wu et al., 2021), which are limited in their diversity (limited to only sketch and extrude operations), which is a problem when scaling to complex geometries. The representation of the data itself is an important factor in its adoption, which is one of the motivations for Text-to-CadQuery (Xie & Ju, 2025) to make data available as Python scripts using CadQuery; however, Text-to-CadQuery also has limited representation of CAD operations, mainly derived from DeepCAD and Text2CAD (Khan et al., 2024). We come at the intersection of these two issues: (1) better representation of CAD operations to reflect real-life complex geometries, and (2) making the data available in open-source representations that will enable community adoption. We clearly mention our motivations for the translator pipeline, and we compare it against existing works (Text-to-CadQuery) that use LLMs to perform a similar task at a much higher computational cost with lower overall quality of translations (Section 5.1).

GRPO post-training. For our post-training method using GRPO, it is established that the gains from GRPO post-training mainly come from easier samples (Noukhovitch et al., 2026). We are able to alleviate this drawback with our cyclic-curriculum sampling approach. Gains with increased difficulty are shown in Figure 6. This gain is despite the under-representation of the difficult samples in our dataset (Table 2). Regular sampling vs. the cyclic curriculum with GRPO, on the full CADFS test set (from Table 3):

RunValidity ↑DFM ↑DFM (faithful) ↑Faithful ↑
SFT.786.678.589.716
GRPO, regular samplingcollapsed from step $\sim$240–––
GRPO, cyclic curriculum (ours).850.729.634.776

References for both parts are at the end of Part 2/2.

AuthorsOpenReview ↗

Response (2/2)

Q2. Are the three processes complete, optimal, or grounded?

"Are the three metric Fused Deposition Modeling (FDM), Computer Numerical Control (CNC) machining, and Injection Molding complete, optimal, or grounded?"

We ground all of our geometric checks in standardized literature from design textbooks and guidelines published by manufacturers. All citations are available in Tables 9, 10 and 11 (Appendix B).

Completeness and optimality are highly dependent on the exact constraints of each manufacturer. Manufacturability depends on a combination of materials, tolerances, production volumes, and available machines; none of these can realistically be included in the prompt and verified reliably from the geometry. Optimality depends on the objective of the manufacturer: for example, our rules treat inaccessible surfaces as costly but not impossible (Table 10), whereas a manufacturer, depending on their machine setup, could deem them impossible. Our geometric checks hence borrow heavily from standardized DFM guidelines instead of reinventing them.

Our checks act like unit tests used as verifiable rewards for code generation. Although the checks are incomplete, they target documented failure modes in a deterministic and interpretable manner. Their thresholds can be readily customized by a manufacturer to their own constraints.


Q3. Rationale for selecting these three processes

"What is the rationale behind selecting specifically these three?"

We chose these three processes because these methods cover the three most widely used approaches to manufacturing, namely additive, subtractive, and formative. Other approaches like sheet-metal forming are specialized processes that do not apply to most solids. Although other processes exist that can be used to manufacture all types of solids, the three chosen are typically the most used, especially the FDM printing process.


Q4. Value of αpenalty\alpha_{\text{penalty}} in Equation 2, and reward hacking

"What is the value of αpenalty\alpha_{penalty} in equation 2? If non-zero, wouldn't the reward be susceptible to hacking, where the model simply maximizes this penalty term?"

The value of αpenalty\alpha_{\text{penalty}} is negative and depends on the cause of the invalid generation: it is −0.3-0.3 when no code is generated, −0.2-0.2 for execution errors, and −0.1-0.1 for an invalid, non-watertight solid.

No, it is not possible for the model to reward-hack this term, because it is only enabled when the generated object is invalid, and the negative value of the penalty makes it impossible.


Q5. Meaning of ScS_c in Equation 7

"What does ScS_c represent equation 7?"

ScS_c in this equation represents the violation score of check cc on the solid SS.


Q6. Key takeaway of Table 4

"What is the key takeaway of Table 4? There appears to be no discussion or reference to it in either the main text or the appendix."

In this table (Table 5 in the revised manuscript), we evaluate our model on standard text-to-CAD generation metrics on two datasets: DeepCAD (Wu et al., 2021) and CADFS (Pyatov et al., 2026). Here we compare our method against the CADFS baseline model; we report their metrics as published in their paper, since it is impossible to render the 3D objects from the FeatureScript code without using the Onshape cloud API. We have updated the main text (Section 6.2) to contextualize this table.


References

  • Wu, Xiao & Zheng (2021). DeepCAD: A Deep Generative Network for Computer-Aided Design Models. ICCV.
  • Xie & Ju (2025). Text-to-CadQuery: A New Paradigm for CAD Generation with Scalable Large Model Capabilities. arXiv:2505.06507.
  • Khan et al. (2024). Text2CAD: Generating Sequential CAD Models from Beginner-to-Expert Level Text Prompts. arXiv:2409.17106.
  • Noukhovitch, Ivison, Lambert & Courville (2026). Learning to Solve Hard Problems in RL for LLMs by Never Giving Up. arXiv:2609.13443.
  • Pyatov et al. (2026). CADFS: A Big CAD Program Dataset and Framework for Computer-Aided Design with Large Language Models. arXiv:2605.01925.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of revisions and new results

We thank the reviewers for the constructive feedback on our manuscript and for helping us better analyze our method. We present our findings from the new experiments below; detailed answers are in our response to each review. Table, figure, and section numbers refer to the revised manuscript.


Key takeaways

  • Our post-training pipeline improves overall manufacturability for all manufacturing processes and paired manufacturability scores for three out of four manufacturing processes while preserving the original design intent (Tables 4 and 8).
  • Most of the DFM gain comes from the model learning to make more valid objects as an effect of reward design, RLVR training, and curriculum sampling strategy.
  • Curriculum sampling makes the training stable by preventing model collapse (Table 3).
  • Our model gains substantially more with increasing difficulty of the prompts compared to SFT (Figure 6).

New experiments and findings

1. Ablations of the curriculum and the reward design (Table 3). GRPO with regular sampling collapses early in the training process. Our method successfully trains for 3,000 steps, achieving a 0.73 DFM score and a 0.85 validity rate, averaged over the four process prompts. Curriculum GRPO without DFM reward scores less on overall DFM. The discounted fidelity term inside our reward design improves DFM (faithful) compared to without fidelity discount (0.634 vs 0.620). The no-DFM condition has lower overall DFM (0.716), but higher DFM on faithful outputs (0.655).

2. Paired DFM changes and per-rule violation rates (Tables 7–8). For the parts for which both SFT and curriculum GRPO models build valid 3D parts, the DFM score is almost the same for the two models. GRPO training improves DFM scores of 3 out of 4 manufacturing processes, and reduces the scores of one of them. In addition to making a fraction of generations more manufacturable (along with a fraction of generations that become less manufacturable), the model learns to build more valid parts, achieving $\sim$85% validity on the full CADFS test set (Pyatov et al., 2026) despite being trained on a smaller and easier subset than the original CADFS training set (Table 2).

3. Performance with increasing difficulty (Figure 6). Our findings also show that our strategy alleviates the problem identified by Noukhovitch et al. (2026) with standard RLVR objectives, where our model gains substantially more with increasing difficulty of the prompts compared to SFT (Figure 6).

4. Static evaluation of LLM judges (Tables 14–16). The new appendix, "Static Evaluation of LLM Judges for DFM" (Appendix D), reports an offline comparison of coverage, analytical accuracy, repeatability, and evaluation latency. On 96 controlled cases with analytical severity references, GPT-6.1 Terra provides every target estimate in the code conditions, with per-rule MAE below 5×10−55\times10^{-5}. Views alone yield only 12/144 complete process scores, while repeated code-only judgments vary by more than 0.01 in 5/71 cases. In a separate latency comparison on 96 saved GRPO completions, geometric scoring takes 40.9 ms on average, compared with 22.73 s for archived code-and-views judge responses. These static results motivate our practical choice of evaluator; they do not establish superior policy performance over judge-reward GRPO or demonstrate reward hacking.


Other changes to the manuscript

  • We updated the abstract with discussions on ablations and the results section with paired DFM changes, and LLM as a judge reliability and usability for our RLVR pipeline.
  • We added detailed discussion in the appendix on LLM as a judge under different inputs (Code + Image, Code only, Image only).

We are cleaning up and anonymizing the repository to submit the code for reproducibility.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.