🤖 machine learning

AutoRegressive Generation with B-rep Holistic Token Sequence Representation

This paper introduces BrepARG, the first framework to encode Boundary Representation (B-rep) data into a holistic token sequence comprising geometric and topological tokens, enabling state-of-the-art autoregressive generation via a transformer-based decoder-only architecture.

Original authors: Jiahao Li, Yunpeng Bai, Yongkang Dai, Hao Guo, Hongping Gan, Yilei Shi

Published 2026-03-31

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jiahao Li, Yunpeng Bai, Yongkang Dai, Hao Guo, Hongping Gan, Yilei Shi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot how to build a complex 3D object, like a chair or a car engine, using a computer. In the world of engineering, these objects are described using something called a B-rep (Boundary Representation).

Think of a B-rep as the "DNA" of a 3D shape. It doesn't just say "this is a cube." It says:

Geometry: "This face is curved like a sphere, and that edge is a straight line."
Topology: "This face is glued to that face, and they meet at this specific corner."

The Problem: The "Two-Headed" Monster

For a long time, AI models trying to design these shapes had a hard time because the "DNA" was messy.

The Old Way: Previous methods treated the shape (geometry) and the connections (topology) as two separate problems. It was like asking a chef to first cook the ingredients (shape) and then, in a completely different kitchen, figure out how to plate them (topology).
The Result: The AI got confused. It might make a beautiful curved surface but forget to connect it to the rest of the object, leaving a floating piece of geometry that doesn't belong to anything. It was fragmented and inefficient.

The Solution: BrepARG (The "Storyteller" Approach)

The authors of this paper, BrepARG, decided to change the game. Instead of splitting the shape and the connections, they decided to turn the entire 3D object into a single, continuous story.

Here is how they did it, using a simple analogy:

1. Turning Shapes into Words (Tokenization)

Imagine you want to describe a Lego castle to a friend over the phone. You can't send a picture; you have to use words.

Geometry Tokens: The authors took the curves and lines of the object and turned them into "words" (tokens). They used a special dictionary (a codebook) where every specific curve or line has a unique word.
Position Tokens: They also added "words" for where things are in 3D space (like "top-left" or "bottom-right").
Topology Tokens: This is the magic part. They added "words" that act like name tags. Every face gets a name tag (e.g., "Face A"). When they describe an edge, they say, "This edge connects Face A and Face B."

Now, instead of a messy 3D file, they have a list of words: "Face A (curved), Face B (flat), Edge (connects A & B)..."

2. Ordering the Story (Sequence Construction)

If you just list random words, the story makes no sense. You need an order.

The Old Way: Randomly listing parts.
The BrepARG Way: They created a smart "reading order."
- They start with the most important "hub" faces (the ones with the most connections) and work their way out, like a spider spinning a web.
- They make sure that when the AI reads about an edge, it has just read about the faces that edge connects.
- This creates a causal chain: The AI learns that "Face A" must exist before it can learn about the "Edge connecting to Face A."

3. The Magic Writer (Autoregressive Model)

Now they use a Transformer (the same type of AI that powers chatbots like me) to learn this "language of shapes."

How it works: The AI reads the story word by word. It sees "Face A," then "Edge," then "Face B." It learns the pattern: "Oh, whenever I see a curved Face A, there's usually a straight Edge connecting it to a flat Face B."
Generation: To create a new object, the AI starts with a blank page. It guesses the first word ("Let's start with a big square face"), then guesses the next word based on the first, and so on. It builds the object one word at a time, ensuring that every new piece fits perfectly with the previous ones.

Why This is a Big Deal

No More "Floating Parts": Because the AI learns the connections (topology) and the shapes (geometry) at the same time, it never forgets to glue the pieces together.
Speed and Efficiency: It's like switching from building a house brick-by-brick with a manual, to having a smart assistant that knows the blueprint and builds the whole wall in one go. The paper shows their model trains much faster and creates higher-quality designs than previous methods.
Versatility: It can be taught to build specific types of objects (like "only chairs" or "only lamps") just by giving it a "topic word" at the start of the story.

The Bottom Line

BrepARG is like teaching a robot to speak the native language of 3D design. Instead of giving it a confusing list of instructions, they taught it to tell a coherent story where the shape and the structure are woven together. The result? A robot that can dream up new, complex, and valid 3D objects on its own, just by predicting the next word in the story.

1. Problem Statement

Boundary Representation (B-rep) is the standard paradigm for representing solid models in Computer-Aided Design (CAD). However, generating B-rep models using deep learning is challenging due to their inherent complexity:

Heterogeneity: B-reps combine continuous, parametric geometric primitives (faces, edges, vertices) with discrete topological dependencies.
Fragmentation in Existing Methods: Prior approaches typically decouple geometry and topology, using multi-stage pipelines (e.g., generating geometry first, then topology) or graph-based representations.
- Graph-based methods prevent the use of efficient, sequence-based Transformer architectures.
- Multi-stage methods fail to capture the full interdependence between geometry and topology, leading to fragmented representations and increased model complexity.
The Gap: There is a lack of a unified representation that encodes both geometry and topology into a single sequence, enabling the application of powerful autoregressive generative models (like Transformers) to B-rep generation.

2. Methodology: BrepARG

The authors propose BrepARG, the first framework to encode B-rep geometry and topology into a holistic token sequence, enabling end-to-end autoregressive generation. The framework consists of three main stages:

A. Holistic Tokenization

The B-rep is discretized into three distinct types of tokens:

Geometry Tokens:
- Faces and edges are sampled in their UV parameter domains (32×32 points for faces, 32 points for edges).
- These features are compressed using a unified VQ-VAE (Vector Quantized Variational Autoencoder) based on a 2D U-Net.
- The latent features are mapped to a shared codebook via nearest-neighbor search, resulting in 4 discrete indices per primitive (face or edge).
Position Tokens:
- To represent the 3D location (bounding box) of each primitive, the authors avoid VQ-VAE (which struggles with high-dimensional continuous boxes) and instead use a Uniform Scalar Quantization algorithm.
- Each of the 6 coordinates of the bounding box is normalized and mapped to a discrete index on a uniform grid ( $L=2048$ levels), producing 6 position tokens per primitive.
Topology Tokens (Face Index):
- Topology is encoded via Face Index Tokens.
- Each face is assigned a unique index.
- Each edge is associated with the indices of the two faces it connects, explicitly encoding the face-edge adjacency.

B. Sequence Construction

The tokens are assembled into a hierarchical sequence to preserve structural relationships and causal ordering:

Block Construction:
- Face Block: [6 Position Tokens] + [4 Geometry Tokens] + [1 Face Index Token]
- Edge Block: [2 Face Index Tokens] + [6 Position Tokens] + [4 Geometry Tokens]
Topology-Aware Sequentialization:
- Face Ordering: Uses a Depth-First Search (DFS) strategy starting from the highest-degree face, prioritizing lower-degree neighbors. This keeps topologically adjacent faces close in the sequence.
- Edge Ordering: Uses the MAX-IDX-A strategy, sorting edges by the maximum index of their adjacent faces. This ensures edges appear near their associated faces, reducing long-range dependencies.
- Re-indexing: Face indices are randomly re-indexed (modulo $N_{max}$ ) to improve model generalization.
Final Assembly: The sequence is constructed as: [START] + [Face Blocks] + [SEP] + [Edge Blocks] + [END].

C. Generation Framework

Model Architecture: A decoder-only Transformer with causal masking is used for autoregressive next-token prediction.
Training: The model learns the joint distribution of the holistic token sequence.
Detokenization (Post-processing):
- Generated tokens are decoded back to UV features (via VQ-VAE decoder) and 3D coordinates (via inverse scalar quantization).
- A novel greedy clustering algorithm (using Union-Find) infers vertex locations by merging edge endpoints based on geometric proximity and loop topology.
- The final geometry and topology are stitched into a valid B-rep solid using OpenCascade.

3. Key Contributions

Holistic Token Sequence Representation: A novel method to encode heterogeneous geometry and discrete topology into a single, unified token sequence, solving the fragmentation issue of previous approaches.
End-to-End Autoregressive Framework: The first B-rep generation system that utilizes a Transformer to co-generate geometric shapes and topological connections in a single stream, eliminating multi-stage pipelines.
State-of-the-Art Performance: The method achieves superior results in generation quality, validity, and efficiency compared to existing diffusion and graph-based models.

4. Experimental Results

Experiments were conducted on the DeepCAD, ABC, and Furniture datasets.

Performance Metrics:
- Validity: BrepARG achieved 87.6% validity on DeepCAD, significantly outperforming baselines like DTGBrepGen (79.8%) and BrepGen (68.2%).
- Distribution Metrics: It achieved the best Coverage (COV: 75.45%), lowest Minimum Matching Distance (MMD: 0.89), and lowest Jensen-Shannon Divergence (JSD: 1.02).
- Novelty & Uniqueness: Near 100% novelty and uniqueness, indicating the model generates diverse, non-duplicate designs.
Efficiency:
- Training: Trained in ~1.2 days on 4 NVIDIA H20 GPUs (vs. 7.5 days for BrepGen).
- Inference: Generates a B-rep in ~1.5 seconds on a single RTX 4090 (vs. 8.4s for BrepGen).
Ablation Studies:
- Confirmed that the DFS face ordering and MAX-IDX-A edge ordering strategies are critical for performance.
- Demonstrated that uniform scalar quantization for positions is more precise and stable than VQ-VAE for bounding boxes.

5. Significance

Paradigm Shift: BrepARG demonstrates that B-rep generation can be effectively treated as a sequence modeling task, similar to natural language processing, unlocking the power of Transformer architectures for industrial CAD.
Efficiency & Scalability: By removing complex multi-stage pipelines and graph convolutions, the approach is significantly faster to train and infer, making it more practical for real-world CAD applications.
Generalization: The holistic approach allows the model to learn the complex coupling between geometry and topology simultaneously, resulting in higher validity rates and more coherent 3D structures.
Open Source: The authors have released the source code, fostering further research in generative CAD.

In conclusion, BrepARG represents a major advancement in generative CAD, successfully bridging the gap between continuous geometric data and discrete topological constraints through a unified token-based autoregressive framework.