Intent2CAD: How Semantic-Parametric Supervision Shapes Text-to-CAD Generation

AI summary

Overview

Research area: Computer vision and AI-assisted engineering design, specifically text-to-CAD (Computer-Aided Design) generation with large language models. The paper sits at the intersection of program synthesis, parametric CAD modeling, and dataset/representation design.

Technical level: Advanced. The paper assumes familiarity with supervised fine-tuning of LLMs, CAD sketch-and-extrude construction sequences, and metrics such as Chamfer Distance. The core idea, however, is explained concretely enough for a determined non-specialist.

Scope (one sentence): The paper builds a 100K paired text–code CAD dataset at three levels of symbolic abstraction and shows, under a fixed model and training setup, that the representation of the target program — not the architecture — measurably changes generation reliability and zero-shot editability.

What This Paper Is About

Most text-to-CAD systems are trained to output low-level construction traces made of primitives such as lines, arcs, circles, and extrusions, and they are judged mainly on whether the program runs and whether the resulting shape matches the target. The authors argue this misses a practical requirement: real parametric CAD programs must expose reusable structure — named features, editable parameters, and relations like equal radii or mirrored centers — so that a designer can later modify them. Intent2CAD therefore holds the model, training objective, text descriptions, and inference fixed, and varies only the granularity of the supervision target, asking how much the symbolic form of the training code itself shapes both generation quality and zero-shot editing.

Key Contributions

1. A representation-centered problem formulation. The authors define "intent-oriented text-to-CAD generation," where intent is restricted to recoverable code-level signals — semantic features, reusable parameters, and lightweight parametric relations — rather than full design history or constraint solving.

2. IntentCAD-100K. A 100K paired text–code dataset built by converting 178,238 raw DeepCAD construction sequences into executable CadQuery programs at three aligned granularities: primitive-only, semantic, and semantic–parametric.

3. A conservative lift-and-validate pipeline. An automated two-stage construction process (tag-preserving reconstruction plus constraint-grounded semantic lifting, then restricted relation induction via LLM-proposed but deterministically validated parameter rewrites) that yields validated targets at scale without manual annotation.

4. IntentCAD-Edit-1K and new metrics. A zero-shot intent-preserving editing benchmark (1K samples: 414 Feature Edits, 311 Consistency Edits, 275 Derived-Relation Edits) plus evaluation metrics for feature recovery (API Recovery), equality-like relations (Equal Relation Score), and derived relations (Parametric Relation Score).

Main Findings

• Semantic lifting drives the largest generation gains. Under identical fine-tuning, moving from primitive-only to semantic supervision reduces Invalid Ratio from 2.39% to 0.22%, lowers mean Chamfer Distance from 1.44 to 0.46 (×10³), and raises median CD from 0.14 to 0.12, with 99.96% API Recovery.

• Parametric lifting mainly buys relation structure, not geometry. Going from semantic to semantic–parametric supervision leaves IR (0.20%), API Recovery (99.96%), and median CD (0.12) essentially unchanged, and mean CD is slightly higher at 0.57 with overlapping confidence intervals. Its value shows up as 93.35% ERS and 95.25% PRS — metrics that are not applicable to the other two representations because those targets do not expose relations.

• Generic LLMs and CAD-specific models both struggle on intent-oriented prompts. In the diagnostic comparison, GPT-5.4 reaches 41.85% IR with mean CD 6.21 and 71.97% AR; GPT-5.4-mini reaches 50.20% IR; Qwen3.5-397B-A17B and Qwen3.5-plus both sit near 41.7% IR. CAD-Coder achieves low IR (1.29%) but mean CD of 145.04 and only 6.11% AR, and cadrille reaches 24.43% IR with 0.16% AR. Qwen2.5-7B and Qwen3.5-9B without fine-tuning are near-total failures (99.98% and 99.86% IR) and improve to 0.32% and 0.20% IR respectively after IntentCAD supervised fine-tuning.

• Representation granularity strongly affects zero-shot editing. Overall Edit Success rises from 41.80% (primitive-only) to 88.90% (semantic) to 92.50% (semantic–parametric), while IR on edit inputs drops from 36.30% to 7.00% to 4.70%.

• Parametric structure specifically helps relation-aware edits. CE@ES rises from 91.00% to 95.82% and DE@ES from 77.09% to 88.73% when moving from semantic to semantic–parametric supervision, with paired bootstrap intervals excluding zero. Feature edits do not improve (FE@ES 95.17% → 92.51%).

• Visually grounded editing shows the same ordering. On 200 cases where loop identifiers are replaced by spatial descriptions, localization rises from 69.50% to 84.00% to 91.50% and ES from 36.50% to 66.00% to 78.50% across the three representations; VLM-rated editability rises from 6.58 to 7.86 to 8.94 on a 0–10 scale. Here semantic supervision wins on feature edits (86.25% vs 78.75%), while parametric supervision wins on consistency (73.33% vs 48.33%) and derived-relation edits (83.33% vs 56.67%).

• Fidelity and coverage of the pipeline. Semantic and parametric lifting cover 69.44% and 18.47% of the test split respectively, with fully fallback samples at 6.10% of the test set. Loop types in the training split are dominated by circles (37.34%), rectangles (32.63%), and fallback loops (14.51%).

Methodology in Plain English

The authors do not touch the model. They change what the model is trained to write.

1. Start from raw CAD traces. Each DeepCAD sample is a sequence of low-level commands plus recovered geometric and dimensional constraints, which the authors organize into a typed relation graph.

2. Rebuild as runnable code with labels. A rule-based reconstructor turns each trace into an executable CadQuery program where every primitive carries a unique tag, so candidate groups can be checked against the geometry and against the constraint evidence.

3. Stage I — semantic lifting. For each candidate group of primitives and each supported feature template (rectangle, regular or irregular polygon, slot, fillet, array), the group is rewritten into a high-level feature call only if both a geometric match and constraint support hold. Everything else stays as a low-level fallback. The rule is "lift when reliable, preserve when uncertain."

4. Stage II — parametric lifting. An LLM (GPT-5.4, with structured JSON output) is used only as a constrained local rewriter: it proposes a plan for turning repeated numeric constants into shared variables or simple derived expressions for EQUAL, CONCENTRIC, MIRROR, DISTANCE, and RATIO relations. It cannot change topology, add operations, or reorder anything.

5. Validate every proposal deterministically. A rewrite is accepted only if the program executes into a valid solid, remains geometrically consistent with the Stage-I program under a fixed tolerance, and touches only permitted parameter definitions and use sites. Failed rewrites silently fall back, which is what makes the pipeline scalable without manual repair.

6. Generate paired text. GPT-5.4 writes a design-intent-level description from the accepted program, deliberately omitting function names, variable names, and any hint of which representation was used, so the three supervision variants share the same text and geometry.

7. Run controlled comparisons. Three aligned representations share text, split, backbone, and training recipe; comparisons use 95% percentile bootstrap confidence intervals with 10,000 resamples over test instances, plus paired bootstrap intervals in the appendix. Editing is then tested zero-shot using the same generation checkpoints, with no edit-specific training.

Why This Matters

The paper's central claim is that dataset design — not just model design — is a lever for making AI-generated CAD genuinely reusable. A program that reproduces a shape but hides its structure is a dead end for engineering workflows, and this work quantifies how much structure in the training target is worth.

Real-world applications:

• Parametric part iteration: designers change a single shared dimension and have all dependent features update consistently, rather than hunting through repeated numeric constants.
• CAD scripting assistants: code-generating copilots that emit readable CadQuery with named parameters, making generated scripts reviewable and maintainable by engineers.
• Design automation and variant generation: product families where symmetric, concentric, or ratio-constrained geometry must be preserved across configurations.
• Lowering the CAD expertise barrier: natural-language-driven modeling for users who are not CAD specialists, with outputs that remain editable afterward.

Industry relevance: the evaluation explicitly targets reuse and local refinement, which is what separates a demo from a tool in mechanical design, manufacturing, and any workflow built on parametric CAD kernels. The public dataset and code release (linked in the paper) plus the conservative, validation-gated construction pipeline give practitioners a template for building domain supervision that stays executable rather than merely plausible.

Future Directions

• Broaden semantic coverage. The current template set is deliberately conservative, leaving many long-tail engineering features in primitive form; extending it without breaking the reliability guarantee is the most direct next step.
• Handle casual and underspecified language. All text descriptions are expert-level prompts, and the paper states that generalization to casual instructions is unstudied.
• Move beyond recoverable code-level signals. The authors explicitly bound "intent" to what is visible in code, leaving full design history, constraint solving, and solver feedback out of scope.
• Raise the lift rate. Because uncertain relations are rejected rather than repaired, some valid relations remain unlifted; better validation or repair could recover them. Closing the gap between explicit loop identifiers and spatial grounding — where success rates remain well below the with-identifier setting — is another open problem.

Target Audience

Researchers and graduate students working on LLM-based code and program generation for structured domains; CAD and geometry-processing researchers interested in parametric representations and editability; and industry engineers or dataset builders who want a concrete, validation-driven recipe for turning low-level construction traces into supervision that supports downstream modification. Readers focused purely on model architecture or decoding innovations will find little here — the paper's contribution is deliberately upstream of both.

Authors’ abstract

Text-to-CAD generation aims to make CAD modeling more accessible by generating executable CAD programs from natural-language descriptions. However, practical CAD workflows require more than executable geometry: generated programs should also expose reusable structure that supports later modification. We introduce intent-oriented text-to-CAD generation, where design intent is expressed as recoverable code-level signals: semantic features, reusable parameters, and lightweight parametric relations. Rather than changing the model architecture or decoding procedure, we investigate how supervision representation granularity affects both CAD generation and zero-shot intent-preserving editing. To enable this study, we construct IntentCAD-100K, a 100K paired text--code dataset built by converting low-level CAD construction traces into executable CadQuery programs. We further construct IntentCAD-Edit-1K to evaluate zero-shot intent-preserving editing from the same representation perspective. Intent2CAD uses a two-stage conservative lifting pipeline: semantic lifting rewrites reliable primitive groups into feature-level operations, while parametric lifting exposes lightweight parametric relations. Under controlled fine-tuning, semantic lifting mainly improves generation reliability and feature recovery, reducing IR from 2.39% to 0.22% and achieving 99.96% API Recovery, while parametric lifting makes reusable relation structure explicit and further improves relation-aware zero-shot editing. Datasets and code are available at https://github.com/JinboYang94/Intent2CAD.