AutoConstrain is a new feature in Autodesk Fusion that uses machine learning to automatically infer and apply geometric constraints to engineering sketches. It helps transform loosely drawn 2D geometry into well-defined, parametric designs, automatically detecting relationships like horizontal, vertical, tangent, and equal.

This capability is powered by a deep learning model trained on 2D geometry to predict constraints and dimensions that maintain design intent. By analyzing the structure and layout of sketch entities, the model suggests constraints that not only make sense mathematically, but also align with how designers typically work.

Why AutoConstrain?

Sketch constraints are foundational to parametric design. They define how geometry behaves when modified and are critical to ensuring models are predictable and editable. But today, adding constraints is largely a painstaking manual process and often overlooked until things break.

In real workflows, designers either spend time adding constraints by hand or leave sketches underconstrained, leading to unintended behaviors during editing. As shown above, changing a dimension from 100 mm to 60 mm in an underconstrained sketch (top) distorts the design, breaking its symmetry. With proper constraints (bottom), the geometry adjusts predictably, preserving the intended relationships. With AutoConstrain, we set out to build a system that understands sketches the way a designer does, not just as lines and arcs, but as meaningful arrangements that imply design intent.

Learning to Constrain

At the core of AutoConstrain is a deep learning model that takes an engineering sketch as input and predicts a sequence of dimensions and constraints that reference the geometric primitives in the sketch. The sketch below shows how different constraints and dimensions reference sketch primitives. Tangent constraints (blue) reference a line and an arc, horizontal constraints (orange) reference two lines, and linear dimensions (red) reference two points.

As the AutoConstrain model must dynamically reference geometry within each sketch, we combine a Transformer decoder with a pointer network architecture. This allows the model to "point" to the relevant sketch elements during generation. The figure below shows how sketch primitives are provided as input and the output is a sequence of predicted constraints/dimensions that reference back to the sketch primitives.

To train the model we randomly remove constraints and dimensions, and task the model with predicting the missing elements. This allows the model to learn to complete partially constrained sketches in a way that is consistent with existing geometry and design intent.

To further improve results, we fine-tune the model on fully constrained sketches and apply Classifier-Free Guidance, a technique that biases the model toward generating complete, well-constrained outputs. These strategies improve the quality and usability of AutoConstrain.

Deep Collaboration

AutoConstrain is the result of deep collaboration across Autodesk’s research, product, and ML platform teams. As head of the Model Operations team, I helped guide the development of this feature from early-stage experimentation to production deployment. Our team focuses on operationalizing foundation models across Autodesk’s product portfolio, ensuring reliability, performance, and seamless integration into tools like Fusion. This project reflects the kind of AI we aspire to build at Autodesk: intelligent, intuitive, and embedded directly into the creative process to help users focus on what matters most—design.

Further Reading:

• Using AI to Power AutoConstrain in Fusion – Autodesk Research Blog

• Sketch AutoConstrain: AI in Manufacturing – Autodesk Fusion Blog

One approach to CAD generative models is sequence-based approaches, which mimic parametric CAD modeling operations to generate structured, history-based geometry. These models work well for prismatic parts with clean modeling feature logic. However, many design workflows rely on direct modeling, where geometry is edited freely, without a fixed modeling history. Direct modeling is common when working with freeform surfaces, organic shapes, or imported geometry where parametric features are absent. Sequence-based methods often struggle here, limited by the operations they’re built to emulate.

Together with collaborators at Simon Fraser University, we developed a pair of generative models that directly synthesize the geometry of CAD models in the boundary representation (B-rep), the native format in most CAD systems:

• SolidGen, an autoregressive model that constructs B-reps element-by-element, predicting the geometry and topology of vertices, edges, and faces in sequence.
• BrepGen, a diffusion-based model that generates B-reps from a structured latent tree, enabling the creation of complex and freeform solids.

SolidGen: Autoregressive B-rep Generation

SolidGen was the first generative model to directly generate boundary representation (B-rep) CAD models. B-reps define solid geometry using a combination of topological elements, vertices, edges, wires, and faces, together with associated geometric primitives, such as lines, arcs, and circle curves, and surfaces such as planes, cylinders, and spheres.

SolidGen constructs B-rep geometry sequentially, predicting one topological element at a time—starting from vertices, then edges, and finally faces. Each element is built with full awareness of the ones that came before, allowing the model to maintain a coherent, watertight structure throughout the generation process.

At the heart of SolidGen is the Indexed B-rep representation. This framework encodes the hierarchical structure of a B-rep solid and explicitly tracks references between elements. As shown above, a face references a loop of edges, which in turn references vertices. This indexed structure is crucial for modeling valid B-reps and enables the model to "point back" to previously generated entities using a pointer network.

The SolidGen architecture (shown above) is based on Transformers and two-level pointer networks for the direct synthesis of B-reps without supervision from a sequence of CAD modeling operations. The architecture enables the generation of vertices, edges, and faces, allowing us to build the complete B-rep topology. 

The animation above shows the step-by-step process of B-rep generation in SolidGen:  edges are generated that reference vertices then faces are formed from loops of edges. As each element is generated, it is integrated into the growing structure, building up a complete and coherent B-rep solid. This highlights how SolidGen learns to construct geometry and topology together, enabling the direct synthesis of editable CAD models.

BrepGen: Structured Latent Geometry with Diffusion

BrepGen takes a diffusion-based approach that produces B-reps with higher fidelity and more flexible structure. Rather than generating geometry element-by-element in a strict sequence, as SolidGen does, BrepGen operates on a structured latent geometry representation that encodes each B-rep as a hierarchical tree (shown in the figure below). The root node represents the solid, with child nodes for faces, edges, and vertices, each encoding geometric features from sampled UV points. Shared topology is captured through node duplication, allowing the model to implicitly learn mating and adjacency relationships.

Using a transformer-based denoising diffusion model, BrepGen reconstructs the solid from root to leaves, first generating global structure, then refining local geometry. After generation, duplicated nodes are merged to recover connectivity, trimming faces from closed edge loops and assembling a complete, watertight B-rep. This approach enables the generation of more intricate surfaces and topologies, including curved, doubly-connected, and freeform geometry that’s difficult to express through sequential modeling alone.

The animation below illustrates the denoising diffusion process in 3D. On the left, surface geometry is progressively refined from noisy samples into clean UV grid patterns representing surfaces. On the right, vertex and edge positions emerge from coarse, disordered points into structured topological elements. 

We found that BrepGen produces geometry with improved structural complexity and visual fidelity compared to SolidGen. In the figure below, you can see that BrepGen generates more diverse and expressive shapes with fewer open boundaries and self-intersecting edges.

BrepGen performs well across a range of tasks, from generating novel shapes to completing partial geometry such as in the figure below. The grey geometry on the left is the input to the model, and the blue geometry shows completions on each row.

BrepGen significantly improves over prior models in both geometric diversity and B-rep validity, generating more expressive and topologically varied solids. Because it operates directly within structured B-rep space, its outputs are immediately compatible with modern CAD pipelines, an enabler for real-world design, editing, and downstream applications.

Toward General-Purpose CAD Generation

SolidGen and BrepGen represent a step toward more capable and flexible generative models for CAD, models that move beyond legacy parametric modeling sequences to generate geometry directly in the native B-rep format. This shift makes it possible to support a wider range of design workflows, including direct modeling and freeform geometry, while producing outputs that are immediately usable in real-world CAD systems. By learning to generate both geometry and topology together, these models open new directions for intelligent design tools that can suggest, complete, and synthesize complex 3D forms. As generative modeling continues to advance, we see direct B-rep generation as a foundational capability for the next generation of ML-assisted CAD tools.

SolidGen Paper: SolidGen: An Autoregressive Model for Direct B-rep Synthesis (TMLR 2022)

BrepGen Paper: BrepGen: A B-Rep Generative Diffusion Model with Structured Latent Geometry (SIGGRAPH 2024)

BrepGen Code: https://github.com/samxuxiang/BrepGen 

Created By: Autodesk Research / SFU

Co-Authors: Pradeep Kumar Jayaraman (SolidGen lead author), Xiang Xu (BrepGen lead author), Joe Lambourne, Zhengqing Wang, Nishkrit Desai, Aditya Sanghi, Nigel Morris, Yasutaka Furukawa

How can machine learning represent and generate 2D sketches and 3D mechanical parts in ways that are structured, controllable, and useful for design workflows? Together with collaborators from Simon Fraser University, we developed a pair of generative models for CAD aimed at learning how humans design:

• SkexGen, a model that disentangles topology and geometry into separate codebooks for generating sketches and extruded parts.

• Hierarchical Neural Coding (HNC), an extension of this work that introduces a multi-level codebook structure, enabling even more flexible and hierarchical control over generation and completion.

These models open up new possibilities for AI-assisted CAD, allowing for partial edits, hybrid designs, and interactive generation grounded in the patterns of real-world design data.

Learning From Human Design Sequences 

Parametric CAD modeling relies on sketch and extrude operations to define 3D shapes. These sketches are typically defined with constraints and dimensions that support quick edits and design variations. However, setting up constraints is time-consuming and requires expert knowledge.

Take the example of a heat sink design. Parametric constraints can be used to drive the number of fins, spacing between fins, and the overall body shape. This allows the design to be updated quickly and consistently across the model.

However, defining such constraints is a manual process and requires a deep understanding of the underlying geometry. Here are the parameters driving the heatsink design, it's a job for an expert.

What if we could learn from how people design and use that to generate new, editable designs automatically? What if we could capture the patterns and structure embedded in real-world sketches and parts and use that as the basis for fast, controllable design generation?

SkexGen (SKetch and EXtrude GENerative model)

SkexGen tackles this problem by firstly separating out the topology from geometry in our representation, so they can be controlled individually downstream.

As with prior work we generate a sequence of tokens based on the hierarchy of curves, loops, faces, and extrusions found in sketch and extrude construction sequences.

Here is where it gets interesting, these tokens are fed into separate Transformer encoders to encode the topology, geometry, and extrude information into separate quantized codebooks. A separate sketch and extrude decoder is used to generate a CAD construction sequence.

The same process can be used to generate 3D parts. At inference time, we can sample from the codebooks and decode them into sketches or parts. 

The disentangled structure allows us to generate and manipulate designs in meaningful ways. When we generate 2D sketches or 3D parts we can use the same code in any of the codebooks to produce results that are similar in either topology, geometry, or extrusion parameters. Here we keep the topology code the same so the designs have similar overall structure.

Code mixing can also turn 😀 into 😐.

Hierarchical Neural Coding for Controllable CAD Model Generation

While SkexGen separates design elements into discrete codebooks, our follow-up work, Hierarchical Neural Coding (HNC), takes this further by introducing structure tied to the hierachy of a CAD model.

As shown above, a sketch and extrude CAD model is naturally hierarchical, consisting of several nested entities: loops define individual 2D contours, profiles represent closed regions composed of one outer loop and potentially multiple inner loops, solids correspond to extruded profiles, and the complete model is composed of one or more solids. Our goal is to enable both local and global control in the generation process, where users can edit any of these entities, whether a loop, profile, solid, or the full model, and have the rest of the design update automatically in a coherent way.

Unfortunately this is not the case today, parametric CAD requires specialized skills and can easily fail when constraints are missing or incomplete. For example, simple edits to the table design above, such as changing leg length or tabletop size, can break the original intent, resulting in misaligned or distorted geometry. These issues highlight the limitations of current tools and the need for ML models that can better preserve design intent.

Our HNC generative model captures CAD design intent as a three-level tree of neural codes, spanning local geometry to global part structure. This representation enables generation and completion of CAD models based on partial inputs, directly specified code trees, or unconditional generation (shown above). The model learns these hierarchical codebooks using a novel VQ-VAE with masked skip connections, producing clean, interpretable representations learned from a large dataset of sketch-and-extrude models. A two-stage transformer then maps between geometry and code trees, allowing flexible, controllable generation. The final designs are outputed as modeling operations and converted into a standard B-Rep format for use in CAD tools.

The figure above illustrates how user edits can be automatically propagated across the design to maintain consistent structure and preserve design intent. Whether modifying the spacing of facial features in a sketch (left) or adjusting the dimensions of a table design (right), the model updates the rest of the geometry in a coherent way. 

The figure above demonstrates the model’s ability to autocomplete partial geometry into complete, realistic designs. Given an incomplete sketch (left) or part (right), the model generates multiple coherent completions, each reflecting plausible design intent. 

Reimagining Design Tools

Together, SkexGen and HNC reflect our ongoing effort to learn expressive and controllable representations for CAD design. With SkexGen, we introduced a disentangled codebook model that separates topology, geometry, and extrusion. With HNC, we take this further, learning hierarchical code structures that reflect how designs are composed and allowing more granular control over the generative process. Our aim is to build tools that support the creative intent of designers. Tools that don’t replace human input, but amplify it by making the design space more navigable, editable, and interactive. 

SkexGen Paper: SkexGen: Autoregressive Generation of CAD Construction Sequences with Disentangled Codebooks (ICML 2022)

SkexGen Code: https://github.com/samxuxiang/SkexGen

HNC Paper: Hierarchical Neural Coding for Controllable CAD Model Generation

HNC Code: https://github.com/samxuxiang/hnc-cad 

Created By: SFU / Autodesk Research

Co-Authors: Xiang Xu (Lead author), Joe Lambourne, Chin-Yi Cheng, Pradeep Kumar Jayaraman, Yasutaka Furukawa

Ever wondered how physical objects with hundreds of parts get assembled in CAD? It’s a tedious process that we automate by learning how pair of parts connect to form joints.

So what does joint setup look like in CAD today? Designers manually pick edges or faces on each part and a joint is formed that constrains the two parts to one another. Once constrained the parts move as one.

However, doing it over and over again is time consuming and error prone...

What if we could automatically create a joint to assemble a pair of parts just by looking at their shape? Could we do this without any object category labels or human guidance? Here’s how we tackle it...

We take a bottom up approach to learn how parts connect locally. We frame the problem as a categorical one and make direct predictions on a solid model's discrete set of faces/edges. We represent each part as a graph and predict a single joint connection between the two parts.

The predicted faces/edges give us a joint axis to align the two parts and the final pose can be recovered using a neurally guided search.

JoinABLe outperforms all of the other methods we compared against and is within 0.5% of human performance on the joint axis prediction task. The image below shows how JoinABLe assembles pairs of parts in a more realistic way than a point cloud baseline.

We release our code along with a new dataset of multi-part CAD assemblies containing rich information on joints, contact surfaces, holes, and the underlying assembly graph structure.

Paper: JoinABLe: Learning Bottom-up Assembly of Parametric CAD Joints (CVPR 2022)
Code: https://github.com/AutodeskAILab/JoinABLe 
Dataset: https://github.com/AutodeskAILab/Fusion360GalleryDataset 

Created By: Autodesk Research / MIT

Co-Authors: Pradeep Kumar Jayaraman, Hang Chu, Yunsheng Tian, Yifei Li, Daniele Grandi, Aditya Sanghi, Linh Tran, Joe Lambourne, Wojciech Matusik, Armando Solar-Lezama.

The objects around us, chairs, cars, devices etc., are almost always designed as solid models in CAD, but surprisingly few deep learning approaches have been used to date. Making it difficult to explore how learning based methods might enhance future CAD tools with features such as auto-complete or interpolation between CAD models. Part of the challenge has been the availability of suitable data, and part teaching these algorithms to speak CAD. We tackled both of these challenges over the course of several collaborations between Autodesk Research and MIT, Brown Universty, and UCL, with results published at CVPR and SIGGRAPH.

Solid models use the boundary representation, or B-Rep. Think of a B-Rep as a watertight mesh where the faces don’t need to be flat and can be trimmed to any shape. These faces are ‘glued’ together, with the topology forming a well structured graph.

In UV-Net (Paper, Code) we use this graph with a GNN and sample a point grid on each face for use with a CNN. This combination outperforms mesh and point cloud methods on both classification and segmentation.

In BRepNet (Paper, Code) we show that convolutional kernels can be applied with respect to oriented coedges to outperform both network and heuristic methods on segmentation.

Along with BRepNet we also release a new segmentation dataset with over 35k CAD models in B-Rep, mesh, and point cloud representations.

So if you have access to solid model data, it can really help with classification and segmentation. But what about other tasks? One long sought after goal in CAD is to reverse engineer a CAD model when the modeling history is not available. We tackle this problem with a new representation, the Zone Graph (Paper, Code), where each zone is a solid region formed by extending all B-Rep faces and partitioning space with them. 

Finally, in a CVPR workshop paper we explore how we might synthesize solid models by first generating plausible engineering sketches using transformers (Paper).

Created By: Autodesk Research / MIT / Brown University / UCL

Co-Authors: Pradeep Kumar Jayaraman, Joe Lambourne, Xianghao Xu, Wenzhe Peng, Aditya Sanghi, Yewen Pu, Hang Chu, Tao Du, Wojciech Matusik, Hooman Shayani, Armando Solar-Lezama, Daniel Ritchie, Thomas Davies, Nigel Morris, Peter Meltzer, Jieliang (Rodger) Luo, Chin-Yi Cheng