💻 computer science

CADReasoner: Iterative Program Editing for CAD Reverse Engineering

This paper introduces CADReasoner, an iterative program editing model that leverages geometric discrepancies between input shapes and predicted meshes, fused with multi-view renders and point clouds, to achieve state-of-the-art performance in CAD reverse engineering across multiple benchmarks.

Original authors: Soslan Kabisov, Vsevolod Kirichuk, Andrey Volkov, Gennadii Savrasov, Marina Barannikov, Anton Konushin, Andrey Kuznetsov, Dmitrii Zhemchuzhnikov

Published 2026-04-01

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Soslan Kabisov, Vsevolod Kirichuk, Andrey Volkov, Gennadii Savrasov, Marina Barannikov, Anton Konushin, Andrey Kuznetsov, Dmitrii Zhemchuzhnikov

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 have a broken, dusty, and slightly misshapen toy car that you found in an attic. Your goal is to build a perfect, brand-new blueprint (a CAD model) for a factory to recreate it exactly.

This is the challenge of CAD Reverse Engineering: turning messy, real-world 3D scans into clean, precise computer designs.

The paper introduces a new AI system called CADReasoner. Here is how it works, explained through simple analogies:

1. The Problem: The "One-Shot" Mistake

Most previous AI systems tried to look at the broken toy car and guess the blueprint in one single attempt.

The Analogy: Imagine a student taking a math test. They look at the problem, write down an answer, and hand it in immediately. If they made a small mistake in the first step, the whole answer is wrong. They don't get to check their work or fix it.
The Result: These AIs often produce blueprints that are "close" but miss tiny details or have weird, impossible shapes because they can't correct their own errors.

2. The Solution: The "Iterative Editor"

CADReasoner works more like a human engineer or a sketch artist.

The Analogy: Imagine an artist drawing a portrait.
1. They sketch a rough outline.
2. They step back, look at the real face, and say, "Hmm, the nose is too long."
3. They erase and redraw the nose.
4. They look again, say, "The ear is too low," and fix it.
5. They repeat this loop until the drawing is perfect.

CADReasoner does exactly this, but with code. Instead of guessing the whole blueprint at once, it writes a little bit of code, builds a 3D model, compares it to the original scan, finds the differences, and then edits the code to fix those specific differences. It does this over and over again (iteratively) until the model is perfect.

3. The "Eyes": Seeing the Differences

How does the AI know what to fix? It uses two special "eyes" to compare its current drawing with the real object:

The Overlay Glasses (Multi-view Images): Imagine taking a photo of your drawing and a photo of the real object, then stacking them on top of each other. Where they don't match, the colors shift (like a red/green ghosting effect). This shows the AI exactly where the shapes are misaligned.
The Ruler (Point Clouds): Imagine a cloud of tiny dots representing the surface of the object. The AI measures the exact distance between the dots on its drawing and the dots on the real object. This gives it a precise "ruler" measurement of how far off it is.

By combining these two views, the AI gets a complete picture of what needs fixing.

4. The "Training Gym": Simulating Real Messiness

Real-world scans are messy. They have dust, missing pieces, and blurry edges. Most AI training happens on "perfect" digital models, which is like practicing for a race on a smooth track and then trying to run in a muddy field.

The Innovation: The authors created a "Scan-Simulation" process. They took perfect digital models and intentionally "ruined" them with digital noise, missing patches, and blurriness to mimic a real 3D scanner.
The Result: CADReasoner trained in this "muddy field" environment. So, when it faces a real, messy scan, it's not confused. It knows how to handle missing data and noise because it practiced on it.

5. The Outcome: State-of-the-Art

The paper shows that CADReasoner is the current champion in this field.

Accuracy: It produces blueprints that are much closer to the real object than previous methods.
Reliability: It rarely produces "broken" blueprints that a factory couldn't build (a problem called "Invalid Rate").
Resilience: Even when the input scan is terrible (missing parts, noisy), CADReasoner can still figure out the correct shape by iterating and correcting itself.

Summary

Think of CADReasoner not as a machine that guesses a blueprint, but as a perfectionist editor. It writes a draft, checks it against the real object using special visual tools, finds the errors, rewrites the code, and repeats the process until the design is flawless. It learns by doing, correcting its own mistakes just like a human expert would.

1. Problem Statement

The paper addresses the challenge of CAD Reverse Engineering: recovering precise, parametric Computer-Aided Design (CAD) models from raw 3D scan data (e.g., point clouds or meshes from LiDAR/RGB-D sensors).

The Gap: Raw scan data is typically noisy, incomplete (missing patches), and contains artifacts, whereas CAD models are clean, parametric, and topologically exact.
Limitations of Existing AI: Current AI approaches for CAD reconstruction are mostly single-pass (one-shot prediction). They lack the ability to iteratively refine errors, leading to models that deviate from true geometry or miss fine details.
Limitations of Agent-Based Methods: While some recent methods use frozen Vision-Language Models (VLMs) to mimic human iterative loops, they suffer from weak 3D grounding and do not learn from their own geometric errors during training.
Realism Deficit: Most public datasets use synthetic inputs (rendered views or point clouds sampled from ideal CAD models) rather than simulating real-world scanning defects (noise, occlusions, mis-registration).

2. Methodology: CADReasoner

The authors propose CADReasoner, a framework that treats CAD reconstruction as a closed-loop program editing task. Instead of a single prediction, the model iteratively refines a runnable Python script (using the CadQuery library) based on geometric discrepancies.

Core Architecture

Input Modalities: The model fuses two complementary modalities at each iteration $t$ $t$ :
1. Multi-view Overlays: 8 canonical views (6 orthographic + 2 isometric) where the target mesh and the predicted mesh are overlaid. Discrepancies are encoded via color (Green = Target, Red = Prediction, Yellow = Overlap).
2. Point Clouds with Offsets: Point clouds sampled from both the target and the predicted mesh. Crucially, each point is augmented with a nearest-surface offset vector ( $\Delta$ ), indicating the direction and magnitude to move the prediction to match the target.
Model Backbone: Based on Qwen2-VL 2B (a Vision-Language Model).
Process Flow:
1. Input: Target evidence (images + point clouds) + Previous Program ( $C_{t-1}$ ).
2. Prediction: The model autoregressively generates an updated CadQuery script ( $C_t$ ).
3. Execution: The script is executed to render a new mesh ( $S_t$ ).
4. Feedback: The new mesh is converted back into the input modalities (images + point clouds) for the next iteration.
5. Selection: The system tracks the "best-so-far" program based on geometric discrepancy metrics.

Training Strategy: Curriculum Learning with Scan Simulation

To bridge the gap between synthetic data and real-world scans, the authors introduce a Scan-Simulation Protocol and a specific training curriculum:

Scan Simulation: A virtual pipeline that simulates real scanning artifacts (incomplete coverage, smoothed edges, missing holes, noise) on clean CAD models. This is applied during both training and evaluation.
Curriculum Learning (SFT):
- Stage A (Seed): Train on clean data to generate valid initial programs ( $t=1$ ).
- Stage B (Refine): Train on a mixture of $t=1$ (generation) and $t=2$ (refinement) examples. The model learns to correct its own imperfect predictions.
- Stage C (Horizon Extension): Extend training to $t=3$ , ensuring the model learns to handle error distributions generated by its own previous steps (on-policy learning).
Key Innovation: Unlike methods using Reinforcement Learning (RL) with scalar rewards, CADReasoner uses Supervised Fine-Tuning (SFT) where the supervision signal is the geometric discrepancy evidence itself. This aligns the model's learning process with how human engineers inspect and revise designs.

Inference

Greedy Decoding: Deterministic step-by-step refinement.
Stochastic Beam Search: Generates multiple candidate edits at each step, ranks them by geometric discrepancy (Chamfer Distance), and retains the top candidates. This explores diverse repair trajectories.

3. Key Contributions

Iterative Self-Correction Framework: Introduced CADReasoner, the first model to perform iterative inference and self-correction for CAD reconstruction by directly rewriting executable code based on geometric feedback, rather than relying on frozen backbones or scalar RL rewards.
Scan-Simulation Regime: Developed a realistic scan-simulation pipeline that models physical scanning defects. Applying this during training and evaluation significantly improves robustness in real-world scenarios.
Multi-Modal Fusion: Demonstrated that fusing multi-view image overlays (global topology/silhouette) with point cloud offsets (local metric distance) provides complementary cues that drive effective program editing.
State-of-the-Art Performance: Achieved superior results across multiple benchmarks without requiring RL fine-tuning, proving that SFT with geometric discrepancy evidence is highly effective.

4. Experimental Results

The model was evaluated on three benchmarks: DeepCAD, Fusion360, and MCB (Machine Component Benchmark).

Clean Surfaces (Ideal Input):
- CADReasoner outperformed existing methods (e.g., cadrille, CAD-Recode) in Chamfer Distance (CD), Intersection over Union (IoU), and Invalid Rate (IR).
- Iterative refinement ( $t=5$ ) significantly improved accuracy over the initial guess ( $t=1$ ), recovering small features and correcting topology.
- Cross-modal fusion (Images + Point Clouds) consistently reduced the Invalid Rate compared to single-modality inputs.
Scan-Simulation (Realistic Input):
- Existing methods degraded significantly when faced with scan artifacts (noise, missing parts).
- CADReasoner, trained with scan simulation, maintained high performance, achieving near-clean results on scan data.
- Robustness: On the MCB dataset, the Point Cloud branch achieved the lowest CD (0.49) with 0% Invalid Rate, outperforming RL-finetuned baselines.
Generalization:
- Training on simulated scans improved transfer to clean data, and vice versa, suggesting the model learns robust geometric reasoning rather than overfitting to specific data distributions.

5. Significance

Paradigm Shift: Moves CAD reconstruction from "single-shot generation" to "iterative reasoning," mimicking the human engineering workflow of inspection and correction.
Practical Applicability: By addressing the "realism gap" via scan simulation, the method is directly applicable to real-world industrial reverse engineering tasks where input data is imperfect.
Efficiency: Achieves state-of-the-art results using Supervised Fine-Tuning (SFT) alone, avoiding the computational cost and instability often associated with Reinforcement Learning (RL) fine-tuning.
Open Source: The authors released the code and model, facilitating further research in 3D geometric reasoning and CAD generation.

In summary, CADReasoner successfully bridges the gap between noisy 3D scans and precise CAD models by treating reverse engineering as an iterative code-editing problem, guided by explicit geometric feedback and trained on realistic, simulated scan data.