acceptodds
Under review as a conference paper at ICLR 2027

ResCAD: Language-Grounded CAD Assembly via Geometry-Constrained Interface Resolution

20 views

Abstract

Advances in CAD generation and retrieval make individual components increasingly available, but independently produced parts often lack the assembly semantics required to connect them. We study language-grounded CAD assembly: given a natural-language request and candidate STEP solids for each requested component, the goal is to select the components, ground their connections to boundary-representation (B-rep) faces or edges, and construct a CAD-kernel-verified assembly without predefined assembly interfaces. The central challenge is that multiple component combinations and connection locations can satisfy the same local geometric requirements. We introduce ResCAD, a framework that separates feasibility, grounding, and execution. Its key principle is to use learning to resolve ambiguity left by geometric constraints rather than replace geometric reasoning. A frozen language model compiles the request into a connection graph and interface requirements; deterministic B-rep filtering removes incompatible hypotheses; language-conditioned B-rep rankers resolve component and interface choices; and a CAD kernel computes poses and verifies the resulting assembly. On 114 unseen Fusion 360 assemblies, geometric filtering increases component-assignment recall within 25 proposals from 30.70% to 89.47%. Under the same candidates and feasible set, ResCAD achieves 71.05% complete-connection recall within 25 proposals, compared with 35.09% for an adapted JoinABLe-style scorer. On 50 end-to-end requests with geometrically unique interfaces, ResCAD recovers 82% exact assemblies. These results show that geometric pruning and language-conditioned interface grounding play complementary roles in converting independently produced CAD geometry into verified assemblies.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
CAD assembly, neuro-symbolic learning, language grounding, geometric reasoning, boundary representation

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_AHrfOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper addresses geometric ambiguity in CAD assembly tasks and proposes ResCAD, a language-grounded CAD assembly framework that explicitly separates geometric feasibility filtering, component and interface grounding, and CAD execution. It first applies geometric rules to filter infeasible candidates, then translates natural-language assembly instructions into structured assembly relationships and geometric constraints and employs a dual-branch grounding module based on B-rep graph neural networks to identify the appropriate components and locate their geometric interfaces. Finally, it executes the assembly using a CAD kernel and performs collision detection to verify the geometric feasibility and global consistency of the resulting assembly.

Critical strengths
  1. The language-grounded CAD assembly task is interesting and practically valuable.
  2. The motivation for separating feasibility filtering, grounding, and execution is well justified.
Critical weaknesses
  1. The Overview is fragmented and fails to provide a coherent understanding of the overall method. I recommend rewriting Section 4.1 (Overview). First, it should establish an overall understanding of the method. For example, the core idea is to separate feasibility, grounding, and execution, and a four-stage framework is designed to realize this idea. Next, the relationship between the core idea and method should be clearly articulated, along with the purpose of each stage. For instance, the authors could explicitly explain that feasibility is implemented through Language Compilation and Geometric Filtering, which perform preliminary screening of candidate components.
  2. The figure and the textual description are inconsistent, which leads to confusion. In Figure 2, the Language Compilation stage appears to take only the request q as input. However, Section 4.2 states that both the request q and the component entities V serve as inputs to Language Compilation. Furthermore, Figure 2 presents Geometric Filtering as a standalone Stage 2, whereas the method description incorporates it as part of the original Stage 3, Two-Branch Grounding. These inconsistencies between the figure and the text make the method considerably more difficult to understand.
  3. Some results in Table 1 show that the full ResCAD performs worse than ablated variants (e.g., ResCAD w/o interface rule and Rules + executor) on some metrics. Could the authors explain the reasons for these performance differences?
  4. The metrics described in the text do not correspond to those reported in Table 1. The meanings of “@1%,” “F@1%,” “Coll.-free,” “All parts,” and “Exact” in Table 1 are not explained. In addition, why is “Exact” uniquely highlighted in bold in the table?
  5. Some recent works on CAD generation [1–3] should be included and discussed in the Related Work section.

[1] Seek-CAD: A Self-refined Generative Modeling for 3D Parametric CAD Using Local Inference via DeepSeek.ICLR 2026

[2] CAD-Tokenizer: Towards Text-based CAD Prototyping via Modality-Specific Tokenization. ICLR 2026

[3] Plan-then-Act: Bi-level CAD Command Sequence Generation. ICLR 2026

Questions for authors

Please revise the writing issues based on the weaknesses.

3 comments

Thank you for recognizing the task's practical value and for the concrete suggestions on presentation. We would like to address your questions individually as follows.

Q1: Please rewrite the Overview to explain how the four stages implement feasibility, grounding, and execution, with a clear purpose for each stage.

A1: Thank you for your detailed suggestions on making the Overview more readable. We have rephrased the passage below to first introduce the separation of feasibility, grounding, and execution, and then explain how the four stages implement these principles:

“ResCAD separates geometric feasibility, language grounding, and assembly execution: satisfying local geometric requirements does not uniquely identify the requested parts or interfaces, and selecting them does not guarantee a realizable assembly. Four stages address these distinctions. First, an LLM translates the request and component entity names into a connection graph and geometric requirements. Second, geometric filtering removes candidates lacking interfaces that satisfy these requirements. Together, these stages define the search space for grounding. Third, two learned B-rep rankers resolve the remaining ambiguity by ranking complete component combinations and their connection interfaces. Finally, a CAD kernel computes component poses and checks whether the selected connections can be realized together. Thus, geometry restricts the choices, learning identifies those matching the request, and execution checks the resulting assembly.”


Q2: Please reconcile Fig. 2 and the text regarding the compiler inputs (q versus q and V) and whether Geometric Filtering is a separate stage.

A2: Thanks for pointing out the presentation of Figure 2 in describing the compiler inputs and geometric filtering. In fact, the compiler receives the request q and component entity names V, not candidate CAD geometry. The names identify the entities to connect, while geometric filtering screens their candidates before learned grounding. We will modify Figure 2 accordingly, and clarify this part in our next version.


Q3: Why do some ablated variants outperform full ResCAD on certain metrics in Table 1?

A3: We understand the reviewer’s concern that ResCAD w/o interface rule achieves lower CD (15.07 vs. 18.35), while Rules + executor achieves higher STEP validity and collision-free rates (98% vs. 96%). Actually, removing the interface rule allows alternative alignments that can bring large surface regions closer to the reference while misaligning the requested interfaces; CD averages surface distances and can therefore favor these alignments. Similarly, Rules + executor can produce valid, collision-free assemblies using incorrect components. However, their reported Exact scores are 44% and 10%, respectively, versus 82% for ResCAD. Overall, these gains reflect surface similarity or geometric validity, not more accurate recovery of the requested assembly.


Q4: Please define “@1%,” “F@1%,” “Coll.-free,” “All parts,” and “Exact,” align the text with Table 1, and explain why Exact is bold.

A4: It is worth mentioning that Shape Acc.@1%, F@1%, and Coll.-free measure geometric fidelity and compatibility through shape agreement, surface accuracy and completeness, and inter-part non-interference, respectively. Distance- and precision–recall-based geometric evaluation is also adopted in recent CAD work [1,2]. Here, “@1%” denotes a distance threshold of 1% of the reference assembly’s bounding-box diagonal: Shape Acc. counts component roles within this mean surface-distance threshold, while F measures surface precision–recall at the same threshold; Coll.-free counts requests with collision-free outputs.

On the other hand, All parts and Exact measure recovery of the requested assembly: All parts requires every selected component to match the target, whereas Exact additionally requires matching connection labels and execution acceptance.

Note that we have bolded the Exact values in Table 1, as it is our primary metric for overall assembly correctness.

[1] Wu et al. CMT: A Cascade MAR with Topology Predictor for Multimodal Conditional CAD Generation. ICCV 2025.

[2] Liu et al. Point2CAD: Reverse Engineering CAD Models from 3D Point Clouds. CVPR 2024.


Q5: Please include and discuss Seek-CAD, CAD-Tokenizer, and Plan-then-Act in Related Work.

A5: We would like to note that the mentioned works Seek-CAD, CAD-Tokenizer, and Plan-then-Act are related to our work from the perspectives of self-refinement, modality-specific tokenization, and planning-based CAD generation, respectively. Different from these works, our work grounds language-specified assembly requests to component choices and B-rep interfaces on existing geometry, rather than generating or editing the component geometry itself. We will include these works and discuss them in the Related Work.

Thanks for the responses. These have resolved my concerns. I hope the authors will incorporate these adjustments into the revised version of the paper to improve its completeness and readability. I will raise my score to 3.

Dear Reviewer AHrf,

Thank you for appreciating our responses and for raising your score. Based on your suggestions, we have incorporated the corresponding changes into the revised manuscript, including improvements to the presentation and additional experimental results in Appendix J.4. The revised PDF has been uploaded, with all textual changes highlighted in blue.

Thank you again for your constructive suggestions and time.

Best regards,

The Authors

Reviewer_CmiJOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The method uses llms, geometric filtering and learning networks to perform the cad assembly generation task. The key idea learning resolves ambiguity left by geometric constraints rather than replacing geometric checks is sound to me.

Critical strengths
  1. The evaluation's logical, with clear explanations and information. table 1 presents an interesting finding that some geometric metrics != task success.
  2. The method motivation and the corresponding solution are reasonable.
Critical weaknesses
  1. The first one dates back to fig 6. The initial user requests already provide fixed geometric attributes, i.e., type, size, neighbors, and symmetry... therefore, calling the input a natural-language request may not be accurate. It is more like a constrained natural-language request.
  2. The second one is related to the llm stage of the method. Appendix table 2 reports nearly 100% accuracy for the frozen llm. Considering weakness 1, this raises 2 questions. First, if so, would a lightweight rule-based parser achieve comparable performance? Is llm part necessary? Second, how sensitive is the system to parsing errors when llms make errors? (My understanding is that fig 6 can only answer missing parser.)
Questions for authors
  1. Please add citations for prior methods directly in Fig. 1.
  2. I think Its key principle is to use learning to resolve ambiguity left by geometric constraints rather than replace geometric reasoning in abstract is not consistent with learning resolves ambiguity left by geometric constraints rather than replacing geometric checks line 85. I think the latter is more accurate.
1 comment

Thank you for recognizing our motivation and the separation between learned grounding and geometric checks. We would like to address your questions individually as follows.

Q1: Please add citations for prior methods directly in Fig. 1.

A1: We agree that adding citations for prior methods directly in Figure 1 would improve clarity, and we will revise the figure accordingly.


Q2: Please unify “replacing geometric reasoning” and “replacing geometric checks”; the latter is more accurate.

A2: Thank you for pointing this out and we will use “geometric checks” consistently in our paper.


W1: It is suggested to call our input as a constrained natural-language request.

A1: Thanks for your suggestion. We agree that “constrained natural-language requests” more precisely describes our inputs, which contain geometric attributes such as type, size, neighbors, and symmetry.


W2: Given the nearly 100% accuracy of the frozen LLM in Appendix Table 2, would a lightweight rule-based parser achieve comparable performance, and is the LLM necessary? How sensitive is the system to parsing errors, beyond the missing attributes evaluated in Figure 6?

A2: We would like to clarify that Figure 6 evaluates learned grounding under missing geometric attributes. Regarding the necessity of the LLM, in a retrospective comparison, a lightweight rule-based parser correctly recovers 399/409 connection descriptions, compared with 409/409 for the cached outputs of the frozen LLM, suggesting that rule-based parsing is a competitive alternative for constrained natural-language requests. However, neither parser directly selects components or interfaces; the subsequent grounding stages resolve these choices. Furthermore, to assess sensitivity to parsing errors, we conducted additional experiments with both missing and incorrect geometric attributes, as shown below:

ConditionCorrect component Top-1 predictions
Unperturbed51–54/114
20% omitted fields43–54/114
20% incorrect fields12–24/114

Overall, these results show that ResCAD can still identify correct component combinations from incomplete geometric requirements, while incorrect hard constraints can exclude the correct candidates before grounding.

Reviewer_GKX3OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents ResCAD, a framework for assembling candidate CAD components from natural-language requests without predefined interfaces. It combines language-based request parsing, geometric filtering, learned component and interface ranking, and CAD-kernel execution. Experiments evaluate component selection, interface grounding, and assembly success on retrieved and generated parts.

Critical strengths
  • The task is useful: independently retrieved or generated CAD parts often lack predefined assembly interfaces. ResCAD connects component selection, interface grounding, and assembly execution in one pipeline.
  • The division between geometric reasoning and learned ranking is sensible. Geometric constraints narrow the search, while the rankers resolve the remaining ambiguity.
  • The experiments cover component selection, interface grounding, and final assembly, with adapted baselines and ablations that help assess the different stages.
Critical weaknesses
  1. The paper does not consistently distinguish candidate recall from the accuracy of the returned assembly. On generated parts, Verified R@25 reaches 100%, but first-accepted accuracy is only 45.95%. Since inference stops at the first accepted assembly, the latter better reflects practical performance. This gap also shows that geometric verification alone cannot ensure that an assembly matches the request.
  2. The contribution of learned ranking to final assembly success is not fully clear. The ablations show substantial effects from geometric filtering and execution, but often report candidate recall or intermediate ranking accuracy. A clearer comparison of final-output success under the same filtering, search budget, and executor would help establish how much the learned rankers contribute.
Questions for authors
  1. Is Table 1’s 82% Exact computed on the first kernel-accepted assembly returned by the system? Does computing Verified R@25 require continuing execution after the first accepted result? Please clarify and report first-accepted accuracy alongside candidate recall.
  2. What causes the gap between 100% Verified R@25 and 45.95% first-accepted accuracy on generated parts? Which errors pass geometric verification, and could ranking the accepted candidates improve the returned result?
  3. Under the same geometric filtering, search budget, and executor, how much do the learned component and interface rankers improve final assembly accuracy over rule-based ranking? Can the existing ablations establish this contribution?

Minor suggestions (no rebuttal response needed):

  • Please enlarge the labels in Figure 2. Some are difficult to read at normal viewing size.
2 comments

Thank you for your insightful comments and for recognizing the practical value of the task and the design of our pipeline. We would like to address your questions individually as follows.

Q1: Is the 82% Exact based on the first kernel-accepted output? Does Verified R@25 continue execution afterward? Please report first-accepted accuracy alongside candidate recall.

A1: We would like to clarify that the 82% Exact in Table 1 indeed evaluates the output obtained from the highest-ranked component assignment, rather than an oracle-selected best-of-25 result. We define the Exact metric as to check agreement with the target component and connection labels together with the recorded execution-acceptance flag. Furthermore, Verified R@25 continues execution after the first accepted result to determine whether any of the first 25 proposals is both kernel-accepted and matches the ground truth.

To further clarify, candidate recall measures whether the correct component assignment appears among the top 25 proposals, regardless of whether it is ultimately accepted by the CAD kernel. We report first-accepted accuracy and candidate recall side by side on the same 50 requests used in Table 1:

MetricPercent
Exact82%
Candidate Recall100%

Thus, first-accepted accuracy reflects the correctness of the returned assembly, whereas candidate recall reflects whether the correct component assignment is included within the fixed search budget.


Q2: Why does 100% Verified R@25 yield only 45.95% first-accepted accuracy? Which errors pass geometric verification, and could reranking accepted candidates improve accuracy?

A2: We understand the reviewer's concern regarding the substantial gap between Verified R@25 and first-accepted accuracy, particularly why geometrically valid candidates may still be incorrect and whether reranking could improve the final output. Here, we would like to clarify that the correct assembly is among the first 25 proposals, but the system may return an incorrect yet geometrically valid assembly before reaching it. For example, candidate parts may share compatible connection diameters but differ in their requested shapes, allowing an incorrect component selection to pass geometric verification.

Furthermore, ResCAD already evaluates candidates in ranked order and returns the first kernel-accepted assembly.Therefore, reranking the accepted candidates using the same ranking scores would not change the returned result, as the system already prioritizes higher-ranked candidates during execution. This explains why simply reranking the accepted candidates would not improve first-accepted accuracy under the current scoring scheme.


Q3: How much do the learned rankers improve final assembly accuracy over rule-based ranking under identical filtering, search budgets, and execution? Do existing ablations establish this contribution?

A3: Actually, our submission includes ablations of geometric filtering, interface-rule dispatch, and component/interface adaptation (Table 1 and Figs. 3 and 5).

As a complement, we compare learned and rule-based ranking on 26 source-verifiable requests, fixing the candidates, geometric filter, search budgets, and executor.

RankingCorrect returned assemblies
Rule-based component and interface ranking3/26 (11.54%)
Learned component and interface ranking6/26 (23.08%)

The results show that combined learned ranking improves returned-output accuracy by 11.54 percentage points, retaining every rule-based success.

Thank you for the response. Your clarifications alleviate my concerns, and I am keeping my original rating of weak acceptance.

Comments on the paper

1 comment

Dear Area Chair and Reviewers,

We sincerely thank the reviewers for their insightful feedback and constructive suggestions, and greatly appreciate the Area Chair’s time and attention during the rebuttal period. We are grateful for the recognition of our interesting, practically valuable, and well-motivated task (Reviewer AHrf), the sensible division between geometric reasoning and learned ranking (Reviewer GKX3), and the soundness of our central design principle (Reviewer CmiJ). Additionally, we appreciate the acknowledgment of our evaluation spanning component selection, interface grounding, and final assembly (Reviewer GKX3).

In response to the reviewers' concerns, we have further strengthened the paper through additional experiments and clarifications. The key efforts made during the rebuttal are as follows:

  • Additional ablation studies (Reviewers GKX3 and CmiJ). To clarify how learning helps select the requested parts and connections beyond geometric compatibility, we added controlled comparisons with rule-based ranking. We also evaluated how language parsing affects assembly decisions through parser comparisons and robustness tests.

  • More details on implementation and methodology (Reviewer AHrf). Reviewer AHrf primarily raised concerns regarding the presentation of our work, particularly the phrasing in the Overview, as well as several technical details of our methods. Accordingly, we have clarified these aspects in our response. The reviewer explicitly acknowledged that our clarifications had addressed their concerns and stated their intention to increase their score from 2 to 3.

These updates are incorporated into the revised manuscript, with textual changes highlighted in blue. We believe the recognized strengths, additional evidence, and resolved concerns together make a strong case for ResCAD’s contribution to language-grounded CAD assembly.

We sincerely thank the Area Chair, the reviewers, and the ICLR community for their time and constructive efforts.

Best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.