Papers
Topics
Authors
Recent
Search
2000 character limit reached

GeoFusion-CAD: Structure-Aware Diffusion with Geometric State Space for Parametric 3D Design

Published 23 Mar 2026 in cs.CV and cs.GR | (2603.21978v1)

Abstract: Parametric Computer-Aided Design (CAD) is fundamental to modern 3D modeling, yet existing methods struggle to generate long command sequences, especially under complex geometric and topological dependencies. Transformer-based architectures dominate CAD sequence generation due to their strong dependency modeling, but their quadratic attention cost and limited context windowing hinder scalability to long programs. We propose GeoFusion-CAD, an end-to-end diffusion framework for scalable and structure-aware generation. Our proposal encodes CAD programs as hierarchical trees, jointly capturing geometry and topology within a state-space diffusion process. Specifically, a lightweight C-Mamba block models long-range structural dependencies through selective state transitions, enabling coherent generation across extended command sequences. To support long-sequence evaluation, we introduce DeepCAD-240, an extended benchmark that increases the sequence length ranging from 40 to 240 while preserving sketch-extrusion semantics from the ABC dataset. Extensive experiments demonstrate that GeoFusion-CAD achieves superior performance on both short and long command ranges, maintaining high geometric fidelity and topological consistency where Transformer-based models degrade. Our approach sets new state-of-the-art scores for long-sequence parametric CAD generation, establishing a scalable foundation for next-generation CAD modeling systems. Code and datasets are available at GitHub.

Summary

  • The paper introduces a geometric state-space diffusion framework using hierarchical CAD representations and G-Mamba blocks, addressing transformer limitations.
  • It achieves high command and parameter accuracy (91.2% and 89.3%) with reduced memory and computational costs by leveraging geometry-conditioned state transitions.
  • This work significantly enhances scalable, topology-consistent generative modeling for parametric 3D design, laying the foundation for future CAD automation.

GeoFusion-CAD: Structure-Aware Diffusion with Geometric State Space for Parametric 3D Design

Motivation and Context

Parametric CAD is ubiquitous in mechanical and product design, yet generative modeling for complex, long-sequence CAD programs remains underdeveloped. Prior approaches predominantly leverage transformer-based architectures, which, while offering strong dependency modeling via self-attention, suffer from prohibitive quadratic resource scaling and diluted context for hierarchical topology. This inefficiency restricts practical scalability and undermines geometric and topological fidelity, especially in extended command scenarios. The paper "GeoFusion-CAD: Structure-Aware Diffusion with Geometric State Space for Parametric 3D Design" (2603.21978) introduces a geometric state-space diffusion framework that addresses these issues by explicitly encoding CAD hierarchy and leveraging linear-time G-Mamba blocks to fuse geometry and topology within an end-to-end generative process.

Hierarchical CAD Representation and Sequence Construction

GeoFusion-CAD represents CAD programs as hierarchical trees, capturing solids, sketches, faces, edges, and vertices as structured nodes. Each node individually encodes geometric primitives and topological relations, preserving strict procedural design history and multi-level semantic dependencies. Unlike earlier approaches that replicate entities (e.g., edges), this structure avoids connectivity duplication and maintains coherent relationships across design stages. The 2D sketch–extrusion paradigm is maintained, with each sketch defining closed loops of primitives (lines, arcs, circles) and corresponding extrusion parameters as orientation, translation, scale, extrusion distances, and Boolean operations. Figure 1

Figure 1: CAD construction pipeline with hierarchical tree representation; sequential Sketch and Extrusion operations form a solid, encoded by GeoFusion-CAD.

The sequence is tokenized, employing explicit end markers for hierarchical entities and uniform quantization for continuous parameters to facilitate diffusion modeling. The hierarchical encoding is serialized as depth-first command sequences, ensuring reversibility and integrity during training and inference.

GeoFusion-CAD Architecture and G-Mamba Diffusion Encoder

The core architectural innovation is the integration of a G-Mamba diffusion encoder that supplants quadratic self-attention with linear-time, geometry-conditioned state transitions. GeoFusion-CAD consists of embedding layers for diffusion timestep and geometry, the G-Mamba diffusion encoder, and a CAD decoder. Figure 2

Figure 2: Comparison of transformer-based architecture (separate command/argument streams) and GeoFusion-CAD’s unified hierarchical sequence approach via G-Mamba blocks.

Figure 3

Figure 3: Framework overview—embedding layers, G-Mamba diffusion encoder, CAD decoder; structured reverse diffusion for coherent generation.

G-Mamba blocks incorporate geometric inductive bias through geometry-conditioned state-space kernels, leveraging local geometric scale, hierarchical depth, and curvature descriptors, as well as hierarchical positional encoding (parent type, sibling index, topology role). These kernels are generated by lightweight MLPs, modulated by diffusion timestep, and used in selective state-space scan with stable geometric state mixing. Depthwise convolutions inject spatial continuity, and the diffusion process iteratively denoises latent geometric features, modeled as Markovian transitions with analytical mean/covariance updates. Figure 4

Figure 4: G-Mamba Block architecture—DWC module, GSM-SSD layer, and MLP for geometry-conditioned multi-scale state transitions.

The CAD decoder reconstructs command and parameter logits from denoised features, ensuring explicit mapping for hierarchical parent and child nodes.

Dataset Construction and Experimental Benchmark

To evaluate scalability and generalization, the authors introduce DeepCAD-240, an extended benchmark derived from the ABC dataset. DeepCAD-240 supports sequences of up to 240 commands, preserving semantic richness and hierarchical dependencies of original sketch–extrusion data, forming the longest and most structurally diverse parametric CAD dataset to date. Figure 5

Figure 5: Sequential decomposition into sketches and extrusions; explicit preservation of geometric and topological dependencies.

Figure 6

Figure 6: Distribution of command sequence lengths in DeepCAD-240, revealing substantial support for extended programs.

Quantitative and Qualitative Results

GeoFusion-CAD demonstrates superior accuracy and geometric fidelity across both short (<60) and long (40–240) sequence evaluation ranges, outstripping transformer-based (DeepCAD, SkexGen, HNC-CAD) methods. On DeepCAD-240, it achieves highest command (91.2%) and parameter (89.3%) accuracy, coverage (73.9), lowest MMD (1.12), and JSD (2.97), with substantial reductions in memory and computational cost (5198MiB, 34.6G FLOPs)—a marked improvement over baselines. Figure 7

Figure 7: Visual results—GeoFusion-CAD produces coherent solids with minimized artifacts; subtle failure cases in baselines marked.

Qualitative analysis shows that baseline methods yield surface distortions, missing connections, and inconsistent joins in complex structures, while GeoFusion-CAD reliably reconstructs watertight, curvature-consistent solids, preserving fine geometric features. Figure 8

Figure 8: Representative samples—GeoFusion-CAD achieves geometric completeness and watertightness; baselines exhibit artifacts and inconsistencies.

Figure 9

Figure 9: Robustness and generalization—GeoFusion-CAD generates diverse, structurally coherent, and geometrically precise industrial-style parts unconditionally.

Ablation and Architectural Analysis

Ablation studies confirm the criticality of hierarchical encoding and G-Mamba blocks. Removing hierarchical structure or substituting G-Mamba with MLP, transformer, or vanilla Mamba precipitates a consistent drop in command/parameter accuracy, coverage, and geometric metrics (notably MMD/JSD), underlining the necessity for explicit hierarchy and geometry-aware diffusion. The geometric conditioning in G-Mamba stabilizes long-sequence modeling and enhances propagation of geometry-aware features, outperforming both attention and convolutional mechanisms for procedural CAD.

Practical and Theoretical Implications

GeoFusion-CAD substantiates the utility of geometric state-space diffusion for scalable, topology-consistent generative CAD modeling. The architecture harmonizes computational efficiency, hierarchical structure, and procedural validity, enabling robust generation across long and complex programs. This approach lays the groundwork for general-purpose, foundation-level CAD modeling systems and could be extended to multi-component assemblies, richer parametric operations, and broader geometric modalities. The capacity for efficient, hierarchical generative modeling also has implications for interpretable design workflows, integration in industrial-scale design automation, and future AI-driven geometric reasoning.

Conclusion

GeoFusion-CAD advances generative CAD modeling by unifying hierarchical tree representation with geometric state-space diffusion, overcoming transformer bottlenecks and preserving long-range geometric and topological dependencies. The G-Mamba block ensures scalable, expressive modeling, delivering substantial gains in accuracy, fidelity, and efficiency. Empirical results validate its robustness and geometric consistency, positioning GeoFusion-CAD as a foundation for next-generation parametric CAD systems and scalable geometric AI.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Sign Up to Generate All Videos Subscribe on YouTube

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Sign Up to Generate

Explain it Like I'm 14

Plain‑language overview

This paper is about teaching computers to “write” the step‑by‑step instructions that designers use to build 3D objects in CAD (Computer‑Aided Design). Think of CAD like a cooking recipe for shapes: you sketch a 2D outline, then “extrude” it (pull it out) to make a 3D part, and repeat. The authors introduce a new AI method, called GeoFusion‑CAD, that can handle very long, detailed instruction lists without getting confused, so it can build more complex and accurate 3D models.

What questions did the researchers ask?

They set out to answer a few simple but important questions:

  • How can we make an AI that understands long, complicated CAD “recipes” without running out of memory or losing track of details?
  • Can the AI keep both the exact geometry (shapes and sizes) and the structure (how pieces connect) consistent from start to finish?
  • If we train on longer and harder examples, can the AI still perform well or even better?

How did they do it?

The team combined three big ideas and used helpful “structures” to guide the AI:

  • Hierarchical tree like a family tree
    • They represent a CAD model as a tree with levels: the whole solid at the top, then sketches and features (like extrusions), then edges, and finally points (vertices). This matches how designers actually think—big picture first, then details. It helps the AI keep track of what depends on what.
  • Diffusion like un‑blurring an image
    • A diffusion model learns by starting from a noisy version of the instructions and gradually “denoising” them back to a clean, correct sequence—like sharpening a blurry photo step by step. This makes training stable and helps the AI generate coherent instructions.
  • State‑space modeling like a conveyor belt with memory
    • Instead of using Transformers (which compare every step with every other step and get very slow as the list grows), they use a “state‑space” model that passes information forward efficiently. It keeps a running memory of what’s important, so it scales in almost a straight line with length (faster and less memory‑hungry).

They introduce a special block called G‑Mamba:

  • “G” for geometric: it pays attention to the shape’s local details (like curvature) and where a step sits in the tree (its place in the “family”).
  • This block helps the model focus on the right connections—local details when needed, and long‑range structure when necessary—without checking everything all at once.

A new, tougher dataset:

  • DeepCAD‑240 is an expanded collection of CAD “recipes” that are much longer (up to 240 steps). This lets them test whether models can handle complex, real‑world designs, not just short examples.

What did they find, and why is it important?

Their model performed better than popular Transformer‑based systems (like DeepCAD, SkexGen, and HNC‑CAD), especially on long, complex instruction lists.

Key takeaways:

  • More accurate instructions: It predicted both the types of commands (like “draw line,” “draw circle,” “extrude”) and their numbers (positions, angles, distances) more correctly.
  • Better shapes and cleaner connections: The generated 3D parts looked more like real models, with smoother surfaces, correct edges, and “watertight” solids (no cracks or gaps).
  • Handles long sequences without slowing down badly: Because it uses linear‑time modeling, it needs less memory and computation than transformer systems as instructions get longer.
  • New benchmark: DeepCAD‑240 shows that longer training and testing make the problem more realistic—and their method shines in this harder setting.

Why this matters:

  • Real CAD work often involves many steps that depend on each other. A model that stays accurate and efficient on long sequences is much more practical for real design tasks.

What’s the potential impact?

  • Smarter CAD assistants: Future design tools could suggest or auto‑complete complex, editable CAD steps, helping engineers and students work faster and make fewer mistakes.
  • More complex, reliable parts: Because the method keeps geometry and structure consistent, it’s better suited for real manufacturing needs.
  • Scalable foundation: The approach can be extended to even larger projects, like multi‑part assemblies, and to more types of operations—not just sketch and extrusion.
  • New standards for research: The DeepCAD‑240 dataset provides a tougher, more realistic challenge that can push the whole field forward.

In short, GeoFusion‑CAD shows a practical way to generate long, accurate, and well‑structured CAD “recipes,” which could lead to more capable and helpful 3D design tools.

View Paper Prompt  View All Prompts 

Knowledge Gaps

Unresolved Knowledge Gaps, Limitations, and Open Questions

The following list synthesizes what remains missing, uncertain, or unexplored in the paper and its supplementary materials, framed as concrete directions for future research:

  • Scope of operations: the method and dataset focus on sketch–extrusion only; revolve is explicitly excluded (“without Revolution”), and features common in industrial CAD (sweep, loft, fillet, chamfer, shell, pattern, constraints-based features) are not modeled or evaluated.
  • Sketch constraints: geometric/dimensional constraints (e.g., tangent, perpendicular, coincident, equal, horizontal/vertical) are not represented or enforced; it is unclear how to integrate a constraint solver or neural constraint satisfaction into the pipeline.
  • Cross-feature references: the hierarchical tree captures parent–child topology but does not model references across steps (e.g., selecting previously generated faces/edges as references, feature dependencies beyond direct hierarchy).
  • Assemblies: multi-component assemblies and inter-part constraints are out of scope (acknowledged as future work); there is no design for assembly references, mating, or hierarchical assembly trees.
  • Parameter precision: all continuous parameters are uniformly quantized to 8-bit IDs in [11, 266]; the impact on geometric accuracy, tolerance control, and editability in downstream CAD systems is not quantified; continuous or mixed discrete–continuous outputs remain unexplored.
  • Orientation representation: Euler angles are used for 3D orientation; discontinuity/singularity issues and alternatives (quaternions, 6D rotation reps, Lie groups) are not evaluated.
  • Topological validity guarantees: although qualitative results suggest “watertight” outputs, there are no formal validity metrics (e.g., manifoldness, watertightness, self-intersections, nonzero volume) or rates of kernel acceptance in real CAD kernels.
  • Executability in CAD kernels: no systematic evaluation of whether generated programs execute without errors across standard CAD kernels (e.g., OpenCascade, Parasolid), nor statistics on failure modes during execution.
  • Diffusion cost and latency: number of diffusion steps, wall-clock latency, and interactive responsiveness are not reported; trade-offs among steps, accuracy, and user-facing latency are unquantified.
  • Data coverage and imbalance: DeepCAD-240 has a long-tail distribution (only 0.21% sequences in 160–240 range); the effect of this imbalance on long-sequence generalization is not studied; strategies for rebalancing or curriculum learning are not explored.
  • Procedural history reconstruction noise: the conversion from ABC/CSG to sketch–extrusion via Onshape/FeatureScript may introduce noisy or ambiguous histories; reconstruction error rates and their impact on training are not measured.
  • Conditional generation: experiments are unconditional; conditioning on sketches, partial histories, target shapes/point clouds, text, or constraints (and controllability over outputs) is not addressed.
  • Editability and incremental design: support for editing existing programs (local updates, constraint propagation, partial re-generation) is not discussed; mechanisms for locality-preserving edits within diffusion are open.
  • Generalization beyond 240 steps: the upper bound of 240 commands is not stress-tested; behavior on longer or more complex programs remains unknown.
  • B-Rep integration: although the paper contrasts SE and B-Rep paradigms, the proposed method is not demonstrated on B-Rep data; unifying or translating between SE and B-Rep within the same framework is open.
  • Geometry-conditioned SSM design: the construction and computation of the conditioning tuple Δk = g(sk, dk, rk) (e.g., curvature descriptor quality, robustness for lines vs. arcs) are insufficiently specified; ablations isolating each component’s contribution are missing.
  • Tokenization and embeddings: representing non-coordinate tokens as 2D padded terms and one-hotting a 2d_t vocabulary may be inefficient; alternative tokenization (learned codebooks, mixed embeddings, continuous regression heads) is not investigated.
  • Decoder expressiveness: the CAD decoder is described as (several) linear layers; the limits of such a decoder for complex argument dependencies, constraint satisfaction, and error correction are not examined; structured or constrained decoding remains unexplored.
  • Training objectives: losses focus on DDPM noise prediction and cross-entropy for command/argument tokens; topology-aware losses, differentiable geometric/constraint penalties, or validity-driven objectives are not included or evaluated.
  • Evaluation metrics: beyond ACC, COV/MMD/JSD, there are no metrics for constraint satisfaction, dimensional fidelity (absolute/relative error), symmetry preservation, or user-perceived design intent; standardized validity and editability benchmarks are lacking.
  • Robustness and OOD: robustness to geometry noise, token corruption, domain shifts (industrial datasets, different units/kernels), and adversarial or extreme cases is not reported.
  • Comparative breadth: comparisons are limited to SE transformer-style baselines and vanilla Mamba; broader baselines (efficient Transformers, bidirectional decoders, graph diffusion, flow/consistency models, neuro-symbolic solvers) are not included.
  • Energy and compute efficiency: while per-sequence memory/FLOPs are reported, total training energy, carbon footprint, and sample-efficiency versus autoregressive baselines are not quantified.
  • Reproducibility and availability: the paper states code and data “will be released”; until available, full reproducibility (including FeatureScript conversion pipeline, filtering criteria, serialization) remains uncertain.
  • Safety and IP concerns: potential leakage of proprietary geometric patterns or regeneration of copyrighted designs from ABC-derived data are not discussed; mechanisms for compliance or filtering are unspecified.
View Paper Prompt  View All Prompts 

Practical Applications

Immediate Applications

The following applications can be built with the paper’s current capabilities (diffusion-based, hierarchical, topology-aware parametric CAD generation; linear-time G-Mamba blocks; DeepCAD-240 benchmark), with integration effort focused on data interfaces and UI/UX rather than core algorithms.

  • Parametric sketch–extrusion autocompletion and repair — Sectors: software, manufacturing, education — What: In-CAD assistants that suggest the next command/parameter, fill missing tokens, or correct topology-inconsistent steps during sketch and extrusion workflows. — Tools/products/workflows: Plugins for Fusion 360/SolidWorks/Onshape; “parametric linter” that flags inconsistent loops/faces and suggests fixes; command-argument autocompletion panes. — Assumptions/dependencies: Access to CAD APIs/FeatureScript-like interfaces; mapping from the paper’s tokenization to each CAD system; revolve/sweep support may require extensions beyond sketch–extrusion; model retraining on proprietary design corpora to reduce domain shift.
  • Topology-consistent generative ideation for designers — Sectors: industrial/product design, daily life (maker/3D-printing communities) — What: Generate multiple coherent CAD variants with long, editable histories (as sequences) for rapid concept exploration, reducing post-fix effort from broken constraints or non-watertight solids. — Tools/products/workflows: “Generate N variants” panel with seed control; variant diff viewer showing command-level changes; export to editable feature trees. — Assumptions/dependencies: Unconditional model benefits from optional conditioning (text, constraints) for targeted outputs; printability checks and feature constraints need external validators.
  • Cost- and memory-efficient cloud CAD generative services — Sectors: software/SaaS — What: Deploy G-Mamba-based inference to cut GPU memory and FLOPs for long sequences versus Transformer baselines, lowering serving cost and latency. — Tools/products/workflows: Managed inference endpoints; serverless batch generators for catalog creation; SDKs exposing “generate_history(length≤240)” APIs. — Assumptions/dependencies: Production MLOps; guardrails and geometric validators; horizontal scaling for enterprise workloads; GPU availability.
  • CAD QA and linting for procedural histories — Sectors: manufacturing, regulatory/QA — What: Batch validators that scan long feature histories for topological discontinuities, invalid loops, or inconsistent parameters, leveraging the model’s topology-aware structure. — Tools/products/workflows: CI-like “design check” step in PLM; report with COV/MMD/JSD-like proxies or project-specific pass/fail rules; autocorrect suggestions. — Assumptions/dependencies: Organization-specific rulesets; integration with PLM/PDM; acceptance workflow for suggested fixes.
  • CSG-to-sketch–extrusion conversion utilities — Sectors: software, academia — What: Use the paper’s conversion pipeline to turn Boolean trees (CSG) or ABC-like assets into parametric sketch–extrusion sequences for downstream editing and learning. — Tools/products/workflows: Dataset converters; legacy part migration tools; “import CSG → parametric history” wizards. — Assumptions/dependencies: Availability of CSG sources; robust loop detection and tokenization; some complex primitives may require approximations.
  • CAD data augmentation for training and benchmarking — Sectors: academia, software — What: Leverage DeepCAD-240 and GeoFusion-CAD to synthesize diverse, long sequences for pretraining or stress-testing new sequence models and CAD validators. — Tools/products/workflows: Benchmark suite with short/long-range splits; reproducible training scripts; ablation baselines (Transformer vs Mamba vs G-Mamba). — Assumptions/dependencies: License-compatible redistribution; consistent token schema; compute for training at target scales.
  • Step-by-step teaching assistants for parametric modeling — Sectors: education — What: Interactive tutorials that generate and explain each command in a long modeling sequence, highlight dependencies (faces/loops/vertices), and replay edits. — Tools/products/workflows: “Explain this feature” overlays; automatic lesson generation from generated histories; classroom labs using DeepCAD-240. — Assumptions/dependencies: Pedagogical UX; alignment of tokens to student-facing CAD concepts; curriculum integration.
  • Design intent search and retrieval — Sectors: software, manufacturing — What: Index and search parts by procedural histories (not just geometry), enabling retrieval like “sketch→extrude→cut pattern with depth in [x,y]”. — Tools/products/workflows: Feature-history embeddings; semantic retrieval of CAD sequences; reuse libraries. — Assumptions/dependencies: Storage of feature histories; privacy/IP constraints; harmonization across different CAD kernels’ feature taxonomies.

Long-Term Applications

These applications require further research or engineering, such as multi-part assemblies, conditional generation, constraint solving, cross-representation learning (B-Rep + SE), safety validation, or large-scale deployment.

  • Full AI CAD copilot for complex assemblies — Sectors: software, robotics, manufacturing — What: Plan and generate long, multi-component parametric histories, including mates/constraints, beyond single-part sequences. — Tools/products/workflows: Assembly-level planners; cross-part constraint solvers; interactive co-design agents. — Assumptions/dependencies: Extension from single-part SE to assemblies; robust constraint inference; scaling beyond 240 steps; traceable edits for safety/compliance.
  • Constraint- and simulation-conditioned generative design — Sectors: aerospace, energy, automotive, healthcare — What: Condition sequence generation on FEA/CFD/manufacturability targets to co-optimize geometry and performance with editable histories. — Tools/products/workflows: Closed-loop pipelines (generate → simulate → revise); multi-objective optimizers; param sensitivity analytics. — Assumptions/dependencies: Differentiable or surrogate simulators; constraint-aware decoding; domain-specific validation (e.g., FDA, ISO).
  • Reverse engineering from scans/meshes/B-Rep to parametric programs — Sectors: manufacturing, healthcare (orthotics/prosthetics), robotics — What: Infer editable sketch–extrusion histories from measured geometry to enable lightweight edits instead of mesh sculpting. — Tools/products/workflows: Perception-to-program pipelines; B-Rep/mesh parsers; alignment/segmentation + program synthesis. — Assumptions/dependencies: Strong conditioning from perception; robust primitive/loop recovery; handling noise/occlusion; IP considerations.
  • Mass customization platforms with safe, editable histories — Sectors: e-commerce, healthcare (patient-specific devices), consumer products — What: Web configurators producing parametric sequences for personalized products that remain manufacturable and auditable. — Tools/products/workflows: Constraint-aware UIs; printability/CNCability gates; order-to-CAD-to-CAM automation. — Assumptions/dependencies: Regulatory gating (e.g., medical devices); supply chain integration; robust guardrails to prevent invalid geometries.
  • On-device or AR-assisted modeling — Sectors: mobile/software, robotics — What: Use the efficiency of state-space models to run light-weight CAD generation on edge devices for guided modeling or scene-based part creation. — Tools/products/workflows: AR overlays; spatial anchoring; quick fixture/part wizards in the field. — Assumptions/dependencies: Tight memory/latency budgets; robust pose/scale estimation; simplified UX for small screens.
  • Automated fixture, jig, and tooling generation — Sectors: manufacturing, robotics — What: Generate parametric fixtures from part geometry and process constraints, with history suitable for downstream tweaks. — Tools/products/workflows: Process-aware conditionings (clamping, tolerances); cell layout integration; quick-turn tooling libraries. — Assumptions/dependencies: Reliable perception-to-constraints mapping; safety and tolerance validation; shop-floor feedback loops.
  • Interoperability standards for AI-generated procedural CAD — Sectors: policy/standards, software — What: Open token schemas and interchange formats for AI-generated feature histories across CAD vendors, enabling traceability and portability. — Tools/products/workflows: Schema specs; conformance test suites; reference converters. — Assumptions/dependencies: Vendor participation; mapping to diverse CAD kernels; IP/licensing alignment.
  • Governance, auditability, and IP provenance of AI-CAD — Sectors: policy, regulated industries — What: Use procedural histories as auditable artifacts, enabling design controls, traceability, and clear ownership of AI-assisted steps. — Tools/products/workflows: Audit logs tying prompts/seeds to histories; risk classification of AI-generated features; approval workflows. — Assumptions/dependencies: Legal frameworks recognizing AI-generated design artifacts; secure storage; standardized metadata.
  • Unified modeling across B-Rep and sketch–extrusion — Sectors: software, research — What: Extend geometry-aware state spaces to jointly reason over B-Rep surfaces and procedural histories, improving fidelity and editability. — Tools/products/workflows: Dual-representation encoders/decoders; cross-supervision datasets; hybrid validators. — Assumptions/dependencies: New datasets with aligned B-Rep and SE histories; training stability for multi-representation diffusion.
  • Accredited AI-CAD curricula and skills certification — Sectors: education, workforce development — What: Formal training on AI-assisted parametric design, sequence literacy, and safety-aware workflows. — Tools/products/workflows: Competency frameworks; lab kits using DeepCAD-240; certification exams. — Assumptions/dependencies: Industry-academia partnerships; evolving best practices; accessible training compute.

Notes on general feasibility dependencies

  • Representation scope: The current work focuses on sketch–extrusion (no revolution/sweep in the released spec). Broader feature coverage will improve applicability.
  • Conditioning: Unconditional generation may need conditioning (text, constraints, reference geometry) for targeted design; requires model extensions.
  • Validation: Manufacturing feasibility, standards compliance, and safety require external validators/simulations integrated into the workflow.
  • Integration: Practical deployment hinges on CAD API access, token/schema alignment, PLM/PDM integration, and data governance/IP policies.
  • Scaling: Sequences beyond 240 steps, multi-part assemblies, and domain-specific constraints will need further research in model capacity and training data.
View Paper Prompt  View All Prompts 

Glossary

  • 8-bit uniform quantization: Mapping continuous values into 256 discrete bins for stable, compact tokenization. "We apply 8-bit uniform quantization to all continuous parameters"
  • ABC dataset: A large repository of CAD models used to derive sketch–extrusion semantics and benchmarks. "preserving sketch–extrusion semantics from the ABC dataset."
  • Autoregressively: Decoding sequences by predicting each token conditioned on the previous ones. "decoded autoregressively."
  • Boundary Representation (B-Rep): A solid modeling paradigm representing objects via their boundary surfaces with full topological consistency. "Boundary Representation (B-Rep)."
  • Boolean composition: Constructing solids by applying Boolean set operations over primitive shapes. "Boolean composition order determines the extrusion sequence"
  • Boolean operation type: A categorical indicator specifying whether an extrusion creates, cuts, joins, or intersects material. "Boolean Operation Type"
  • B-spline surfaces: Smooth piecewise polynomial surfaces commonly used in CAD for flexible shape modeling. "B-spline surfaces"
  • Constructive Solid Geometry (CSG): A representation that combines primitive solids using Boolean operations to form complex models. "Constructive Solid Geometry (CSG) methods"
  • Coverage (COV): A generative evaluation metric measuring how well generated samples cover the reference distribution. "COV (73.9)"
  • Denoising diffusion probabilistic model (DDPM): A diffusion-based generative model that learns to reverse a noise-adding process. "A denoising diffusion probabilistic model (DDPM)~\cite{dhariwal2021diffusion}"
  • Depth-first (serialization): Converting a hierarchy into a linear sequence by traversing nodes in depth-first order. "depth-first command sequence"
  • Depthwise convolution (DWC): A convolution that operates per channel, reducing parameters while preserving local structure. "depthwise convolution (DWC) block."
  • Design intent: The intended parametric and functional goals embedded in a CAD model’s constraints and structure. "design intent"
  • Euler angles: A triplet of angles parameterizing 3D orientation. "Euler angles (θ,ϕ,γ)(\theta, \phi, \gamma)"
  • FLOPs: A computational complexity measure counting floating-point operations. "FLOPs(256)"
  • G-Mamba block: A geometry-conditioned state-space module adapted from Mamba to model long-range CAD dependencies efficiently. "a lightweight G-Mamba block"
  • Gated Hadamard fusion: An element-wise multiplicative gating mechanism used to fuse latent representations. "gated Hadamard fusion"
  • Geometric inductive biases: Prior structural assumptions about geometry built into a model to improve learning and generalization. "integrates geometric inductive biases"
  • Geometric state-space modeling: Using state-space models tailored with geometric cues to capture long-range dependencies in CAD sequences. "geometric state-space modeling"
  • Hierarchical inductive bias: A modeling prior that reflects hierarchical structure, aiding in capturing multi-level dependencies. "hierarchical inductive bias"
  • Hierarchical positional embedding: Positional encoding that incorporates hierarchical relationships (e.g., parent type, sibling index). "hierarchical positional embedding"
  • Hierarchical tree representation: A structured CAD encoding where nodes represent entities (solids, sketches, faces, edges, vertices) and their relations. "a hierarchical tree representation"
  • Jensen–Shannon Divergence (JSD): A symmetric divergence measure between probability distributions used to evaluate generative models. "JSD (2.97)"
  • Latent space: A learned continuous feature space where complex structures are represented compactly for modeling or generation. "latent space"
  • Markov chain: A stochastic process where the next state depends only on the current state, used to formalize diffusion steps. "We model this process as a Markov chain"
  • Maximum Mean Discrepancy (MMD): A statistical distance between distributions used to assess generative fidelity. "MMD (1.12)"
  • Mamba: A selective state-space sequence model enabling linear-time long-range dependency modeling. "Mamba"
  • MiB (Mebibyte): A binary unit of memory measurement equal to 220 bytes. "5198MiB"
  • NURBS: Non-Uniform Rational B-Splines, a standard for exact curve and surface representation in CAD. "NURBS"
  • One-hot encoding: A vector representation with a single one and zeros elsewhere, used for discrete token embedding. "one-hot encoding"
  • Pointer networks: Sequence models that output indices pointing to input elements, useful for structured geometry decoding. "pointer networks"
  • Positional encoding: A method to inject token position information into sequence models. "positional encoding"
  • Quadratic time and memory complexity: The O(L2 d) scaling of attention that limits transformer efficiency on long sequences. "quadratic time and memory complexity O(L2d)\mathcal{O}(L^2 d)"
  • Reverse diffusion process: The learned denoising trajectory that maps noisy states back to clean samples. "The reverse diffusion process is modeled as:"
  • RMSNorm: Root Mean Square normalization, a variant of normalization stabilizing training by scaling features by their RMS. "RMSnorm layers"
  • Selective state-space (SSD) layer: A state-space module that selectively mixes states for efficient sequence modeling. "selective state-space (SSD) layer"
  • Self-attention: A mechanism where each token attends to all others to aggregate context, common in transformers. "self-attention"
  • Sketch--Extrusion (SE): A procedural CAD paradigm that builds 3D solids by extruding 2D sketches. "Sketch--Extrusion programs"
  • State-space transition matrices: The matrices defining the dynamics of state updates in state-space models. "state-space transition matrices"
  • Tokenization interval: The discrete range into which continuous parameters are quantized for sequence modeling. "tokenization interval"
  • Topological consistency: Maintaining valid and continuous connectivity in a model’s geometry. "topological consistency"
  • Topological dependencies: Dependency relations arising from how geometric entities connect within a CAD model. "topological dependencies"
  • Transformer encoder-decoder architectures: Sequence-to-sequence models using attention for encoding and decoding. "transformer encoder-decoder architectures"
  • Uniform attention: Treating all tokens equally in attention, which can dilute critical local relations. "Uniform attention thus dilutes these local relations"
  • Watertight solids: 3D models with closed, gap-free surfaces suitable for manufacturing or simulation. "watertight solids"
View Paper Prompt  View All Prompts 

Open Problems

We found no open problems mentioned in this paper.

Collections

Sign up for free to add this paper to one or more collections.

Sign Up

Tweets

Sign up for free to view the 2 tweets with 179 likes about this paper.

Sign Up for Free