The one-paragraph version
This paper asks a representation question, not a model question: if you keep the language model, the training method, the text prompts, and the test shapes all fixed, does it matter how you write down the CAD program the model is supposed to learn from? The authors argue yes. They start from low-level construction traces — long lists of lines, arcs, circles and extrusions inherited from the DeepCAD dataset — and build a pipeline that carefully rewrites those traces into cleaner, executable CadQuery code. When a group of lines can be reliably recognized as a rectangle, or a set of equal radii can be reliably recognized as sharing one value, the pipeline makes that structure explicit in code and otherwise leaves the low-level code alone. That creates three aligned training targets for the same shapes: primitive-only, semantic, and semantic-plus-parametric. After fine-tuning the same model on each target, the semantic version is much more reliable to generate and the semantic-plus-parametric version is much easier to edit in a way that preserves relations like equality, mirroring, or proportional sizing.
The problem they're solving, and why it matters
Text-to-CAD means turning a natural-language description into a program that, when run, builds a 3D solid model. Recent work has made this executable much of the time, but the authors point out that executability plus roughly correct shape is not enough for real parametric CAD work.
In parametric CAD modeling — meaning modeling where a shape is defined by named features and editable dimensions rather than just frozen triangles — a good program must support later reuse and modification. A concrete example from the paper: two holes might both have radius 0.857. A primitive-only program would simply write that number twice. The shape looks right, but if a designer later says change one radius to 0.94 while keeping them equal, the program gives no hint that the two numbers should move together. Similarly, a rectangle drawn as four separate line segments looks correct but is painful to move as one rectangle.
The authors call the missing piece intent-oriented text-to-CAD generation. Here intent is used in a deliberately narrow sense, which they define explicitly. It does not mean full design history or the designer's mental purpose. It means only three kinds of recoverable signals visible in code: semantic features, meaning recognizable modeling operations like rectangle or slot or fillet; reusable parameters, meaning named variables for things like width or radius instead of repeated numbers; and lightweight parametric relations, meaning simple links like equal values, concentric centers, mirrored positions, offset distances, or simple ratios. Without those signals, models can pass shape metrics while producing code that is brittle to edit.
The key idea, in plain words
The key idea is to change the supervision, not the learner. Supervision here means the target code the model sees during training.
Think of two recipes that produce the same cake. One lists 50 tiny stirring actions with temperatures written out each time. The other says make the sponge base, then make the same frosting twice using one shared sugar amount. Same cake, very different ability to adjust later. The paper tests whether language models learn better CAD when taught with the second kind of recipe.
To do this without hand-labeling 100,000 models, they propose what they call conservative lifting. Lifting means raising low-level code to a higher-level description. Conservative means lift when reliable, preserve when uncertain. If geometric shape matching and recovered constraint evidence both agree that four segments form a rectangle, rewrite it as a rectangle operation with explicit width and height. If evidence is weak or the pattern is not in the supported set, keep the original segments as a fallback loop. A second stage does the same for relations: if there is good evidence that two dimensions are meant to be equal, rewrite them to use one shared variable; if one position is meant to mirror another, rewrite it as a simple mirrored expression. Every proposed rewrite must still run and must still produce the same solid within a tight tolerance, or it is rejected.
How it actually works, step by step
First, the team builds a dataset called IntentCAD-100K. They start from 178,238 raw construction sequences from DeepCAD. For comparison, DeepCAD is a large public collection of CAD models stored as low-level sketch-and-extrude command histories. Many samples are discarded because they cannot be converted to valid CadQuery, which is a Python library for building solids through code, or cannot be normalized and validated. They also remove duplicates based on a quantized construction signature before any lifting, so the three representations stay aligned. The result is 100,000 paired text-and-code examples split 80/10/10 for training, validation, and testing.
Construction uses a two-stage lift-and-validate pipeline. In plain words before any formal check:
Stage 1 is reconstruction plus semantic lifting. The pipeline first rebuilds each raw sequence as runnable low-level CadQuery code, giving every tiny geometric piece a unique tag identifier. It also builds a constraint graph, meaning a network where nodes are those tagged pieces and edges record recovered local relations like parallel or equal length. Then for each candidate group of pieces and each supported feature template — for example rectangle, regular polygon, irregular polygon, slot, fillet, or array — it asks two questions in words: does the geometry look like the template, and do the recovered relations support that interpretation? Only if both are true is the group rewritten as a feature-level call with explicit parameters. Otherwise the low-level code is kept.
Stage 2 is relation lifting by local rewriting. The Stage 1 program now has features but may still repeat numbers. A large model, reported as GPT-5.4, is used only as a proposer, not as final authority. It sees the program plus the constraint summary and proposes a structured plan to change only variable definitions into shared variables or simple derived expressions. The plan cannot change operation order, cannot add operations, and must keep evaluated numbers the same. A deterministic validator then accepts the rewrite only if three things hold in words: it executes to a valid non-empty solid, it preserves geometric invariants like volume, bounding box, and center of mass within a tolerance of 10 to the minus 5, and it changes only allowed parameter definitions. If any check fails, the Stage 1 version is kept.
After that, the same model family generates an expert-level text description that mentions features and relations but is forbidden from mentioning code details like function names or variable names. This yields three aligned targets per shape: primitive-only before lifting, semantic after Stage 1, and semantic-plus-parametric after Stage 2.
For evaluation they add intent-aware metrics beyond the usual Invalid Ratio, meaning share of programs that fail to run or form a valid solid, and Chamfer Distance, meaning symmetric point-cloud distance between predicted and true shapes after normalization. They define API Recovery as feature-level F1 agreement on semantic feature types after normalizing equivalent calls; Equal Relation Score as preservation of shared-variable structure; and Parametric Relation Score as preservation of derived expressions that reference other variables. For editing they build IntentCAD-Edit-1K: 1,000 cases with 414 Feature Edits that replace a feature or change an attribute, 311 Consistency Edits that change one value while keeping equality-like links, and 275 Derived-Relation Edits that change one value while keeping mirror, ratio, or distance links. Crucially, editing is zero-shot: the generation checkpoint is asked to output the full edited program with no extra editing training.
What they showed — results, honestly, with limitations
A diagnostic test first shows existing systems struggle on these intent-oriented prompts. Reported general models have Invalid Ratios around 41-50%, while dedicated CAD models trained elsewhere transfer poorly on shape and feature recovery. After supervised fine-tuning with Low-Rank Adaptation, meaning training only small adapter weights while freezing the base Qwen models, Invalid Ratio drops to around 0.2-0.3% with near-perfect feature recovery. This motivates the dataset but does not yet isolate representation, so the controlled comparison matters more.
Under identical backbone, data split, and training, semantic lifting accounts for the largest generation gain. Invalid Ratio falls from 2.39% for primitive-only to 0.22% for semantic, mean Chamfer Distance falls from 1.44 to 0.46 in units of 10 to the minus 3, and API Recovery reaches 99.96%. Parametric lifting keeps reliability and median shape similar while adding relation recovery of 93.35% Equal Relation Score and 95.25% Parametric Relation Score. Those relation scores are not applicable to the earlier representations because those targets do not expose relations.
Zero-shot editing shows a similar division. Overall Edit Success Rate, meaning executable plus correctly realizing the requested change after resolving variables, rises from 41.80% primitive-only to 88.90% semantic to 92.50% semantic-plus-parametric. Feature-edit success jumps most with semantic lifting, while relation-aware edits gain most with parametric lifting: Consistency Edit success from 91.00% to 95.82% and Derived-Relation Edit success from 77.09% to 88.73%, with paired bootstrap intervals reported as excluding zero. A 200-case visually grounded test where loop names are replaced by spatial descriptions shows the same pattern plus better target localization.
Honestly, scope is limited. The paper supports only a conservative set of common templates; about 82.68% of programs get full semantic recognition and only 34.24% get at least one relation proposal, with the rest falling back to primitives. Prompts are expert-level and fairly explicit, so casual or underspecified language remains untested. Intent means only code-level signals, not full constraint solving. The pipeline reduces bad supervision by rejecting uncertain rewrites, but that also means some valid relations are left unlifted. Details like the exact behavior of the GPT-5.4 proposer and rater are described only at prompt level, so that part is harder to independently verify from the paper alone.
Why this might matter to me
For spatial reasoning in LLMs and VLMs, the visually grounded editing result is striking: the same edit instruction and same four-view rendering succeed far more often when the underlying code has named features and shared variables. That suggests localization is not only a vision problem; a cleaner symbolic scaffold gives the model discrete, referable objects to attach spatial words to. The finding that meaningful API names matter — an anonymized version with identical structure but scrambled names collapses in reliability — also points to language priors as part of spatial competence.
For world models, the lesson is that prediction of the next shape is less useful than prediction of an editable causal structure. A world model that knows two cylinders share a radius or two blocks are mirrored can propagate one intervention correctly, which is exactly what Consistency and Derived-Relation Edits test. The paper offers a concrete recipe for exposing that structure as variables plus tiny expressions rather than a heavy solver.
For text-to-CAD and parametric geometry, this is directly reusable: lift-when-reliable plus execute-and-compare validation is a practical way to upgrade primitive traces into training data without inventing false constraints. For 3D generation and scene representation, the broader principle transfers. Whether the primitive is a mesh triangle, a Gaussian, or a line segment, learning from flat primitives encourages mimicry of geometry, while learning from grouped features with shared parameters encourages learning of composition and symmetry that survives editing.
Terms worth knowing
Computer-Aided Design program: executable code that builds a solid by sketches, features, extrusions, and Boolean operations, not just a static mesh.
CadQuery: a Python library used here as the target language for CAD programs.
Design intent in this paper: only recoverable code signals — semantic features, reusable parameters, lightweight relations — not full history or designer goals.
Primitive-only supervision: training target that keeps low-level segments, arcs, and repeated numbers.
Semantic lifting: rewriting a reliable primitive group into a feature call like rectangle or slot with explicit parameters.
Parametric lifting: rewriting parameters into shared variables for equality or into simple expressions for mirror, distance, or ratio links.
Fallback loop: preserved low-level code when lifting is unsupported or uncertain.
Constraint graph: nodes are tagged geometric pieces and edges are recovered local relations used as evidence for lifting.
Invalid Ratio: fraction of generated programs that fail to execute into a valid solid.
Chamfer Distance: symmetric distance between sampled surface point clouds, reported times 1,000.
API Recovery: F1 agreement on semantic feature types between prediction and ground truth.
Equal Relation Score and Parametric Relation Score: preservation of shared-variable structure and derived-expression structure, reported only where ground truth contains them.
Feature Edit, Consistency Edit, Derived-Relation Edit: edit types that change a feature, change one value while keeping equality links, or change one value while keeping mirror, ratio, or distance links.
Edit Success Rate: share of edits that run and match the target on affected loops after resolving variables, within 10 to the minus 5 tolerance.