The one-paragraph version
Given a single freehand sketch of an object like a chair or a sports car, Composable CAD builds not one 3D model but a whole mix-and-match kit of 3D models, with several different versions of each part. You can pick any base with any seat with any backrest, and any combination will still fit together into one solid, buildable object. It does this with off-the-shelf vision-language models plus explicit geometry: first it reads layout hints from the sketch and builds a very simple block layout called a proxy, then it asks the model to flesh out each block into detailed code independently, then it runs a fixed geometric fix-up that seats each detailed part back onto its assigned block and its shared flat contact areas. The output is a set of editable CadQuery programs, one per part variant, that are interchangeable by construction.
The problem they're solving, and why it matters
Designers often start with a loose sketch that says what the parts are, roughly how big each is relative to the others, how they line up, and what touches what. They then rebuild that idea in computer-aided design, usually part by part, and want to try variations without redoing everything.
Recent vision-language models can turn a sketch plus a prompt like “generate CAD for a chair” directly into CAD code, sometimes in a loop where the model runs the code, looks at a render, and fixes it. The paper argues this fails in an important way when you want parts.
A part that looks good alone is not necessarily composable, meaning it can be combined with other independently made parts into a coherent whole. In practice independently sampled parts drift: proportions change, alignments slip, and where two parts should meet you get a gap with empty air, an overlap where two solids interpenetrate, or a wobbly touch like a dome touching along a curve instead of two flat faces pressing together.
That matters because real design is collaborative and iterative. Different people may own different parts, you may want to keep five versions of a backrest while the seat stays fixed, or you may want to 3D print the kit and physically assemble any combination. If every new variant breaks the joints, the design space is not actually usable. The paper reframes sketch-to-CAD as generating a design space of interchangeable part programs, not a single shape.
The key idea, in plain words
Think of building with shoeboxes before carving furniture.
First, agree on where each shoebox goes, how big it is, and which boxes touch. That coarse arrangement is the proxy. It captures the designer’s intent from the sketch in a deliberately crude form: one simple volume per part, placed in a shared coordinate frame.
Second, let different sculptors carve the detail inside each shoebox independently, without looking at the other boxes. Because each sculptor starts from their own box plus a crop of the sketch showing just their part, they can add a lot more detail than a model trying to hold the whole object in mind at once, and they can work in parallel.
Third, have a carpenter, not an artist, do the final fitting. A deterministic geometric procedure, meaning a fixed rule with no AI guessing, trims or pads each carved part so it stays inside its own shoebox and meets its neighbors exactly over pre-agreed flat contact patches called connecting surfaces.
The crucial distinction is between two kinds of rules. Design constraints are soft wishes recovered from the sketch, such as this part sits on that part, these edges line up, this part is about twice as long as it is wide, these two armrests mirror each other. Structural constraints are hard requirements for assembly derived from the proxy, such as stay inside your box, and cover this exact flat rectangle where you meet your neighbor without sticking past its plane. The paper uses the soft wishes to build the proxy, then uses the hard requirements to force interchangeability.
How it actually works, step by step
Planning happens once for the whole object, before any detail is added.
Segmentation: the system asks a vision-language model to list the semantic parts a designer would model separately, for example base, column, seat pan, backrest, left armrest, right armrest, then asks an image model to paint a color-coded mask for those parts. Each part’s pixels are recovered by color.
Geometric prior, meaning layout hints measured from the drawing itself rather than guessed by the language model: the system vectorizes strokes and finds T-junctions, places where one stroke end hits the middle of another at an angle, as evidence that two parts cross or attach. Strokes near junctions vote for the two horizontal directions in the drawing, while vertical is assumed to be up on the page. Projecting each part mask onto those three axes lets the system read alignment, meaning anchors like minimum, center, and maximum line up within a small pixel tolerance, and proportion, meaning relative extents along the three axes snapped to a coarse grid. Mirroring comes directly from the part list.
Proxy building and checking: the model is prompted to write a CadQuery program with exactly one function per part returning one primitive volume, placed to match proportions, alignments, and attachments. Each recovered relation is also compiled into a small check function that can be executed against the built geometry to report pass or fail. The system runs those checks and gives one round of natural-language feedback. The authors treat these as guidance, not strict law, because both the sketch and the extraction are approximate. Mirroring is exact by generating once and reflecting.
Fixing interfaces: overlapping proxy boxes are trimmed so interiors do not overlap. Where two attached boxes touch, their shared flat overlap becomes the connecting surface. Those boxes plus surfaces are the structural constraints that all later variants must obey.
Detail generation happens independently per part. For each part the model receives only that part’s proxy code and that part’s sketch region, and is told to edit and elaborate the existing operations rather than rewrite from scratch. The paper samples five variants per part in parallel with increasing sampling temperature from 0.1 to 0.5, so low-temperature samples stay faithful and higher-temperature samples diverge more.
Deterministic rewrite seats each sample. In words: move, then stretch, then add or shave only at the joints.
Step 1, translate: move the detailed solid so its center matches its proxy box center. This changes no shape.
Step 2, scale: scale separately along each axis about the box center until the part reaches its connecting surfaces while staying inside its box.
Step 3, form a flat face: look locally at each interface. If the surface falls short, meaning concave, union on, meaning add, a solid made by extruding the connecting surface inward until it hits the part, filling only the gap. If the surface sticks out past the plane, meaning convex, cut away only the excess beyond the plane. The paper shows the opposite choice would flatten shaped detail into a featureless plane.
The rewrite appends operations to preserve the sampled code, operates on executed geometry because connecting faces are often implicit in code like an extrusion, and is capped by a material budget that limits changed volume to 10 percent of the shape. If a part cannot be seated within budget, that composition is counted as failed.
The authors state a composability guarantee: if proxies have disjoint interiors, each attached pair shares one flat surface, the attachment graph is connected, and samples meet stated conditions about having solid material where needed, then any choice of one rewritten sample per part has disjoint interiors, meets exactly over those surfaces, and forms one connected solid. The budget does not weaken the geometry when it succeeds; it just declares failure when too much change would be needed.
The same interfaces enable editing and fabrication. You can redraw a part in 2D, borrow a finished part from another design, or describe a replacement in text like “slotted trident” headstock for a guitar. The replacement inherits the old part’s proxy and surfaces and is seated the same way. For printing, the system adds a peg on one side and matching socket on the other centered on each connecting surface, so digital interchangeability carries over to physical parts.
What they showed — results, honestly, with limitations
They evaluated on 33 objects drawn from OpenSketch, DifferSketching, SlowSketch, and AmateurSketch, covering different styles from dense professional construction lines to a few loose strokes. Each method made five program variants per object. They scored shapes as generated, where all parts come from the same run, and recombined, where parts are randomly mixed across runs to test interchangeability.
For preserving sketch intent, their pipeline without rewrite scored highest on proportion at 91.2 percent of relations satisfied and alignment at 88.8 percent, with the full method slightly lower at 89.4 and 86.9 percent because the rewrite moves geometry after those checks. Single-pass and two-pass vision-only baselines were lower, around 75 to 85 percent. Mirroring was 100 percent for their method by construction versus 93.0 and 82.3 percent for baselines.
For structural validity they checked three things: no overlap, attached pairs actually touch within 0.1 centimeters after normalizing to a 10 centimeter box, and valid interface, meaning they meet over a flat region large enough relative to thickness. As generated, their full method had 93.3 percent of shapes pass all three versus 73.9 percent for single-pass. After recombination the gap explodes: they stay at 91.5 percent, while single-pass collapses to 9.9 percent because parts made together do not mix. The ablation without rewrite and the two-pass baseline stay around 54 to 55 percent after recombination, pointing to the rewrite as the key.
They also tested asking the vision model itself to repair bad recombinations with up to three minutes of execute-and-revise. Overlap and attachment improved but valid flat interfaces did not, moving from 55.2 to 54.1 percent all-succeed versus 91.5 percent for their geometric rewrite, which takes negligible extra time. The authors suggest this is because the model must reason about joints indirectly through code while their rewrite measures executed geometry directly.
Detail and cost: their method averaged 127.5 CAD operations and 274.8 lines of code per object versus 53.2 operations and 77.9 lines for single-pass. Examples show spoked wheels, slatted grilles, and panel creases where single-pass gives slabs and plain cylinders. Generation takes about 5 to 11 minutes with parallel part calls and about 526 thousand tokens on average using Gemini 3.1 Pro, more tokens than baselines because of constraint feedback, but faster than sequential two-pass generation.
Two user studies: 12 participants preferred their outputs over single-pass on detail in 77.8 percent of trials, proportion 66.7 percent, fidelity as a buildable depiction 70.0 percent, and overall 75.6 percent, all statistically above chance. Six participants in an exploratory study all preferred picking parts over picking whole shapes, reacted negatively to floating or overlapping baseline parts, and said exploration developed their rough sketches, though whole-shape variants could feel more divergent. Participants wanted controllable and hierarchical segmentation.
Limitations the authors state plainly: segmentation is a single flat list, so you cannot open a part into subparts; the CadQuery representation favors prismatic extrusions, fillets, and booleans and handles freeform surfaces like car bodies mainly as massing changes; and interfaces are limited to one flat shared surface per attached pair, excluding curved or disconnected joints and broader requirements like clearance, function, manufacturability, and general symmetry.
Why this might matter to me
For spatial reasoning in vision-language models, this is a concrete pattern for not asking the model to do what it does poorly. Quantitative placement, inferring exact 3D contact planes from implicit code, and predicting execution are delegated to measured stroke geometry and executed solids, while the model does what it does well: proposing plausible detailed programs from a local visual plus code context. The failure of model-based repair versus geometric repair is a useful datum.
For world models and 3D generation, the proxy plus connecting surfaces act like a tiny scene representation with explicit contact semantics. Instead of generating a soup of geometry and hoping joints emerge, layout, attachment graph, and contact patches are fixed once and reused as invariants across samples. That separation of global structure from local appearance is directly relevant to controllable generation and persistent worlds.
For text-to-CAD and parametric geometry, the work shows the value of editing proxy code rather than generating from text alone, preserving program structure while adding operations, and of treating constraints as executable check functions with residuals for feedback. The material budget is also a transferable idea: a principled knob for how much post-hoc fitting may distort a generative sample.
For part-based 3D and scene representation, interchangeability is the core contribution. By forcing every variant through the same box-and-surface contract, recombination becomes compositional: five variants of each of five parts yields thousands of valid assemblies without re-generation. The peg-and-socket extension shows how a digital contact specification can drive physical assembly, a step toward generative design that remains fabricable.
Terms worth knowing
Vision-language model: a model that takes images plus text and produces text or code. Here it writes and edits CAD programs but is not trusted for precise 3D measurement.
CadQuery program: Python code that builds solid geometry through operations like sketching profiles, extruding, filleting, and boolean union and cut. The paper’s output, editable and executable, not just a mesh.
Proxy: an intentionally crude whole-object program with one simple volume per part that fixes size, position, and adjacency before detail is added. Think agreed shoeboxes.
Design constraints: soft layout wishes from the sketch — attachment which parts touch, alignment which edges or centers line up, proportion relative sizes, mirroring symmetric pairs — used as guidance with feedback.
Structural constraints: hard assembly requirements from the proxy — stay inside your proxy box, cover each assigned connecting surface without crossing its plane — enforced exactly.
Connecting surface: the flat shared patch where two proxy boxes meet, the contract that detailed parts must cover after rewriting.
Deterministic rewrite: the fixed three-step fitting procedure of translate, then scale, then union material where concave or cut where convex, with no learned guessing.
Material budget: a cap, set to 10 percent of shape volume in the paper, on how much the rewrite may add or remove. It trades preserving sampled detail against achieving valid joints.
Composable: the property that any one variant chosen per part combines into a single connected solid with no gaps or overlaps, the paper’s central goal.