Reconstructing Editable 3D Shapes as Parametric CAD Programs

33 concepts28 papers1 proposal

Imagine taking a 3D scan of a mechanical component, such as a custom engine bracket. Traditional computer vision pipelines process this raw sensor data into a dense triangle mesh, a voxel grid, or a neural radiance field. Visually, the reconstruction might look flawless. However, if an engineer needs to alter the diameter of a bolt hole or extend the bracket's length by five millimeters, they hit a wall. In a static mesh, making these adjustments requires tedious vertex manipulation that inevitably destroys the object's geometric precision. The mesh is a "digital statue"—frozen and uneditable.

In professional engineering, objects are designed using Computer-Aided Design (CAD) software. Designers do not manipulate raw vertices; instead, they write a procedural program. They draw 2D sketches, apply algebraic constraints (such as making two lines parallel or tangent), and execute sequential operations like extrusions, sweeps, or cuts.

To bridge the gap between unstructured 3D scans and professional engineering workflows, a rapidly growing research direction focuses on parametric editability. Rather than predicting static geometry, these methods reverse-engineer or generate the underlying construction history—the sequence of parametric commands—directly from raw data. By representing 3D shapes as executable programs, these approaches inherently expose semantic control variables, allowing human designers to seamlessly modify and iterate on reconstructed models.

Deconstructing Shapes into Sketch-and-Extrude Operations

The core mechanism of parametric reconstruction involves decomposing a continuous 3D shape into a discrete sequence of standard CAD operations. The most common paradigm mimics the foundational human workflow: identifying 2D profiles and their corresponding 3D extrusion parameters.

For example, Mikaela Angelina Uy et al. developed Point2Cyl: Reverse Engineering 3D Objects from Point Clouds to Extrusion Cylinders, which transforms raw point clouds into a collection of extrusion cylinders. By predicting geometric proxies and utilizing differentiable, closed-form solvers, their approach extracts fully editable CAD primitives from unstructured data. To eliminate the need for massive labeled datasets of design histories, Pu Li et al. introduced SECAD-Net: Self-Supervised CAD Reconstruction by Learning Sketch-Extrude Operations. Their self-supervised network predicts 2D implicit sketches and 3D extrusion parameters simultaneously, demonstrating that networks can learn the logic of CAD construction without explicit human annotations.

[Raw 3D Scan / Point Cloud] 
           │
           ▼ (Neural Network Decomposition)
[2D Sketch Profiles] + [Extrusion Lengths / Paths]
           │
           ▼ (Executable Program)
[Fully Editable Parametric CAD Model]

To capture more complex, organic geometry that simple linear extrusions cannot represent, M. Zhao et al. proposed SweepNet: Unsupervised Learning Shape Abstraction via Neural Sweepers. This framework abstracts shapes into "sweep surfaces" by driving a 2D profile along a 3D trajectory. Similarly, Pu Li et al. demonstrated in SfmCAD: Unsupervised CAD Reconstruction by Learning Sketch-based Feature Modeling Operations that decoupling global structural paths from local sketch details allows an unsupervised network to recover advanced operations like sweeps and lofts, mapping raw voxels directly to industry-standard CAD logic.

Recovering Subtractive History via Zone Graphs

A major hurdle in reverse-engineering CAD models is handling subtractive operations, such as drilled holes, pockets, or chamfers. When a designer cuts a volume out of a solid object, the geometry of that volume disappears, leaving behind only subtle traces on the remaining surfaces.

To solve this "invisible volume" problem, Xianghao Xu et al. introduced a geometric framework in Inferring CAD Modeling Sequences Using Zone Graphs. Instead of guessing arbitrary shapes, the authors extend the existing faces of a final 3D boundary representation (B-rep) outward into space. This face-extension process creates a collection of intersecting spatial volumes, or "zones," which represent a superset of all potential shapes that could have existed during the construction history.

By framing the problem as a discrete graph selection task, a Graph Neural Network (GNN) can evaluate the relationships between these zones and determine exactly which volumes were added and which were subtracted. This elegant mechanism turns an infinite search space into a manageable, discrete optimization problem, successfully recovering the historical traces of operations that are no longer physically present.

Enforcing Design Intent with Algebraic Constraints

A true CAD model is defined not just by its current dimensions, but by its design intent—the underlying rules that dictate how the geometry behaves when modified. If a user resizes a bracket, a hole centered on that bracket should remain perfectly centered.

To capture this relational intelligence, generative models must predict geometric primitives alongside their algebraic constraints. Ari Seff et al. pioneered this with Vitruvion: A Generative Model of Parametric CAD Sketches, a transformer-based architecture that outputs both the visual primitives of a sketch and its mathematical constraints (such as parallelism, perpendicularity, and tangency). This ensures that the generated models can be imported into professional software and edited without breaking their structural logic.

For solid 3D geometry, Daxuan Ren et al. introduced CSG-Stump: A Learning Friendly CSG-Like Representation for Interpretable Shape Parsing. Traditional Constructive Solid Geometry (CSG) relies on highly irregular, nested binary trees of Boolean operations (unions, intersections, and complements) that are notoriously difficult for deep networks to optimize. The authors "squash" these complex trees into a fixed-depth, three-layer structure that is highly compatible with neural networks, enabling unsupervised parsing of point clouds into clean, human-interpretable Boolean operations.

When dealing with imperfect inputs, such as smoothed simulations or noisy scans, Joseph George Lambourne et al. demonstrated in Reconstructing editable prismatic CAD from rounded voxel models that combining neural feature detection with a search-and-retrieval strategy for constrained 2D sketches can successfully snap rounded, degraded geometry back into sharp, mathematically valid CAD files.

Sequence Modeling and Language Interfaces

Because a CAD construction history is fundamentally an ordered sequence of discrete tokens and continuous parameters, researchers have increasingly leveraged sequence-generation architectures like Transformers and Diffusion models to infer CAD "languages."

In CADOps-Net: Jointly Learning CAD Operation Types and Steps from Boundary-Representations, Elona Dupont et al. showed that teaching a network to jointly predict what operation was performed and when it occurred in the sequence drastically improves the accuracy of sketch recovery. To scale this to raw point clouds, Elona Dupont et al. later introduced TransCAD: A Hierarchical Transformer for CAD Sequence Inference from Point Clouds, utilizing a two-tiered decoding strategy to handle noisy scan data. Similarly, Mohammad Sadil Khan et al. developed CAD-SIGNet: CAD Language Inference from Point Clouds Using Layer-Wise Sketch Instance Guided Attention, which employs specialized attention mechanisms focused on specific 2D sketch regions to accurately infer sequential design steps.

Rather than relying purely on autoregressive transformers, Weijian Ma et al. introduced a diffusion-based approach in Draw Step by Step: Reconstructing CAD Construction Sequences from Point Clouds via Multimodal Diffusion. Their model, CAD-Diffuser, utilizes a volume-based noise schedule that forces the network to mimic human design priorities—generating broad, primary outlines before refining fine geometric details.

This sequential framing has opened the door to natural language interfaces for 3D design. Mohammad Sadil Khan et al. introduced Text2CAD: Generating Sequential CAD Designs from Beginner-to-Expert Level Text Prompts, which translates text prompts into executable CAD commands rather than static meshes. To refine these generations, Jiahua Liao et al. developed Automated CAD Modeling Sequence Generation from Text Descriptions via Transformer-Based Large Language Models, combining a specialized generator with an LLM-based critic that refines command sequences based on confidence scores. To overcome the poor spatial reasoning of general-purpose models, Siyu Wang et al. proposed CAD-GPT: Synthesising CAD Construction Sequence with Spatial Reasoning-Enhanced Multimodal LLMs, embedding a 3D spatial localization mechanism into multimodal LLMs to ensure that text-to-sequence generation yields valid, watertight geometry.

Differentiable Shape Programs and Bidirectional Editing

The ultimate power of parametric editability is realized when the relationship between code and geometry becomes bidirectional and differentiable. When the execution engine itself can propagate gradients, deep learning models can optimize code parameters directly based on geometric feedback.

Bingquan Dai et al. demonstrated the utility of programmatic representations in MeshCoder: LLM-Powered Structured Mesh Code Generation from Point Clouds, using an LLM to convert point clouds into executable Blender Python scripts. Because the output is structured code, users can perform high-level topological modifications—such as altering component thickness or changing mesh resolution—simply by updating a variable in the script. For interactive design, Dan Caşcaval et al. developed Differentiable 3D CAD Programs for Bidirectional Editing. Their system utilizes a custom differentiable domain-specific language (DSL) that allows a designer to directly "drag" a 3D shape's geometry on screen; the system then automatically backpropagates that spatial movement to calculate the exact parameter updates required in the underlying program code.

  ┌────────────────────────────────────────────────────────┐
  │                                                        │
  ▼                                                        │
[Program Code / DSL] ──(Differentiable Execution)──► [3D Geometry]
  ▲                                                        │
  │                                                        │
  └───────────────(Gradient Backpropagation)───────────────┘

Taking this concept to its logical conclusion, Sinisa Stekovic et al. introduced PyTorchGeoNodes: Enabling Differentiable Shape Programs for 3D Shape Reconstruction. By making procedural node graphs differentiable, their framework can ingest a messy, real-world 3D scan and automatically optimize the continuous parameters of a shape program. Instead of outputting unchangeable voxels, it extracts the actual semantic "sliders" of the object—such as the height of a chair's backrest or the number of legs it possesses.

For multi-step modifications, Habib Slim et al. showed in ShapeWalk: Compositional Shape Editing Through Language-Guided Chains that mapping high-level language instructions to these procedural parameters allows models to execute complex, multi-step shape edits reliably. To extract these parameters from standard engineering documentation, Ke Niu et al. developed CReFT-CAD: Boosting Orthographic Projection Reasoning for CAD via Reinforcement Fine-Tuning, using reinforcement learning to train Vision-Language Models to accurately extract 3D parameter tables directly from 2D orthographic drawings.

By treating 3D shapes as executable, constrained programs rather than static spatial data, this research direction fundamentally changes how machines reconstruct and generate the physical world—turning passive geometric outputs into active, intelligent, and editable design partners.

Key Foundational Work

Point2Cyl: Reverse Engineering 3D Objects from Point Clouds to Extrusion Cylinders (2022) — contributed 2 concept elements to this direction.
Inferring CAD Modeling Sequences Using Zone Graphs (2021) — contributed 2 concept elements to this direction.
Reconstructing editable prismatic CAD from rounded voxel models (2022) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_parametric_editability_90345823,
  title = {parametric editability},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/parametric-editability/rdr_90345823f9c245049404cafe9e6da139},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_parametric_editability_90345823_v1,
  title = {parametric editability},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/parametric-editability/rdr_90345823f9c245049404cafe9e6da139/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake