Learning CAD Modeling Sequences via Projection and Part Awareness
Authors: Yang Liu
Daxuan Ren
Yijie Ding
Jianmin Zheng
Fang Deng
Venue: NeurIPS 2025 poster ()
Keywords: Computer-Aided Design
Modeling Sequence Generation
Semi-Autoregressive
Part Awareness
Triplane Projection
Primary area: deep_learning

Abstract: This paper presents PartCAD, a novel framework for reconstructing CAD modeling sequences directly from point clouds by projection-guided, part-aware geometry reasoning. It consists of (1) an autoregressive approach that decomposes point clouds into part-aware latent representations, serving as interpretable anchors for CAD generation; (2) a projection guidance module that provides explicit cues about underlying design intent via triplane projections; and (3) a non-autoregressive decoder to generate sketch-extrusion parameters in a single forward pass, enabling efficient and structurally coherent CAD instruction synthesis. By bridging geometric signals and semantic understanding, PartCAD tackles the challenge of reconstructing editable CAD models—capturing underlying design processes—from 3D point clouds. Extensive experiments show that PartCAD significantly outperforms existing methods for CAD instruction generation in both accuracy and robustness. The work sheds light on part-driven reconstruction of interpretable CAD models, opening new avenues in reverse engineering and CAD automation.

Learning CAD Modeling Sequences via Projection and Part Awareness
Yang Liu Beijing Institute of Technology
Daxuan Ren Nanyang Technological University Singapore daxuan001@e ntu. edu.
China, Beijing 1 liuyangebit. edu cn
Yijie Ding
Jianmin Zheng
Nanyang Technological University Singapore yijie0029e.ne wtw.nnu..eeee adw.eeuu..uueeuu.........
Nanyang Technological University Singapore ASJNZheng@ntu..duu edu.sg
Fang Deng
Beijing Institute of Technology
China, Beijing
dengfang@bit. cn
PART
CAD
Figure CAD Library reconstructed by PartCAD
Abstract
This paper presents ParCCAD, a novel framework for reconstructing CAD modeling sequences directly from point clouds by projection guided,, part-aware geometry reasoning. consists of (1) an autoregressive approach that decomposes point clouds into part-aware latent representations, serving interpretable anchors for
"Corresponding author (dengfang@biic @bit.edb..c...
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

CAD generation; (2) projection guidance module that provides explicit cues about underlying design intent via triplane projections; and (3) autoorrrrereeevveeeeeeeeeeeeeeee de- coder to generate sketch-extrusion parameters in a single forward pass, enabling efficient and structurally coherent CAD instruction synthesis. By bridging geomet- ric signals and semantic understanding, PartCAD tackles the challenge of recon- structing editable CAD models- c underlying design processes- from 3D point clouds. Extensive experiments show that PartCAD significantly outperforms existing methods for CAD instruction generation in both accuracy and robustness. The work sheds light part-driven reconstruction of interpretable CAD models, opening new avenues in reverse engineering and CAD automation.
Introduction
Computer-Aides Aided Design (CAD) plays central role in modern industrial manufacturing and product development [] While CAD models can be represented by point clouds, meshes, boundary represen- tations Reps), and constructive solid geometry (CSG), these representations primarily capture the final geometry rather than the generative design process. In contrast, the modeling sequence represen- tation defines the model through sequence of modeling commands such as sketching, extrusion, and Boolean operations that encode not only geometric construction but also high-level design intent and the underlying semantic logie. These modeling sequences are fundamental for supporting editability, version control, and downstream analysis [2]. However, recovering such sequences from raw 3D data, especially from unstructured inputs like scanned point clouds, remains a challenging problem.
Manual reconstruction is aabor-intensive and requires substantial domain expertise [3] 4 [5] Thus,
automating the conversion from point clouds into editable modeling workflows offers transformative potential for reverse engineering, redesign, and knowledge transfer in CAD systems 6 7.
This paper focuses on converting 3D point clouds into ordered parametric instructions- as sketches (e.g.. line, arc, circle) and operations (e.g.. extrusion) 8 9 that can be replayed or edited in standard CAD environments [T0 M 12] The problem by nature lies at the intersection of geometric reasoning, program induction, and sequential learning. Recent works have framed this as sequence prediction problem, applying decoderr architectures map geometric inputs to command sequences [33. While effective for simple shapes, these approaches often fail to scale real-world models that require reasoning over intermediate constructions, hicrarchical dependencies, and geometric constraints. To mitigate this, other methods incorporate geometric priors or sketch- based abstractions to guide the generation process [14. More recent hybrid models combine low-level geometric cues with high-level structure to improve interpretability and output validity, though many of them still focus on fitting continuous primitives rather than generating symbolic instructions, limiting their ability to capture procedural intent [5]
Despite substantial advances in CAD modeling sequence generation, current techniques still exhibit notable limitations. For instance, many approaches treat raw geometric input as monolithic entity, overlooking the procedural structure and hierarchical dependencies inherent to CAD modeling, which in turn leads to inefficiencies in capturing design intent and guiding accurate reconstruction. Another challenge lies in the sequential reasoning of CAD operations. Fully autoregressive methods ensure sequential consistency but are highly vulnerable to eтror accumulation, where early mistakes propagate and compound over subsequent steps [16] 17. In contrast, non- non-autoregressive approaches improve efficiency by generating sequences in parallel, but often struggle to capture hierarchical dependencies and structural constraints, leading to incoherent or invalid outputs [88 19). addition, current methods lack explicit mechanisms to align high-level geometric features with stepwise modeling instructions, limiting their ability to produce semantically consistent instructions. The inherent one-te one-to-mane to-many mapping between geometry and valid command sequences further introduces ambiguity, complicating both learning and inference. These challenges lead to fundamental question: How can raw geometry be structured and interpreted to reflect the underlying design process and guide the generation of accurate and semantically meaningful CAD instructions?
To answer this question, we introduce PartCAD, semi-autoregressive framework that generates structured CAD modeling instructions by leveraging implicit part abstractions and projection-gus guided geometry. Rather than treating raw input as whole, ParCCA autoregressively decomposes the point cloud into a sequence of part-aware latent representations, each semantically aligned with a simple modeling step, thereby providing procedural structure and capturing design intent. These

---

latents serve as anchors for CAD generation, guided by canonical triplane projections that explicitly encode view-aligned geometric cues. To decode latents into parametric instructions, PartCAD adopts non-autoregressive decoding strategy that produces precise forward pass. Several key techniques are introduced to bridge low-level geometry and high-level semantics for coherent and interpretable CAD reconstruction. The main contributions of our work include:
parameters in single
ParICAD, a semr-auttreggressvve framework for parametric CAD generation, which decomposes input point clouds into procedurally aligned part-aware latents and generates structured modeling instructions with triplane projection guidance:
an adaptive projection strategy to refine view-aligned geometry, and a hierarchical KNN aggrega- tion kernel to extract robust triplane features;
a projection-guider decoding mechanism that integrates part-level semantics with both point-level local features and global geometric context, enabling accurate CAD instruction generation in single forward pass.
Extensive experiments demonstrate that PartCAD achieves superior performance in learning CAD instruction sequences and generalizes well across domains (see Figure I for some models recon- structed by PartCAD). The proposed approach provides new insights into reconstructing editable and semantically meaningful CAD programs from raw geometry.
2 Related Works
Shape Representations: Various low-level shape representations such as point clouds, voxels, and meshes are widely used to describe 3D geometry. These discrete formats have become standard in modern 3D vision pipelines, supporting substantial progress in tasks like feature extraction, segmentation, and classification 220 21
22 23 24). With advances in geometric learning, recent techniques enable translation across representations, for example, reconstructing meshes from point clouds (25] 26 or converting voxel grids into implicit fields (27 28). Their outputs, however, lack explicit structure and editability, and fail convey the parametric representation needed for downstream design, analysis and manipulation. Our goal is to translate raw geometric inputs, particularly point clouds, into structured parametric representations suitable for procedural modeling.
Parametric CAD Learning: Parametric modeling aims to learn structured representations CAD models, with Constructive Solid Geometry (CSG) and Boundary Representation (B-Rep) being two widely adopted paradigms. CSG constructs 3D shapes by hierarchically combining primitives (e.g.. cubes, spheres, cylinders) through Boolean operations (e.g.. union, intersection, difference), making it well-suited for procedural tasks involving regular geometries and well-defined topologies. Recent works have applied deep neural networks to infer CSG trees for inverse or generative design, showing promising results on synthetic or simple shapes [29 30 31]. However, its reliance on a limited primitive vocabulary restricts expressiveness in modeling complex surfaces and high-level design intent. In contrast, B-Rep explicitly represents geometry through vertices, edges, and faces, offering high fidelity in capturing intricate geometric and topological details. Combined with deep learning, recent methods have exploited B B-Rep using graph neural networks and Transformer-be based models features
to learn spatial and connectivity-awaat B-Rep remains challenging due to its strict consistency constraints and sensitivity to topological variations or geometric imperfections. Moreover, B-Rep focuses on final geometry rather than the design process, limiting its capacity for sequential reasoning and intent-aware editing. Unlike these works, we focus on learning parametric instruction sequences (c.g.. sketch, extrusion, Boolcan operations) that describe 3D shapes through step-by-step modeling process. These instructions compactly encode both geometric structure and design logic in an interpretable form, aligning naturally with procedural modeling workflows.
34 35
36 37 Nevertheless, learning with
Instruction language offers a procedural representation of 3D modeling, where shapes are incrementally constructed via sequences of semantic commands. Rather than directly defining geometries, CAD instruction captures the logic of the actual modeling workflows, offering high interpretability and editability (38), Early methods used handcrafted rules, templates, or grammars to encode domain-specific priors. Recently, generative paradigms have emerged, leveraging the semantic and sequential nature of instruction sequences under supervised or
CAD Instruction Language Generation:
3

---

Autoencoder- based methods encode entire instruction sequences into compact latent vectors and decode them holistically, capturing global dependencies and improving stability 422. Seq2Seq models formulate instruction generation as conditional sequence translation from multimodal inputs (e.g., sketches, images, point clouds) to command sequences, aided by Autoregressive models further enhance local control and syntactic consistency by generating instructions token-by- token 45 46 47 48) Additionally, large-scale pre-trained models (e.g., large language models or multimodal large models) have been introduced into CAD instruction generation [49 50
unsupervised learning [39 40 41
attention mechanisms for long-range dependency and cross-modal alignment 43 44
S 52 [53]
In contrast to existing paradigms, we propose a semi-au autn--utorrrrssivvee framework that first derives part-aware latent representations an autoregressive manner, followed by a projection-guieee autoregressive decoder to generate CAD instructions in a single forward pass. This design enables precise semantic reasoning alongside efficient and structurally coherent instruction generation.
non-
PartCAD for Inferring Modeling Sequences from Point Clouds
Step Part Decomposition
voll
PC3D Encoder
Part
valld
vold part
Awsld
-..
Eyvi
Orientation Predictor
Step CAD Instruction Genaration
Autorogres ogresseee Update
Aggrogazion
guera
20 Point Projection
Step Projection Guidance
Lanter
Pojeztoo))
Olobal Feature Interaction
Adactivn Sampling
Aeg zulue
PC2D Encoder
Popeation
X2 Projction))
R
fext
1,185 (36, 154
00
YZ Projectoree
1.10 136 101
Figure 2: Overview of PartCAD Architecture. Starting from a point cloud X, PartCAD generates parametric CAD instructions in three steps: (1) Part Decomposition extracts global point cloud feature fx and autoregressively decodes it into a sequence of part latents 21,...: zN; (2) Projection Guidance predicts an orientation for each 2, and derives aanonical-aligned projections used to extract triplane features fpe2d = { f=z fyy) (3) Instruction Generation decodes each part
latent by leveraging its projection features generate instruction parameters {(cttt exxt )
Given the input point cloud X. our goal is to generate a sequence of structured parametric instructions where each sketch-extrusion pair compactly describes constructive step in the modeling process. Formally, each instruction c. (cekt, cext) consists of two components: gekt encodes primitives (line, arc, and circle our work) to define the profile geometry of the sketch, while ext specifies the corresponding solid operation via parameters such orientation, origin, extrusion distance, scaling, and Boolcan operation type. Following 42 43 48), both components are represented discrete intervals obtained by quantizing continuous modeling parameters into fixed vocabularies. More details about CAD sequence representation are provided in Appendix A.T
C = (c, [c,,) j
Inspired by the compositional nature of human CAD modeling, we introduce PartCAD, a semi- autoregressive framework that translates unstructured point clouds into structured parametric in- structions. Instead of treating instruction generation as a flat sequence prediction task, ParCCA decomposes the input geometry into part-wise latent representations, each grounded implicit design intent. Given that design details are inherently embedded within canonical planes and different perspective views encode distinct geometric and topological features, we extract triplane projection features to provide low-level geometric guidance for each part latent. Finally, each part latent is

---

decoded leveraging local- and global-level features, enabling accurate CAD instruction generation in a single forward pass. The rest of this section elaborates on these key techniques along with optimization strategies. Further implementation details are provided in Appendix A.2 A.2
Autoregressive Implicit Part Decomposition: Real-world CAD models are inherently compo- sitional, comprising multiple parts with explicit semantics and ordered construction logic. To model this structure, we propose an autoregres- sive formulation that incrementally decomposes the input geometry into semantically meaning- ful latent representations. Given a global feature fz extracted from the input point cloud X, the part decoder is initialized with a special start embedding 2g and sequentially generates se- each con- ditioned on the previously decoded latents and the shared global context. As shown in Figure [3] each latent acts semantic anchor for gen- erating corresponding modeling instruction. Formally, the generation process follows:
Port Latert Decompottion
tratruction Design Indent
200
ries of implicit part latents {2n 1 [
Figure 3: Given a 3D point cloud, PartCAD pre- dicts sequence of implicit part latent Σn. each encodes a part-level decomposition and is aligned with a modeling instruction that conveys explicit design intent.
N P(Z fx = II P(zn Zea, ppc3d
(1)
#=
To regulate this autoregressive process, we introduce part discriminator that classifies whether each generated latent corresponds to a valid modeling operation. The discriminator provides auxiliary supervision to distinguish valid construction steps from redundant slots, enhancing instruction alignment and termination control.
Triplane Projection Guidance: Inspired by the observation that human CAD modeling of- ten sketches in canonical planes and visual- izes extrusions from side views, we propose a projection-guided approach that converts 3D ge- ometry into structured 2D features for instruc- tion decoding. These triplane projections cap- ture view-specific design intent and serve as an effective interface between raw point clouds and parametric instruction synthesis. To this end, we estimate an orientation from each part latent rotate the input point cloud accordingly, and project it onto three canonical planes to extract aligned 2D features.
Inttal Projection
Normal Fltteinn
Grid Sampling
Figure 4: Illustration of adaptive projection. From left to right: initial projection, after normal filter- ing, and final result with adaptive grid sampling.
However, direct projections often introduce artifacts, such as points clustering along extrusion faces and sparse coverage in curved regions. To mitigate this, we propose an adaptive projection strategy that combines normal-based filtering and adaptive grid sampling. As illustrated in Figure 4 the former removes points whose surface normals deviate from the projection direction (thresholded by ònormal); while the latter resamples the filtered points into uniform grids, enforcing spacing constraint ógrid to ensure balanced coverage and reduce redundancy.
To effectively capture structural cues from projection points, we design a hicrarchical KNN aggre- gation kernel tailored for triplane projections. After projection, geometrically distinct 3D regions may collapse into adjacent 2D neighborhoods, making naive Euclidean KNN prone to ambiguity. To address this, our kernel progressively refines k neighbor selection in three stages: (1) select the nearest 3k candidates by 2D Euclidean distance; (2) filter to 2 points with similar radial distances from the projection centroid; and (3) retain the final l: neighbors with the most similar surface normals to enforce consistency. This results in a geometry-
local neighborhood that preserves surface semantics for downstream feature extraction. Formally, the final neighborhood index is defined as:
idXinnal TopKy (I|n:- nyll. j E TopK (Ir: ryle j TopK3; (lIP: p,())), (2)
5

---

where p, denotes the 2D projected coordinates, the surface normal, and r; the radial distance to the centroid. After constructing the refined neighborhoods, projection features are extracted using three FdgeConv-style layers. Empirically, our hierarchical kernel enables more accurate encoding of sketch and extrusion structures. See Appendix B for additional comparisons and visualizations.
CAD Instruction Generation: Given the part-level representations from autoregressive decompo- sition, our goal is decode complete parametric instructions in a single forward pass. As shown in Figure 2 (bottom right), we leverage the semantics encoded in each part latent 2n, as well as the geometric cues preserved in its corresponding triplane projections fpe2d [ f fx*). Specifically, we employ two dedicated decoder branches: the top- view feature f is used for sketch decoder Dekt. while
the side-view features f and fn are concatenated guide the extrusion decoder Dext. Mathematically, the generation process can be formulated as:
pkt DDst (Zn; ( c [ext(Ens [ S
To facilitate instruction decoding from part latents, we introduce two interaction mechanisms that connect semantic embeddings with features extracted from triplane projections. First, a cross- attention (CA) module aligns each part latent 2, with its associated point-level projection features f, E N xd to enable local feature aggregation. Second, a self-attention (SA) operates on global features f. Max MaxPool(C..) 1x facilitate contextual interaction.
CA(Zn; fn) = soltmax (( du (f.
(4)
Sf, = Sh ((,, /V de) (f,
(5)
where W W W and W W W denote the learnable projection matrices, softmax is applied row-wise across the attention scores, and dę is the feature dimension of each head. The output embeddings of the above interactions serve as inputs to the final decoding: the CA results provide the query Q, while the SA outputs act as the key and value K/V.
F(I) < LN(FFN(LN(FF + Dropout(MHA(FF? (MHA(F Kn, V.)I))), 1=1,2
(6)
Here, P( Qn. MHA denotes multi-head attention, LN is the Layer Normalization, and FFN is the feed forward network. Finally, the output embeddings after the second decoder layer are fed into two separate linear heads to generate the complete instruction:
On (MLP skotch (F.f.skntth))
MLP extruusoo (F (xttessttnsion))).. C [n
Optimization: As shown in Figure 2] we employ a multi-objective loss to jointly supervise the training process. First, the Parameter Tosses (Lekt and Lext), defined as position- -iiti cross-entropy over discretized instruction tokens, supervise sketch and extrusion prediction at each modeling step. Second, the Rotation loss (,rot), formulated as cross-entropy over discretized orientation tokens, encourages accurate estimation of canonical-alignes rotations for reliable triplane projection. Last, we propose a Validity loss (Lva)), implemented as binary cross- cross-entropy between predicted validity scores and not-hot labels, to guide the part decoder in distinguishing meaningful construction steps. These labels indicate whether each sequence in the ground truth instruction corresponds to a valid modeling operation. The overall training objective is the weighted sum of the above components:
Lioral Aaki Lekt + dext Lext + Crot + Aval
(8)
where Aekt, dexts Avot and Aval are weight coefficients controlling the contribution of each term.
4 Experiments
Dataset: We train and evaluate our model on the DeepCAD dataset 42 and further perform cross-dataset validation on the Fusion 360 Gallery [12. Both datasets provide executable modeling instructions that can be rendered into 3D geometry via standard CAD kernels. Following prior work 43), we remove duplicate data based on geometry similarities. yielding ~ 140k training and 7k test/validation samples. We generate point clouds by uniformly sampling 2,048 points from the normalized CAD model. Instruction parameters are quantized bits, and each sequence organized into extrusionskkethh pairs (see Appendix A.I for details).

---

Implementation and Training: The latent dimension in PartCAD is set to 512. We use k = 40 neighbors for 3D point cloud encoding and k 60 for projection feature extraction. For adaptive point cloud projection, we set the normal threshold normal = 0.5 and grid spacing &grid = 1 x 10-6
The model is trained for 200 epochs with batch size of 32 using the AdamW optimizer
(initial
learning rate 1 x 10-1) and an Exponentiall_R scheduler. Loss weights are set Aakt 2, Aext Aval = 5, and Aoot = All experiments are conducted on NVIDIA A100-40GB GPUs, with each training run taking around 18 hours. During inference, instructions are generated by top-1 decoding over the autoregressively predicted part latents. Additional details are provided in Appendix AA.2
Evaluation metrics: To comprehensively evaluate the quality of the generated CAD sequences and corresponding 3D shapes, we adopt three primary metrics: Chanfer Distance (CD). Fl Score, and Invalid Rate (IR). CD measures geometric similarity as the bidirectional distance between predicted and ground-truth shapes, each uniformly sampled with 8, 1,192 points (scaled by 10 for readability). We report both mean and median CD to reflect overall accuracy and robustness. Following [49, 48]. we compute F1 scores for sketch and extrusion parameters to evaluate instruction-level consistency using the Hungarian algorithm [55] Moreover, the ratio of predictions that fail to generate valid geometry using PythonOCC [10 is reported as the IR.
Baselines: We comprehensively compare our method with several representative CAD genera- tion approaches, categorized into sequence generation-basel 42 45 and primitive fitting- based [15] 40 [4 [3] methods. For sequence- baselines, we evaluate the generated construction instructions directly. For primitive-basee methods, which predict geometry without explicit command sequences, assess performance using CD) and IR to measure geometric fidelity and modeling validity. All baselines are trained, fine-tuned, and tested using their official implementations, ensuring fair comparison against strong existing methods. Full implementation details are provided in the Appendix A.3
4.1 Evaluation Results
Design Instruction Generation Results: Table reports generation on the DeepCAD dataset. The experiments demonstrate that our method outperforms all sequence generation-bail based methods across all metrics. For instruction parameter indicators like F1 and IR, the results show that our method achieves more accurate parameter recovery with minimal sequence-level errors. For geometric metrics such as median and mean CD, the results show that our method yields more accurate shape reconstruction with higher fidelity to the ground-truth geometry.
reports the quantitative results of CAD instruction
Table 1: Quantitative results of sequence generation-basel methods on the DeepCAD dataset [42) We report F1 scores for sketch parameters (Line, Arc, Circle) and extrusion parameters (Extrusion), CD (mean and median) for geometric fidelity, and IR for modeling validity.
F1 Score Circle
CD (x (x1)))
Methods
IR
Line f
Are
Extrusion
Mean 4
Median +
DeepCAD hp
69.37
15.45
60.26
87.56
44.53
17.49
8.51
DeepCAD*
71.54
18.50
58.13
87.88
39.65
8.33
5.39
TransCAD
43
75.03
40.52
73.89
89.17
34.54
5.67
3.60
PanCAD (Ours)
82.82
56.06
81.06
95.56
4.93
0.238
0.91
We also compare our method with primitive fitting-based approaches in terms of geometric fidelity and modeling validity. As reported in Table 2 our method achieves a lower median CD and IR, indicating more accurate geometry and fewer invalid predictions. The higher Fl scores indicate accurate recovery of instruction parameters, while lower CD reflects that the gen- erated CAD models are geometrically consistent with the input point clouds. Figure presents qualitative comparisons with all baselines. As illustrated, our method shows accurate and struc- turally consistent reconstructions even on challenging cases involving complex sketches and multi-pan part assemblies. In contrast, sequence generation basclines (DeepCAD, DeepCAD", TransCAD) fail to
Table 2: Quantitative results of primitive fitting- based methods on the DeepCAD dataset 42 with median CD and IR metrics.
Methods
Median CD (x10")
IR 4
Point2Cyl 15
0.493
3.72
ExtrudeNet 04
0.371
24.51
SECAD 40
0.355
7.92
HNC-CAD
0.841
6.94
PartCAD (Ours)
0.238
0.91
7

---

generate valid instructions produce inconsistent geometries in some examples, while primitive fitting-based methods (HNC-CAD, SECAD, Point2Cyl, ExtrudeNet) struggle to preserve fine-grained details. More visual results are provided in Figure and Appendix C.1
Cross Dataset Experiments: Following the protocol of prior works (39 48 43 we con- duct the cross-dataset evaluation Fusion 360 Gallery 12 to assess generalization perfor- show that
Table 3: Quantitative results of cross-datases exper-
iments on the Fusion 360 Gallery [12] measured in terms of median CD and IR.
mance. Results presented in Table show PartCAD significantly outperforms all sequence generation based methods in both median CD and IR, reducing the median CD by an order of magnitude compared to baselines. While the median CD is slightly higher than that of some primitive fitting-basen based methods, which bene- fit from direct primitive-level alignment, our method can provide parametric design history with high validity, enabling more interpretable and editable CAD modeling. Representative re- sults shown in Figure where method reconstructs more complete and faithful CAD
Methods
Median CD (x (x10')
IR
Methods based on Primitive Fitting
Point2Cyl [5]
0.458
3.28
ExtrudeNct 14]
0.513
23.85
SECAD 40
0.433
7.49
HICC-CD 13
3.785
6.83
Methods based on Sequence Generation
DeepCAD [42
95,88
26.28
DeepCAD 42
44.23
6.90
TransCAD 43
39.24
4.92
ParCAD (Ours)
1.130
1.31
models compared to all baselines, better capturing the underlying geometry from input point clouds.
Input
GT
Ours
DeopCAD
DespCAD
TransCAD
HNC-CAD
SECAD
Point2Cyl
ExtrudeNet
brseld
brslldd
bwalld
Figure 5: Qualitative results the DeepCAD dataset 42 Each shows input point clouds (left) and the reconstructed CAD models by different methods (right). Compared with bascline methods, ParCCAD produces geometrically accurate and structurally coherent shapes from the input point cloud, effectively preserving fine-grained details and part-wise layout.
Real Scan Experiments: To evaluate ParCCAD real-world applications, we 3D-printed sev- eral CAD models and captured their scans using SIMSCAN-42 3D laser scanner. As shown in Figure 7 ParCAAD successfully reconstructs geometrically faithful CAD models from the scanned point clouds. Furthermore, to evaluate robustness of PartCAD under imperfect input assess the impact of degraded point cloud quality, including surface perturbations (e.g., noise con- tamination) and partial inputs (e-g., missing regions or occlusions). Detailed settings and qualitative visualizations are provided in Appendix C.2
Figure 7: Experiments real-life scanned point clouds (middle) show our method accurately re- constructs real-world CAD models.
conditions, we conduct additional experiments to

---

Input
Ours
DeepCAD
DeepCAD'
TransCAD
HNC-CAD
SECAD
Point2Cyl
ExtrudeNet
Invali
Invalid
lovald
Insalid
Figure 6: Qualitative results on the Fusion 360 Gallery [1]. Our approach produces structurally consistent CAD reconstructions with fine-graine geometric details. In contrast, DeepCAD" and TransCAD occasionally fail to generate valid models, while HNC-CAD, SECAD, Point2Cyl, and ExtrudeNet mainly recover coarse outlines but struggle to capture precise design features, often resulting in shape distortions or noisy artifacts.
4.2 Ablation Study
To analyze the contribution of each core component in the proposed ParCCAD framework, we conduct ablations by selectively disabling key modules and report the results in Table 4 In the part-awareness branch, we remove the autoregressive part decoder and discriminator (w/o Part Decomp.), forcing direct orientation prediction from the global point cloud feature. This ablation results in severe degradation across all metrics, including marked drop F1 scores, increased mean and median CD, and higher IR. A similar trend is observed when discarding triplane projection guidance (w/o Proj. Guidance) and relying solely on the global point cloud features. Notably, although retaining projection guidance improves the validity of generated instructions (declining IR), disabling adaptive sampling (w/o Adapt. Proj.) or replacing the hierarchical KNN kernel with standard Euclidean KNN (w/o Hier. KNN) leads to noticeable drops in parametric performance (FI) and geometric fidelity (CD). This indicates that these two components are essential for projection guidance to provide effective geometric cues. Finally, in the instruction decoding branch, remove local feature aggregation (w/o Local Feat. Aggreg.) or disable global feature interaction (w/o Global Feat. Interact.). can be noted that omitting either attention mechanism leads to higher CD and lower F1 scores, underscoring the necessity of both local and global information for accurate CAD instruction generation. Visual results of the ablation experiments can be found in Appendix C.3
Table 4: Ablation study results on the DeepCAD dataset 42
We report F1 scores for sketch (weighted average over Line, Are, Circle) and extrusion parameters, Chamfer Distance (CD) for geometric fidelity, and Invalid Rate (IR) for instruction-level correctness.
F1 Score f Extrusion
CD (x 1x100) 4.
Group
Model Variant
IR 4
Sketch
Mean
Median
Part Awareness
w/o Part Decomp.
59.51
72.63
15.34
1.987
8.01
w/o Proj. Guidance
65,53
87.23
14,59
1.062
8.94
Projection Guidance
w/o Adapt. Proj.
61.33
73.46
13.42
1.282
5.79
w/o Hier. KNN
64.71
78.93
10.27
1.384
4.27
w/o Local Feat. Aggreg.
75.58
95.25
5,639
0.313
1.33
Instruction Generation
w/o Global Feat. Interact.
73.61
94.63
6.301
0.482
1.51
PartCAD (Full Model)
80.01
95.56
4.93
0.238
0.91

---

Discussions
Conclusion: We have introduced Par(CAD, a semi-auttoegrressvve framework designed for generating structured CAD modeling instructions from point clouds. Our contributions include an implicit part decomposition strategy that autoregressively derives interpretable part representations from point clouds, projection guidance module that provides explicit geometric cues via triplane features, and a non-autoregressive decoder that generates parametric instructions by fusing point- and part- wise features. Extensive evaluations show that PartCAD outperforms existing baselines, achieving significant improvements in both parametric accuracy and geometrie fidelity.
projectionguuidncce
Limitations and Future Work: There are several limitations in our current work. First, the performance of the model inherently constrained by the size and diversity of the training datasets. Second, the mapping from geometry to parametric sequence can be intrinsically one-to- me-too-many introducing ambiguity that complicates both training and evaluation. Third, generating accurate modeling instructions becomes increasingly challenging as object complexity grows, particularly for geometrically intricate or hierarchically unstructured models. Some failure cases are discussed in Appendix D In future, we plan delve into more advanced reasoning mechanisms and richer representations to resolve the ambiguity, optimize the instruction generation, and support intricate shape designs, thereby enhancing the robustness and applicability of PartCAD.
While this work has the potential support educational tools for engineering and design students and lower the barrier to entry for CAD design, its focus on sketch-extrusion alone may constrain design creativity.
Broader Impact:
Acknowledgments
This work was supported in part by the National Natural Science Foundation of China (NSFC) under the Distinguished Young Scholars Program (Grant 62025301), the NSFC Basic Science Center Program (Grant 62088101 the MOE AcRF Tier Grant of Singapore (RG12/22), and the China Scholarship Council (Grant 202406030027).
10

---

References
[1] Mikell Groover and EWJR Zimmers. CAD/CAM: computer-aided design and manufacturing. Pearson Education, 1983.
[2] Jorge D Camba, Manuel Contero, and Pedro Company. Parametric cad modeling: An analysis of strategies for design reusability. Computer-aided design. 74, 2016.
[3] Gopal Sharma, Difan Liu, Subhransu Maji, Evangelos Kalogerakis, Siddhartha Chaudhuri, and Radomír Měch. Parsenet: A parametric surface fitting network for 3d point clouds. In Proceedings of the European conference computer vision (ECCV), 2020.
[4] Xiaogang Wang, Yuelang Xu, Kai Xu, Andrea Tagliasacchi, Bin Zhou, Ali Mahdavi-Amiri, and Hao Zhang. Pic-net: Parametric inference of point cloud edges. In Advances in neural information processing systems (NeurIPS), 2020.
[5] Lequan Yu, Xianzhi Li. Chi-Wing Fu, Daniel Cohen-Or, and Pheng-Ann Heng. Ec-net: an edge-aware point set consolidation network. In Proceedings of the European conference on computer vision (ECCV), 2018.
[6] Dimitrios Mallis, Ali Sk Aziz. Elona Dupont, Kseniya Cherenkova, Ahmet Serdar Karadeniz, Moham- mad Sadil Khan, Anis Kacem, Gleb Gusev, and Djamila Aouada. Sharp challenge 2023: Solving cad history and parameters recovery from point clouds and scans. overview, datasets, metrics, and baselines. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2023.
[7] Mohsen Yavartanoo, Sangmin Hong. Reyhanch Neshatavar, and Kyoung Mu Lee. Cne-net: Self-supervised learning for ene machining operations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024.
[8] Yaroslav Ganin, Sergey Bartunov, Yujia Li, Ethan Keller, and Stefano Saliceti. Computer-aided design as language. In Advances in Neural Information Procexsing Systems (NeurIPS), 2021.
19] Wamiq Para, Shariq Bhat, Paul Guerrero, Tom Kelly, Niloy Mitra, Lconidas J Guibas, and Peter Wonka. Sketchgen: Generating constrained cad sketches. In Advances in Neural Information Processing Systems (NeurIPS), 2021.
[10] Juergen Riegel, Werner Mayer, and Yorik van Havre. FreeCAD. https://wwv. wttp::///wwwfreeedd..om org/ 2024.
[11] Changjian Li, Hao Pan, Adrien Bousseau, and Niloy J Mitra. Free2cad: Parsing freehand drawings into cad commands. ACM Transactions on Graphics (TOG), 41(4), 2022.
[12] Karl DD Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G Lambourne, Armando Solar- Lezama, and Wojciech Matusik. Fusion 360 gallery: A dataset and environment for programmatic cad construction from human design sequences. ACM Transactions Graphics (TOG), 40(4), 2021.
[13] Xiang Xu, Pradeep Kumar Jayaraman, Joseph G Lambourne, Karl DD Willis, and Yasutaka Furukawa. Hierarchical neural coding for controllable cad model generation. In International Conference Machine Learning (ICML). 2023.
[14] Daxuan Ren, Jianmin Zheng, Jianfci Cai, Jiatong Li, and Junzhe Zhang. Extrudenet: Unsupervised inverse sketch-and-extrude for shape parsing. In Proceedings of the European conference on computer vision (ECCV), 2022.
[15] Mikaela Angelina Uy Yen- Yu Chang, Minhyuk Sung, Purvi Goel, Joseph G Lambourne, Tolga Birdal, and Leonidas J Guibas. Point2cyl: Reverse engineering 3d objects from point clouds to extrusion cylinders. In Proceedings of the IEEF/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2022.
[16] Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in neural information processing systems (NeurIPS), volume 28, 2015.
[17] Marc' Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. In International Conference on Learning Representations (ICLR), 2015.
[18] Jiatao Gu, James Bradbury, Caiming Xiong, Victor OK Li, and Richard Socher. Non-autoregressive neural machine translation. In International Conference on Learning Representations (ICLR), 2017.
[19] Yisheng Xiao, Lijun Wu, Junliang Guo, Juntao Li, Min Zhang, Tao Qin, and Tie-yan Liu. A survey on non non-auvoreeressive generation for neural machine translation and beyond, IEEE Transactions on Pattern Analysis and Machine Intelligence (IEEE TPAMI), 45(10) 2023.
11

---

[20] Charles R Qi. Hao Su. Kaichun Mo. and Leonidas J Guibas. Pointnet: Deep learning point sets for 3d classification and segmentation. In Proceedings the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
[21] Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas Guibas. Pointnet++:: Deep hierarchical feature learning on point sets in a metric space. In Advances in neural information processing systems (NeurIPS), 2017.
[22] Yue Wang. Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph enn for learning on point clouds. ACM Transactions on Graphics (TOG), 38(5). 2019.
[23] Vincent Sitzmann, Justus Thies, Felix Heide, Matthias Nießner, Gordon Wetzstein, and Michael Zollhofer. Deepvoxels: Learning persistent feature embeddings. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
[24] Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt. Neural sparse voxel fields. Advancex in Neural Information Processing Systems (NeurlPS), 2020.
[25] Philipp Erler, Paul Guerrero, Stefan Ohrhallinger, Niloy J Mitra, and Michael Wimmer. Points2surf learning implicit surfaces from point clouds. In Proceedings of the European conference on computer vision (ECCV), 2020.
[26] Rana Hanocka, Gal Metzer, Raja Giryes, and Daniel Cohen-Or. Point2mesh: a self-prior for deformable meshes. ACM Transactions on Graphics (TOG), 39(4), 2020.
[27] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
[28] Lars Mescheder, Michacl Occhsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proceedings of the IEEF/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
[29] Daxuan Ren, Jianmin Zheng, Jianfei Cai, Jiatong Li, Haiyong Jiang. Zhongang Cai, Junzhe Zhang, Liang Pan, Mingyuan Zhang, Haiyu Zhao, et al. Csg-stump: A learning friendly esg-like representation for interpretable shape parsing. In Proceedings of the IEEE/CVF international conference on computer vision (ICCV), 2021.
[30] Fenggen Yu, Zhiqin Chen, Manyi Li, Aditya Sanghi, Hooman Shayani, Ali Mahdavi-Amiri, and Hao Zhang. Capri-net: Learning compact cad shapes with adaptive primitive assembly. In Proceedings of the IEEL/CVF conference on compuder vision and pattern recognition (CVPR), 2022.
[31] Kacper Kania, Maciej Zieha, and Tomasz Kajdanowiez. Uesg-net- unsupervised discovering of constructive solid geometry tree. In Advances in Neural Information Processing Systems (NeurIPS), 2020.
[32] Haoxiang Guo, Shilin Liu, Hao Pan, Yang Liu, Xin Tong, and Baining Guo. Complexgen: Cad reconstruc- tion by b-rep chain complex generation. ACM Transactions on Graphics (TOG), 41(4), 2022.
[33] Xiang Xu, Joseph Lambourne, Pradeep Jayaraman, Zhengqing Wang. Karl Willis, and Yasutaka Furukawa. Brepgen: A b-rep generative diffusion model with structured latent geometry. ACM Transactions on Graphics (TOG), 43(4), 2024.
[34] Benjamin T Jones, Michael Hu, Milin Kodnongbua, Vladimir G Kim, and Adriana Schulz. Self-supervised representation learning for cad. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2023.
[35] Elona Dupont, Kseniya Cherenkova, Anis Kacem, Sk Aziz Ali, Ilya Arzhannikov, Gleb Gusev, and Djamila Aouada. Cadops- net: Jointly learning cad operation types and steps from boundary- representations. In International Conference on 3D Vision (3DV), 2022.
net:
[36] Pradeep Kumar Jayaraman, Aditya Sanghi. Joseph G. Lambourne, Karl D.D. Willis, Thomas Davies. Hooman Shayani, and Nigel Morris. Uv-net: Leamiing from boundary representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2021.
[37] Joseph G Lambourne, Karl DD Willis, Pradeep Kumar Jayaraman, Aditya Sanghi, Peter Meltzer, and Hooman Shayani. Brepnet: A topological message passing system for solid models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition (CVPR), 2021.
12

---

[38] Yuezhi Yang and Hao Pan. Discovering design concepts for cad sketches. In Advances in Neurul Information Processing Systems (NeurIPS), 2022.
[39] Weijian Ma, Minyang Xu, Xueyang Li. and Xiangdong Zhou. Multicad: Contrastive representation learning for multi-modal 3d computer-aided design models. In Proceedings of the 32nd ACM International Conference on Information and Knowledge Management (CIKM), 2023.
[40] Pu Li, Jianwei Guo, Xiaopeng Zhang, and Dong-Ming Yan. Secad-net: Self-supervised cad reconstruction by learning sketch-extrude operations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2023.
[41] Pu Li, Jianwei Guo, Huibin Li, Bedrich Benes, and Dong- Ming Yan. Sfmead: Unsupervised cad reconstruc- tion by learning sketch- based feature modeling operations. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024.
[42] Rundi Wu, Chang Xiao, and Changxi Zheng. Deepead: deep generative network for computer-aided design models. In Proceedings of the IEEE/CVF international conference on computer vision (ICCV), 2021.
[43] Elona Dupont, Kseniya Cherenkova, Dimitrios Mallis, Gleb Gusev, Anis Kacem, and Djamila Aouada. Transcad: A hierarchical transformer for cad sequence inference from point clouds. In Proceedings of the European conference on computer vision (ECCV), 2024.
[44] Xueyang Li, Yu Song, Yunzhong Lou, and Xiangdong Zhou. Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. In Proceedings of the 32nd ACM International Conference on Multimedia (ACM MM), 2024.
[45] Armen Avetisyan, Christopher Xie, Henry Howard-Jenkins, Tsun- Yi Yang, Samir Aroudj, Suvam Patra, Fuyang Zhang. Duncan Frost, Luke Holland, Campbell Orme, et al. Scenescript: Reconstructing seenes with an autoregressive structured language model. In Proceedings of the European conference computer vision (ECCV), 2024.
[46] Weijian Ma. Shuaiqi Chen, Yunzhong Lou, Xueyang Li, and Xiangdong Zhou. Draw step by step: Reconstructing cad construction sequences from point clouds via multimodal difflusion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Puttern Recognition (CVPR), 2024.
[47] Xiang Xu, Karl DD Willis, Joseph G Lambourne, Chin-Yr Yi Cheng, Pradeep Kumar Jayaraman, and Yasutaka Furukawa. Skexgen: Autoregressive generation of cad construction sequences with disentangled eodebooks. In International Conference on Machine Learning (ICMI.), 2022.
[48] Mohammad Sadil Khan, Elona Dupont, Sk Aziz Ali, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. Cad Cad-signet: Cad language inference from point clouds using layer-wise sketch instance guided attention. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024.
[49] Mohammad Sadil Khan, Sankalp Sinha, Sheikh Talha Uddin, Didier Stricker, Sk Aziz Ali, and Muham- mad Zeshan Afzal. Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. In Advances in Neural Information Processing Systems (NeurIPS), 2024.
[50] Sifan Wu, Amir Hosein Khasahmadi, Mor Katz, Pradeep Kumar Jayaraman, Yewen Pu, Karl Willis, and Bang Liu. Cadvlm: Bridging language and vision in the generation of parametric cad sketches. In Proceedings of the European conference on computer vision (ECCV), 2024.
[51] Siyu Wang, Cailian Chen, Xinyi Lec, Qimin Xu, Lei Xu, Yanzhou Zhang, and Jie Yang. Cad-gpt: Synthesising cad construction sequence with spatial reasoning-enhanced multimodal llms. In Proceedings of the AAAI Conference Artificial Intelligence (AAAI), 2025.
[52] Kamel Alrashedy, Pradyumna Tambwekar, Zultiqar Zaidi, Megan Langwasser, Wei Xu, and Matthew Gombolay, Generating cad code with vision-language models for 3d designs. In International Conference on Learning Representations (ICLR), 2025.
[53] Jingwei Xu, Zibo Zhao, Chenyu Wang, Wen Liu, Yi Ma, and Shenghua Gao, Cad-mllm: Unifying multimodalit--onddiiooo cad generation with milm. arXiv preprint arXiv:2411.0449 2024.
[54] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.
[55] Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly. 2(1-2), 1955.
13

---

[56] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez. L ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.
[57] Anastasia Dubrovina. Fei Xia, Panos Achlioptas, Mira Shalah, Raphael Groscot, and Leonidas J. Guibas. Composite shape modeling via latent space factorization. Proceedings of the IEEE/CVE International Conference on Computer Vision 201C,),
[58] Yongheng Zhao. Tolga Birdal, Haowen Deng, and Federico Tombari. point capsule networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
[59] Danila Rukhovich, Elona Dupont, Dimitrios Mallis, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. Cad-recode: Reverse engineering cad code from point clouds. In Pruceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2025.
14

---

NeurIPS Paper Checklist
Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification:
The abstract and introduction clearly state the central contributions of the paper: a semi remi-autoregressiv framework for CAD instruction generation that decomposes input geometry into part-wise latent representations and decodes them using triplane projection guidance. These claims are consistently supported by detailed methodological descriptions and validated through both quantitative and qualitative experiments. The scope and limita- tions of the approach are appropriately discussed, and no unsubstantiated or overgeneralized claims are made. The presentation remains faithful to what is actually achieved in the work.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not perceived well by the reviewers,
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize other settings.
is fine to include aspirational goals as motivation as long as is clear that these goals are not attained by the paper.
2. Limitations
Question:
Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification: The paper discusses key limitations in Section 5 and Appendix D First, the performance of the proposed model is bounded by the scale and diversity of available train- ing data. Second, the inherently one-to-many nature of introduces ambiguity that complicates both learning and evaluation. Third, the model's ability to generate accurate CAD instructions declines for complex or hierarchically unstruc- tured geometries. We provide representative failure cases and discuss how these limitations affect generalization and robustness. Additionally, we outline future directions address these issues through improved reasoning mechanisms and richer representations.
mapping
Guidelines:
The answer NA means that the paper has limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution is low images are taken in low lighting. Or speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency the proposed algorithms and how they scale with dataset size.
15

---

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, worse outcome might be that reviewers discover limitations that aren't It acknowledged the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community, Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [NA]
Justification: The paper does not contain theoretical results requiring formal assumptions or proofs. The work focuses on algorithmic design, architectural innovations, and empirical evaluation.
Guidelines:
The answer NA means that the paper does not include thcoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but they appear in the supplemental material, the authors are encouraged provide short proof sketch to provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Answer: [Yes]
The paper provides comprehensive implementation details, including archi- tecture configurations, training hyperparameters, loss formulations, and dataset processing steps. Key components such as autoregressive part decomposition, triplane feature guidance, and CAD instruction generation are fully described in Section 3 Section 4 and Appendix A.2 All experimental protocols follow standard benchmarks with clearly stated evaluation metrics. These details sufficient to reproduce the main results even without access the source code.
Justification:
Guidelines:
The answer NA means that the paper does not include experiments. If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
16

---

While NeurIPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily new algorithm, the paper should make it clear how to reproduce that algorithm. (b) the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.
(c)
If the contribution is new model (e.g., . a large language model), then there should either way to access this model for reproducing the results or way to reproduce the model (e.g.. with an open-source dataset instructions for how to construct the dataset).
(d) We recognize that reproducibility may tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. the case of closed-source models, it may be that access to the model limited in some way (e.g.. registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described in supplemental material?
Answer: [Yes]
Justification: All implementation and training details are described in main paper and Appendix to support reproducibility.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS code and data submission guidelines (https://nips.ce
aublic//uuddes//odeettbim..
wwwpssiinnooyiyyly for more details.
While we encourage the release of code and data, we understand that this might not be possible, so "No" an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurlPS code and data submission guidelines (https for more details.
/ //nips/co wwtpppbicc/guues......ppppppppee
The authors should provide instructions data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification: We provide comprehensive details of our experimental settings, including dataset preprocessing, training/test splits, model architecture and hyperparameters, optimizer configurations, and weight settings in Section and Appendix[A.. A.2 All these details are fully documented to ensure the results are understandable and reproducible.
Guidelines:
17

---

The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, or as supplemental material.
7. Experiment statistical significance
Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Question:
Answer: [Yes]
Justification: All reported results are obtained through multiple carefully controlled runs with consistent data splits and training configurations. The results are highly stable, and consistent trends observed across all baselines and experimental settings. These outcomes provide strong support for the validity our claims.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, confi- dence intervals, or statistical significance tests, least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall
run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
should be clear whether the error bar is the standard deviation the standard error of the mean.
It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out range (e.g. negative error rates).
If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Question:
Answer: [Yes]
Justification: All experiments were conducted 8 NVIDIA A100-PCIE-40GB GPUs, using a batch size of 32 and training for 200 epochs. The average training time of the full model approximately 18 hours. All major experiments, including ablation studies and cross-dataset evaluations, were performed under this setup. Detailed implementation and resouree settings are provided in Section 4 and Appendix A.2 to ensure reproducibility and transparency.
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported the paper (e.g., preliminary or failed experiments that didn't 't make into the paper).
18

---

9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurlPS Code of Ethics httppp///earrppp.cc/ppalll/leees
Answer: [Yes]
This research fully adheres to the NeurIPS Code of Ethics. It involves no human subjects, personal data, or sensitive content and does not pose foreseeable risks related to safety, privacy, fairness, or misuse. All experiments are conducted using publicly available datasets with appropriate licenses. We have carefully reviewed the ethical guidelines and confirm that our study complies with all relevant principles.
Justification:
Guidelines:
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g.. there is a special consid- eration due to laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification: Our work has the potential to support educational tools for engineering and design students by automating CAD modeling and lowering the barrier to entry for novice users. This may improve accessibility and efficiency in industrial design workflows, particu- larly in manufacturing, architecture, and engineering. by reducing design time and enabling more interpretable modeling tools. However, our method centers on sketch-extrusion operations, it may constrain modeling flexibility in more complex or creative design scenar- ios. Moreover, while the method itself does not pose direct societal risks, recognize the potential for misuse in automated design pipelines, such as the unauthorized replication of copyrighted or proprietary structures. To mitigate such concerns, we advocate for ethical deployment in compliance with intellectual property regulations and encourage future work to expand the modeling expressiveness and reinforce responsible use educational and professional contexts.
Guidelines:
The answer NA means that there no societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (c.g., disinformation, generating fake profiles, surveillance), fairness considerations (c.g., deploymennt of technologics that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and tied to particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).
19

---

11. Safeguards
Question:
Does the paper describe safeguards that have been put in place for responsible release of data models that have a high risk for misuse (e.g., pretrained language models, image generators, scraped datasets)?
Answer: [NA]
Justification: Our work does not involve high-risk models datasets with potential for misuse, such as large-scale generative models or scraped web data. The proposed method focuses on CAD instruction synthesis from point clouds, with foreseeable dual-use or safety concerns.
Guidelines:
The answer NA means that the paper poses such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Question:
Answer: [Yes]
Justification: All datasets and code assets used in this paper are publicly available and properly cited, including the DeepCAD dataset 42 and the Fusion 360 Gallery [12), both which are distributed under open academic licenses. We strictly adhere the terms of use and include appropriate attribution to the original sources in the paper. We also publicly available codebases (c.g., PythonOCC [I0) that are released under permissive open-source licenses, all of which are appropriately credited in the manuscript.
Guidelines:
The answer NA means that the paper does use existing assets.
The authors should cite the original paper that produced the code package or dataset.
The authors should state which version of the asset is used and, if possible, include URL.
The name of the license (e.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (e.g., website). the copyright and terms of service of that source should be provided.
If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswi thcode. com datasets has curated licenses for some datasets. Their licensing guide can help determine the license dataset.
For existing datasets that are re- re-packaged, both the original license and the license of the derived asset (if has changed) should be provided.
this information is not available online, the authors are encouraged to reach out to the asset's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
20

---

Justification: We introduce a new trained CAD instruction generation model (PartAA)) in- cluding architecture details, training configuration, dependencies, and evaluation instructions. The documentation will be provided to ensure reproducibility and ease of use.
Guidelines:
The answer NA means that the paper does release new assets.
Researchers should communicate the details the dataset/codd/mmodll as part their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset is used.
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?
Answer: [NA]
Justification: This work does not involve any human subjects or crowdsourcing experiments.
Guidelines:
The answer NA means that the paper does not involve crowdsoureing nor research with human subjects.
Including this information the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included the main paper.
According the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification: This work does not involve any form of crowdsourcing or research with human subjects. All experiments are conducted using publicly available or synthetically generated datasets.
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and expect authors to adhere to the NeurlPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if' applicable), such the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, formatting purposes and does not impact core methodology, scientific rigorousness, originality of the research, declaration is not required.
21

---

Answer: [NA]
Justification: This work does not involve any large language models (LLMs) as part of the core methodology. LLMs were not used in the development, implementation, or evaluation of the proposed approach.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non sta-standard components.
Please refer to our LLM policy htttpp///eaurpps..cooooooerrrrre /LLM) for what should or should not be described.
22

---

Appendix Overview
This appendix provides supplementary information to support the main paper. Section presents detailed implementation settings for CAD sequence representation and the ParICAD framework. Sec- tion B offers additional methodological insights into adaptive projection refinement and hierarchical KNN aggregation. Section reeporttree additional experimental results and analyses. Section D provides some failure cases and more discussion.
A
Additional Implementation Details
A.1
CAD Representation
CAD Design Instructions
(2,,
Ourv
Orientation (0, 9:7)
Cirole
Loop
Line
Excnution
Skotch
(7 Ty. Tc)
Sketch Representation
Extrusion Representation
Parametorization
Skatch
I66
Sugaemse Length
Easuaios Dimrcs
Shatch Orgia
Skathh
Bodlandduliee
Sequence Representation
Figure 8: Illustration of CAD model and tokenized sequence representation.
We adopt a hicrarchical CAD sequence representation structured as sequence of extrusion-sketch token pairs. As illustrated in the bottom part of Figure g we formulate each sequence as solid modeling instruction, consisting of extrusion parameters, sketch primitives, and start/end tokens. Compared primitive-level
42 or tightly packed autoregressive formats 49 48
our representation
offers clearer semantic alignment with human design intent.
In the following, detail the representation format and parameterization of each component.
Sketch Representation: As shown in the top-left part of Figure each Sketch comprises one or more Face, each bounded by one more closed Loop. Each loop consists of geometric primitives Curve, i.c., Line, Arc, or Circle, which are arranged counterclockwise order to ensure consistency. Each primitive is parameterized using several 2D coordinates (z, y) (or radius for Circle):
Line: Start Point and End Point
Are: Start Point, Midpoint, and End Point
Circle: Leftmost Point and Radius
Extrusion Representation: As shown the top-right part of Figure g each Extrusion instruction
consists of 10 parameters that define how 2D sketch is transformed into a 3D solid, including the Orientation, Translation, and Scaling Factor of the sketch plane, as well as the extrusion extent and the Boolean operation type:
23

---

Orientation: parameters (0, 0, that define the sketch plane orientation via Euler angles
Translation: parameters (Ta, Ty. Te) specifying the sketch plane position
Scaling Factor: parameter a controlling the normalization of sketch size
Extrusion Extent: 2 parameters (dt,c) dd) indicating extrusion distances along and opposite to the sketch normal
Boolean Operation: parameter 3 denoting the extrusion operation type, including new, cut, join, and infersection
Tokenization and Quantization. To enable structured sequence representation, we follow 48 to introduce special tokens for parameter separation, including padding, start/end of sequence and end markers for curves, loops, faces, sketches, and extrusions. All continuous parameters (except special tokens and Boolean operation types) uniformly quantized into 8-bit integers, shown in Table
Table 5: Token vocabulary in CAD sequence representation.
Token Category
Token Symbol
Token Value
Description
[11, 266
X coordinate
Sketch Token
y
[11,... 266
Y coordinate Circle Radius
[1l,..., 266]
0
[11, 266]
266
Sketch Plane Orientation
[11,..., 266]
Extrusion Token
Tz
[11, 266
T9
11, 266
Sketch Plane Origin
53
[1, [1,,..., ,66
d+
[11, 266
Extrusion Distance Toward and Opposite Sketch Plane Normal
d-
[11 266]
[11...., 266]
Sketch Scaling Factor
10}
Boolean (New, Cut, Join, Intersect)
PAD
Padding token
SOS
Start of sequence
EOS
End of sequence End of sketch End of face End of loop
Special Token
es
4
End of curve
Ce
End of extrusion
Implementation Details. We set the maximum sequence length, i.e., the maximum number of extrusion-sketch pairs per CAD model, 10. Each sequence is padded fixed length of 110 tokens to ensure batching during training. Following 42), each face contains up to 6 loops, and each loop comprises most 15 curve primitives. In addition, based on geometric similarity. While the filtered dataset may still include models with similar shapes (e.g., cubes or cylinders), variations in size, position, and orientation ensure that no exact sequence duplicates remain in the final dataset.
follow 43] to perform deduplication
A.2 Implementation Details for PartCAD Architecture
The PartCAD framework consists of three modules: (1) Autoregressive Implicit Part Decomposition, (2) Triplane Projection Guidance, and (3) CAD Instruction Generation. Below, we detail the architectural configurations and hyperparameters for each component.
Autoregressive Implicit Part Decomposition: The 3D point cloud encoder implemented using three stacked EdgeCony layers [22 with channel dimensions [12, 64, 64, 128), followed by global

---

max pooling. The input feature consists of 3D coordinates and surface normals, and the neighborhood size is set to & 40. The output global feature projected via a linear projection head.
The autoregressive part decoder comprises four Transformer decoder layers 166, each with 8 attention heads and a ferd-forward network of hidden dimension 2048. It incorporates residual connections, layer normalization, and dropout rate of 0.2. For auxiliary supervision and orientation prediction, we append two prediction heads:
The part discriminator, implemented as a single-layer MLP of size [512, 1], outputs a scalar confidence score indicating whether the generated latent corresponds to valid modeling step.
Part Discriminator:
Orieniation Predictor: The orientation predictor, implemented as single-layer MLP of size [512,3] predicts discretized sketch plane orientation tokens (f, Φ 7) used to align projections with canonical CAD views.
Triplane Projection Guidance: With the predicted orientation (0n, Pn. To) from each part latent, we perform denumericalization to obtain a rotation matrix R, Soutrroo (On, On, To). This then applied to the input point cloud X' produce rotated geometry X R. X, aligning with canonical CAD design views.
Based on X, we derive canonical eanonieal-aligned triplane projections for subsequent adaptive sampling and feature encoding. To enable reliable triplane encoding, we apply a projection refinement module using thresholds nnormal = 0.5 (for normal filtering) and 6gri 1 x 10-6 (for grid resampling).
The 2D projection encoder consists of three 2D EdgeConv layers with dimensions [12, 64, 64, 64). Input features include 2D projected coordinates, associated normals, and radial distances to the projection centroid. The local neighborhood size is set to k = 60. The encoder outputs per-point features, which are subsequently used for instruction decoding.
We use separate decoding branches for sketch and extrusion parameter prediction. Each branch consists of: a local feature aggregation layer for aligning part latents with point-level projection features via cross- attsentottnnoon a global feature interaction layer for contextual reasoning over triplane global features via self-attention, and two Transformer decoder layers (each with attention heads, a ferd-forward dimension of 2048, and dropout rate 0.2) for final sequence decoding. The output of each branch is passed through a linear layer to generate the predicted instruction parameters.
CAD Instruction Generation:
The latent dimensions for the part representations 2n, 3D point features f and ryy-llane features f are all set to 512. The zz- and yz-plane features f== and f are both set to 256 for dimensional compatibility during feature concatenation, i.e., [s fxH] E RR512.
Latent Dimensions:
Loss Implementation Details:
We implement the multi-objective loss described in Section 3 which combines supervision on instruction parameters with auxiliary objectives for orientation estimation and part validity classification.
The parameter loss consists of two parts, i.e., the sketch loss Lake and the extrusion loss Lext- Let yt denote the ground- -truh token at position t and in be the predicted logits, the loss is computed using position-wis wise cross-entree entrop:::
Parameter loss:
Tike
Texs
Lake
skt Vi.a
log
eet ft,t
Lext
extt Vt.
eext log Vi.3
Here, Takt and Text denote the sequence lengths of sketch and extrusion tokens respectively, d 267 is the vocabulary size, and yt.s. De.s denote the one-hot target and softmax prediction for token t and class
The rotation parameter is treated as a discrete token similar to other instruction parameters. Let of denote the one-hot target token and oo the predicted softmax probability the corresponding rotation position, the loss is computed as:
Rotation loss:
d,ot
Lrot
V log Vt.
(10)
25

---

Validity loss: To supervise part validity, we define binary label yn {0, 1) for each part latent, indicating whether it corresponds to a valid modeling step. The prediction Uū E [0, 1] is obtained via sigmoid function. The validity loss is computed using binary cross-entropy:
N Σ
1
Lvall
yal log Gial +
Vn ( log(1
Vn
(11)
Here, N denotes the number of part latents, yo is the ground-truth one-hot label indicating whether the n-th part is valid, and izai is the predicted validity score after sigmoid activation.
The total training objective is weighted combination of all components:
Liotal = Lakt. + dext frxxt + Aroe Lrot + Aval L
(12)
In all experiments, we set the loss weights as Askt = 2, Aext = 1, Avot 1, and Aval = 5.
A.3 Implementation Details for Baseline Methods
DeepCAD: For DeepCAD 42 use its official open-source implementation. The model is first trained for 1000 epochs with the sequence reconstruction objective, jointly optimizing a sequence encoder and latent decoder to reconstruct CAD sequences. In the second stage, the sequence encoder is frozen, and 4-layer PointNet++ point cloud encoder [2I] (as provided in the official implementation) is trained for 200 epochs using MSE loss to align its output with the latent space. At inference time, input point clouds are encoded into latent vectors, which are then decoded by the pretrained decoder generate CAD instruction sequences.
Since the original DeepCAD adopts contrastive learning approach, where the point cloud encoder is trained to align with sequence latents, it may suffer from information loss due to weak
DeepCAD":
supervision. We provide DeepCAD", a variant trained to directly decode CAD instruction sequences from point cloud features. The decoder takes input the extracted point cloud features and learned constant embedding, and is supervised with cross-entropy loss over quantized instruction parameters. All remaining architecture (i.e., point cloud encoder and sequence decoder), optimization scheme, and testing protocol follow the original DeepCAD setup, with the model trained for 200 epochs.
TransCAD: For TransCAD [43, since the official implementation is not provided, we reimplement the framework based on the original paper details. The overall architecture consists of point cloud encoder (4-layer PointNet+++), Loop-Extrusion Decoder (4-layer Transformer decoder with 3-layer MIP),, two separate decoders (a 3-layer MI.P for extrusion parameters and 4-layer Transformer decoder for loop parameters), and a Loop Refiner for guantization offset regression. All hyperpa- rameters follow the specifications described in the original paper. Following their training setup, we supervise CAD sequence types, quantized parameters, and continuous offsets for 200 epochs.
we adopt the official open-source implementation and use their released pretrained codebook and model weights. Given the test CAD models, we convert them into the primitive-based representation adopted by HNC-CAD and formulate the task as a conditional generation problem. The predicted shapes are then evaluated using Chamfer Distance (CD) and Invalid Rate (IR) to assess geometric fidelity and modeling correctness.
HÑC-CAD: For HNC-CAD 13
SECAD:
For SECAD 44), we use the official implementation and pretrained model in their open- source repository for testing. Given input point clouds, the model reconstructs CAD shapes, which are evaluated using CD for geometric fidelity and IR for modeling validity.
we utilize the official open-source code and pretrained model to generate CAD models from input point clouds. As the method does not produce construction sequences, we evaluate its performance using CD and IR for fair comparison.
Point2Cyl: For Point2Cyl 13],
ExtrudeNet: For ExtrudeNet [14, since no pretrained model is provided, we train the model from scratch using the official codebase and follow their data preprocessing pipeline. The trained model used to reconstruct CAD shapes from input point clouds, which are evaluated using CD and IR.
26

---

B Additional Methodological Insights
B.1 Additional Details for Autoregressive Implicit Part Decomposition
In ParICAD, we perform implicit decomposition through an autoregressive scheme, enabling each part correspond to a procedural modeling action while conditioning on previous steps capture inter-part dependencies and avoiding the complexities of explicit geometric partitioning. Compared one-shot alternatives that attempt to generate all part latents simultaneously, this design yields more stable outputs and avoids premature or invalid part proposals. Although autoregression inherently reduces parallelism and may introduce error accumulation, we observed no significant drifting in practice, aided by explicit supervision from the part discriminator and strong geometric priors from rotation-guil -uuiddd projections. This design thus provides balanced trade-off between procedural fidelity and robustness, highlighting the value of autoregression as a principled mechanism for modeling sequential CAD construction processes.
B.2 Additional Details for Adaptive Point Cloud Projection
Projection
Sample
Points
Missing
Nearest Nelghbors
Captured
Grid Bampling
Projected
Duplicate
Watl-bitt Boundary
Boundary Points
Figure 9: A toy example of ry-plane projection of cylinder CAD shape.
While normal filtering effectively suppresses points that are mostly irrelevant to the design intent in the current projection view, it remains insufficient mitigate the clustering artifacts caused by projection distortion. In particular, points from side surfaces are often compressed toward projection boundaries, leading to over-concentration and reduced structural coverage. This degrades neighborhood quality in KNN-based aggregation and compromises the fidelity of geometric features.
To address this, we introduce an adaptive grid sampling strategy to spatially regularize the projection points. As illustrated in Figure 9 we visualize KNN neighborhoods for fixed sample points before and after grid sampling. Before processing, neighbors overly concentrated within local region, missing connections to global structural context. In contrast, grid-constraine resampling yields more spatially balanced neighborhoods, providing more geometric cues for downstream feature extraction. This strategy contributes to more reliable CAD instruction generation under projection guidance, as confirmed by ablation experiments.
B.3 Additional Details for Hierarchical KNN Aggregation Kernel
While Euclidean-based KNN is widely used for point cloud feature extraction 22
it often struggles in projection spaces where points from geometrically distinct surfaces become spatially adjacent after flattening, especially in complex assemblies with nested overlapping structures.
As illustrated Figure 10 (left), we provide a toy example by projecting a hollow cylindrical CAD shape onto the xy-plane. In this scenario, naive Fuclidean- KNN (Figure T0 middle) produces spatially adjacent yet structurally inconsistent neighborhoods, resulting in limited receptive fields and unstructured pattern aggregation.
27

---

20 Projection Plane
Limited Reception Fields
Broader Reception
X
Nested Structure
Unstructured Pattem
Projection Points
Euclidean distance-based KNN
Hierarchical kernei-based KNN
Figure 10: Euclidean distance-based KNN vs. hierarchical kernel-based KNN.
To address this, our hierarchical KNN aggregation kernel progressively refines neighhorhood selection based on spatial distance, radial constraint, and normal similarity (see Equation 2}. As shown in Figure [0 (right), compared to Auclidean-basee KNN, our method forms more semantically consistent neighborhoods with broader receptive fields, better capturing the global CAD structure even in nested regions. This improvement strengthens projection-based feature learning and improves downstream CAD instruction generation.
Additional Experiments
C.1 Additional CAD Modeling Visualization
To further illustrate the part-aware generation process of PartCAD, we present step-by-step modeling visualizations in Figure [T] We incrementally decode the predicted part latent sequence, where each latent generates
pair that corresponds to meaningful modeling operation. This process continues until an invalid latent is encountered, indicating the of the sequence. shown in the figure, PartCAD effectively extracts structural cues from the input point cloud and assembles complete CAD model through composition of part-wise instructions. It worth noting that for part latents associated with sketch-extrusion pairs involving Boolean operations such as join, and intersection, skipping the preceding solid construction steps can lead to modeling failures, as these operations rely on existing geometry to function properly.
In addition, we provide additional visualizations reconstructed models from the generated CAD instructions to demonstrate the robustness of PartCAD in handling complex modeling scenarios, as shown in Figure 12 and Figure I3 These examples highlight two representative challenges CAD reconstruction. Specifically, Figure T2 illustrates cases involving complex sketch structures, where the model successfully reconstructs detailed multi-contour and nested profiles. Figure [3) presents examples with complex topologies, including multi-bode assemblies and solid modeling operations (e.g., cut, join, or intersection). These visual results further demonstrate the effectiveness PartCAD in producing structurally coherent and geometrically faithful parametric CAD programs under diverse and challenging design conditions.
C.2 Additional Ablation Study on Point Cloud Quality
Impact of Surface Perturbations: Reverse engineering from noisy or imperfect 3D scans is a common challenge in real-world applications. To evaluate the robustness of PartCAD under such conditions, we simulate surface-level perturbations by injecting controlled Gaussian noise into the input point clouds. This setup mimics typical data acquisition errors observed in practical scenarios, such as sensor noise, surface jitter, or minor misalignments.
Specifically, we simulate surface perturbations by adding Gaussian noise independently to each coordinate of the input point cloud. Let p; 3 denote point in the raw point cloud, and its perturbed version P, is given by:
28

---

Input
Part Latent
Part Latent
Part Latent
Part Latent
Part Latent
Result
New
Cut
Gut
Cut
Gut
Input
Part Latent
Part Latent
Part Latent
Result
New
Join
Join
Figure 11: Visualization of part-wise latent decoding. Each column shows the cumulative result of decoding one additional latent, illustrating the progressive construction of the CAD model.
Figure 12: Qualitative visualization of reconstructed models with complex sketch structures. The examples highlight ParCAAD's s ability to recover intricate sketch layouts and maintain consistency across nested geometric constraints.
p: - C00,0'
(13)
Here, the noise is sampled independently for each point and each dimension. The standard deviation w is defined relative to the geometric scale of the point cloud as:
b Daax bmin
E.
(14)
100
29

---

Figure 13: Qualitative visualization of reconstructed models with complex topologies. These exam- ples showcase ParCAD's ability to handle multi-body relationships and solid modeling operations while maintaining structural coherence.
where ||baax bmiu| denotes the diagonal length of the axis-ali aligned bounding box (AABB) of the point cloud with { E [0.5, 1.0, 2.5, 5.0] controlling the relative noise intensity.
Figure 14 presents qualitative visualizations of reconstructed CAD models generated from perturbed point clouds. We observe that PartCAD maintains strong performance under low moderate per- turbation levels (c.g.. & = 0.5, 1.0, 2.5), successfully generating accurate and structurally consistent modeling instructions. Even under more severe noise conditions (e.g., { 5.0), the framework demonstrates notable resilience, producing plausible results that largely preserve the semantic and geometrie integrity the original shapes. These results suggest that ParCCAD is robust to realistic surface-level imperfections that commonly arise in practical 3D data acquisition settings.
Input
=
0.5
== 1.0
= =550
Input
{ =
{ 0.5
1-0
25
Input
t= 0.5
{=10 1.0
2=
(=5.0
Input
{ =
6-0.5
(=10
f-25
$=0.0
Figure 14: Qualitative visualization of reconstructed CAD models under different levels of Gaussian perturbation. We present four test examples from the DeepCAD dataset [42]. Each group of six columns corresponds to one test case. The first column shows the original input, with the raw input point cloud on top and the ground-truth CAD shape below. The remaining columns show results under noise levels & 0.5, 1.0, 2.5, and 5.0, where the perturbation applied independently each coordinate. The specific noise level used in each result is annotated above the corresponding column.
30

---

Impact of Partial Inputs:
To assess the robustness of PartCAD under incomplete geometric input, we conduct an ablation study by randomly removing portion of points from the imput point clouds, simulating partial observations such missing regions occlusions. Specifically, we evaluate on the test set of the DeepCAD dataset, where 5%, 10%, 25%, and 50% of points are randomly removed and the resulting degraded point clouds are used for parametric instruction generation.
Figure 15 presents qualitative visualizations of the reconstructed models under different levels of incompleteness. We observe that PartCAD maintains strong modeling performance under mild to moderate point removal, consistently generating well-structured and semantically coherent CAD models. In some more challenging cases, however, substantial point loss (e.g.. removal of 50% of input points) may obscure critical geometric cues, potentially resulting in degraded model quality or partial failure in instruction reconstruction.
Input
0%
5%
10%
25%
50%
Input
0%
5%
10%
25%
50%
Invli
Input
0%
5%
10%
25%
50%
Input
0%
5%
10%
25%
50%
Inslld
Qualitative visualization of reconstrueted CAD models under varying degrees of point removal. We present four test examples from the DeepCAD dataset [42]. The first column in each block shows the original input, with the input point cloud top and the ground-truth CAD shape below. The remaining columns show results under 5%, 10%, 25% and 50% point removal (red points are removed). The percentage of missing points indicated above each result.
Figure 15:
C.3 Additional Ablation Study Visualization
We present qualitative comparisons of different ablated variants in Figure I6 corresponding to the ablation study reported Section Compared to the full model, the ablated variants may produce imprecise modeling details
geometric distortions, incomplete structures, redundant components, (e.g., inaccurate extrusion distances). These issues highlight the importance of each module in ensuring accurate instruction generation and, therefore, faithful CAD modeling.
C.4 Additional Statistical Robustness Experiments
To validate the robustness of our method, we further assess its performance consistency under repeated inference. Since model parameters are fixed after training, the main source of variabil- ity lies in inference randomness and stochastic point resampling in the Chamfer Distance com- putation. To quantify this effect, we performed 10 independent inference runs without fixed ran- dom seeds and report the mean and standard deviation of the main metrics on DeepCAD and Fusion 360 Gallery datasets. The results Tables and 7 confirm that our method remains stable and robust under varying inference iterations.
Table 6: Experimental results on the Fusion 360 Gallery [12. measured in terms of median CD and
IR.
Median CD (x10*)
IR
Mean Std
1.144 0.041
1.321
0.194
31

---

Input
w/o Part Decomp.
w/o Proj. Guidance
w/o Adapt. Proj.
w/o Hiler.
w/o Local
Global
PartCAD (Full Model)
KNN
Feat. Aggreg.
Feat. Interact
Visualization ablation results. From left to right: input point cloud, reconstructed models by different ablated variants, and ground-truie truth CAD model. Each column shows the impact of individually disabling core component.
Figure 16:
Table Statistical results on the DeepCAD dataset 42 (Line, Arc, Circle) and extrusion parameters (Extrusion). CD (mean and median) for geometric fidelity, and IR for modeling validity.
report scores for sketch parameters
CD (x10²)
IR
Line
Arc
Cirele
Extrusion
Mean
Median
Mean
82.852
56.124 0,304
81.156
95.599 0.109
4.908
0.2373
0.911
Std
0.129
0.188
0.065
0.0009
0.038
D Failure Cases and Discussion
While PartCAD demonstrates strong performance in generating structured CAD models from point clouds, certain failure cases highlight the remaining challenges. We provide some representative failure cases in Figure 17 where ParCCAD successfully reconstructs the overall shape and topology but exhibits some local errors, such as geometric displacement (left), a missing part (middle). and an incomplete curved region (right). Based on our experiments, these issues arise from two primary factors. First, converting continuous design parameters into discrete numerical representations can lead to modeling precision loss, particularly in fine-grained or tightly constrained structures. Second, complex or highly detailed sketches, especially those involving nested or intricate contours, can challenge the model's is ability capture localized geometric features.
Input
GT
Ours
Input
GT
Ours
Input
GT
Ours
Deepaccment
Mosing
Incoppats Cures
Figure 17: Visualization of three failure cases. While the global structure is preserved, minor local emrors such as displacement, missing part, and incomplete profile can be observed.
Beyond the main contributions of this work, we also identify several insights that merit further discussion.
Modeling Ambiguity. In real-worke CAD design, a unique shape can be constructed through multiple valid modeling trajectories, reflecting diverse design philosophies and user preferences. Defining optimal puth typically requires additional criteria (e.g., minimizing sequence length, the number of exttcc-ettrusion pairs, or the use of specific primitives), which may diverge from natural human modeling habits. While current framework adopts deterministic decoding
32

---

strategy, generating distributional outputs that capture multiple plausible construction sequences remains a promising direction for future work. In addition, reward-based reinforcement learning paradigms may offer viable paths for addressing this challenge.
Intermediate representation. Decomposing a complex shape into simpler intermediate repre- sentations is widely accepted consensus in geometric learning, demonstrated in voxel- and point-related tasks [57] [58]. Beyond the implicit decomposition in ParCCAD, we also investi- gated more explicit schemes, such as bypass tasks that segment input points into semantically meaningful subsets or clustering parts based on feature similarity to provide stronger geometric grounding, but these efforts yielded only marginal (or no) accuracy gains while incurring ad- ditional computational and architectural complexity. However, we still believe that designing effective intermediate representations remains a promising direction, as a well-chosen abstraction could substantially simplify the generation of complex CAD modeling instructions.
Dataset Limitation. The size, diversity, and generalization capacity of high-quality datasets remain key bottleneck for building more powerful CAD generation models, especially when targeting complex modeling scenarios. For example, incorporating additional basic primitives (e.g.. free-form curves) together with richer modeling operations (c.g.. revolve, loft, chamfer) would allow trained models to better adapt to real-world design tasks, and several recent works have begun moving this direction [59]. Moreover, current datasets exhibit long-tail distributions in model part counts and may suffer from out-of-distribution issues (e.g., discrepancies in shape scale or complexity from real-scan) both posing significant challenges to robust generalization in practical applications. Our framework is naturally extensible to enriched datasets, and future work will aim to exploit larger-scale corpora to further strengthen robustness and real-world applicability.
33


Reviews:
[{"review_id": "FlqPf8oaEw", "reviewer": "Reviewer_ZqHg", "summary": "This paper introduces a semi-autoregressive framework that reconstructs instructions to compose CAD models given raw point clouds. The algorithm begins by embedding the inputs into part-specific latent codes. It incorporates the sketch information through a view-aligned triplane projections and decodes precise sketch-extrusion instructions non-autoregressively in a single forward pass. The results show good performance on DeepCAD and Fusion360 benchmarks.", "questions": "- Could the paper explicitly specify what $c_n$ is? What's the length of this vector? Is it dynamic/variable or always the same? \n- How is the BRep-Part correspondence modeled ? This is different than point cloud-part correspondence (asked earlier in weaknesses). A primitives-vs-part debate can be beneficial also.\n- What are the advantages disadvantages in using an autoregressive encoder with a direct decoder?\n- Why do we have a KNN-like clustering and not learning those 'hierarchical' operations?", "limitations": "Limitations are properly addressed. Although, the broader societal impact is not fully discussed.", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "### Strengths\n\n- I like that the paper sees sketch modeling as a guidance and brings tools from 3D generative modeling like triplanes. \n- The non-autoregressive decoder is probably efficient and can bring some internal consistency.\n-  The guidance fuses part-level semantics with local/global point features and can help getting good accuracy.\n- The paper demonstrates good performance in standard datasets. \n\n### Weaknesses\n\n- The introduction argues for structure and hierarchy but most of the contribution in this regard is in part modeling. This seems to be a common theme in the literature but is definitely simplistic. 3D models are so much more than parts. They are compositions of simple-to-complex primitives, each of which can have or not have a semantic meaning. Parts are only some of those basis functions. I think those claims should be tuned down and adjusted to the actual contributions.\n\n- The idea of using different latent codes for parts is not new at all. In particular, it has been explored and popularized for example by the 3D capsule networks. I would suggest that the paper cites and explicitly mentions these:\n  * Zhao et al. \"3D point capsule networks.\" CVPR 2019.\n  * Dubrovina et al. \"Composite shape modeling via latent space factorization.\" ICCV 2019. \n\n- The paper explicitly focuses only on sketch-extrude type models and utilizes sketches that are composed only of lines, arcs and circles. Although these constitute most of the operations / primitives, it is very unlikely that a single CAD model exists that is composed only of those operations / primitives. Recent CAD modeling tools have much more coverage and less restrictions than what is proposed here. This includes CAD-Recode (not cited): \n  * Rukhovich et al. \"CAD-Recode: Reverse Engineering CAD Code from Point Clouds\". arXiv:2412.14042.\n\n- Speaking of parts in CAD models is interesting. We can segment the point cloud into parts but in a CAD model, primitives can belong to different parts causing non-uniqueness or inconsistencies. It seems like there is no explicit treatment of this in the current paper. Could the authors elaborate on how the model handles these cases?\n\n- I see that the overall pipeline is similar to Point2Cyl, except that a rather new toolset is used. I think the paper should discuss similarities / differences. In particular, how the discrete state of tokens would compare to a continuous model as in Point2Cyl is certainly interesting. \n\n- The method is counter-intuitive to me. This is not negative per se but requires clarification. I would expect that the point latents are generated by a one-step encoder whereas the decoder could be auto-regressive (like in LLMs). Why does the paper argue for the reverse? What are the advantages disadvantages? The paper gives some explanations but not a comparative one.\n\n- Rotations are regressed over the discrete tokens. Wouldn't this cause problems / errors? I feel like all canonicalizations would be a bit off. \n\n- What about the CC3D-ops dataset which contains longer (operation) sequences? I think we have more datasets to evaluate on compared to DeepCAD and Fusion360 now. \n\n- The evaluation metrics are fine but at this stage I would really recommend adopting a CAD-aware loss that is evaluated on instructions / operations and their parameters. This would be a true 'program-distance', that characterizes how effort is needed to turn a sequence of operations into another one.\n\n- In Table 1, I think Point2Cyl can be included as their sketches are more general and can be easily parsed into arcs/lines etc. \n\n- Real scan experiments are limited to qualitative ones. Can we have some quantitative evaluations for known CADs?\n\n- The checklist claims that the error bars included, however non of the tables or plots provide error bars, and authors ask the reader to 'trust' their experience that the results are stable. This is unacceptable to me. My current rating is 4 but if the rebuttal does not address this, I will be lowering the score.", "was_revised": true, "final_justification": "I thank the authors for addressing the concerns. I maintain my score of acceptance.", "rebuttal": "We sincerely thank you for the thorough review and constructive feedback. We appreciate your thoughtful questions that will help improve our work. Below are our responses to your concerns, along with additional clarifications.\n\n---\n\n**W.1/W.4/Q.2: Structure, Parts, and CAD Modeling**\n\nWe appreciate your point about 3D structural complexity. Our work specifically targets the procedural structure inherent to CAD modeling workflows, where part-wise decomposition provides a tractable abstraction that aligns well with standard CAD practices. Each \"part\" in our context represents a meaningful modeling step (sketch-extrusion pair) that captures design intent rather than purely geometric segmentation.\n\nWe perform implicit decomposition through autoregressive latent generation, allowing each part to naturally correspond to procedural modeling actions while avoiding the complexities of geometric partitioning. Through our experiments, we found this implicit formulation more effective and scalable than explicit segmentation approaches. We will revise the introduction to better articulate this CAD-specific scope and procedural focus.\n\n---\n\n**W.2/W.5: Related Work and Comparisons**\n\nThank you for highlighting these important references that we missed. We will include them in the revision, as they provide valuable context for part-based latent modeling. Our work focuses specifically on procedural CAD sequence generation rather than static shape analysis or segmentation. Regarding Point2Cyl, our approach takes a different direction. We generate structured instruction sequences using discrete tokens aligned with formal grammar, ensuring syntactic validity and semantic interpretability. Point2Cyl, in contrast, fits continuous cylinders using implicit functions, without the symbolic structure needed for procedural modeling. We will include a more detailed comparison highlighting these complementary approaches.\n\n---\n\n**W.3: CAD Operation Coverage**\n\nYou raised an important point about our current scope. We acknowledge that real CAD models typically involve more operations and primitives. Our current work focuses on sketch-extrusion operations that constitute the majority of parametric CAD workflows, but this is indeed a limitation we should discuss. We appreciate the pointer to CAD-Recode and will cite it along with a discussion on extending to broader CAD operations. Our framework is designed to be extensible to richer operations (sweeping, lofting) and sketch primitives (splines, complex curves) given appropriate training data, which we plan to pursue in future.\n\n---\n\n**W.6/Q.3: Autoregressive Design Choice**\n\nWhile global features are extracted in a single pass using a standard encoder, part latents are generated autoregressively to reflect the sequential nature of CAD modeling, allowing each part to condition on previous ones and capture inter-part dependencies consistent with real-world workflows. We did explore one-shot alternatives that generate all latents simultaneously, but observed reduced performance and less stable outputs, particularly with premature or invalid part generation. While autoregression does reduce parallelism and could potentially introduce error accumulation, we found minimal runtime overhead in practice and no significant output drift thanks to the supervision from our Part Discriminator. We will include a more detailed discussion of this design trade-off in our revision.\n\n---\n\n**W.7/W.8: Discretization and Datasets**\n\nDiscretization does introduce quantization error, but we found this trade-off worthwhile as it significantly improves training stability compared to direct regression approaches. The discrete formulation also enables more structured supervision and token-based evaluation. Regarding datasets, we focused on current datasets to maintain consistency with prior work. They contain complex samples with long, hierarchical sequences, suitable for testing our method's robustness. We appreciate the suggestion about CC3D and are currently applying for access to include it in future evaluations.\n\n---\n\n**W.9: CAD-Aware Evaluation**\n\nWe agree that CAD-aware evaluation is crucial. Our framework does integrate CAD-aware design in both training and evaluation. During training, we supervise both geometric parameters and structural/semantic tokens that encode high-level CAD concepts like boundary markers and Boolean operations using cross-entropy loss. Our evaluation goes beyond pure geometry through token-level F1-scores that assess both low-level parameters and high-level instruction structure.\n\n---\n\n**W.10/W.11: Point2Cyl Comparison and Real Scan Evaluation**\n\nWe excluded Point2Cyl from instruction-level comparison because its outputs use continuous implicit representations rather than discrete symbolic primitives. While its 2D sketches may visually resemble our primitives, they're defined through fitted parameters rather than explicit modeling commands. Post-hoc parsing into symbolic tokens is possible but often unreliable. For real-world scans, our evaluation is primarily qualitative, as most real scan datasets unfortunately lack the high-quality parametric CAD annotations needed for rigorous quantitative comparison. We plan to curate more scan-CAD pairs with parametric labels for future research.\n\n---\n\n**W.12: Statistical Rigor and Error Reporting**\n\nWe sincerely apologize for the mismatch in our checklist, which was our oversight. You’re absolutely right that empirical results should be supported by proper statistics. Since model parameters are fixed after training, variability primarily arises from inference randomness and stochastic point sampling in the Chamfer Distance computation. To address this concern, we conducted 10 independent inference runs without fixed random seeds and computed mean and standard deviation for the main metrics (see the following 2 tables). Our original experiments followed strict protocols: consistent data splits, fixed training seed, dataset deduplication, and full implementation details (see Section 4, Appendix A.2–A.3). We acknowledge the importance of reporting statistical variation. We will include error bars and statistical analysis in the final version and sincerely appreciate your attention to this crucial issue.\n\n---\n\n**Table: Experiments in DeepCAD Dataset**\n\n| Instance | F1 Line | F1 Arc | F1 Circle | F1 Extrusion | Mean CD | Median CD | IR   |\n|----------|---------|--------|-----------|--------------|----------------|-----------|------|\n| 1        | 82.97   | 56.66  | 80.79     | 95.62        | 4.87           | 0.238     | 0.89 |\n| 2        | 82.71   | 56.28  | 81.35     | 95.63        | 4.91           | 0.236     | 0.90 |\n| 3        | 82.64   | 55.76  | 81.11     | 95.68        | 4.89           | 0.238     | 0.86 |\n| 4        | 82.96   | 56.22  | 81.31     | 95.78        | 4.99           | 0.237     | 0.92 |\n| 5        | 82.93   | 55.76  | 81.14     | 95.59        | 4.84           | 0.238     | 0.95 |\n| 6        | 82.66   | 55.88  | 81.49     | 95.54        | 4.89           | 0.237     | 0.97 |\n| 7        | 82.85   | 56.48  | 81.04     | 95.44        | 4.80           | 0.237     | 0.93 |\n| 8        | 83.01   | 56.37  | 81.15     | 95.69        | 4.97           | 0.237     | 0.95 |\n| 9        | 82.94   | 55.96  | 80.99     | 95.40        | 4.90           | 0.236     | 0.85 |\n| 10       | 82.85   | 55.87  | 81.19     | 95.62        | 5.02           | 0.239     | 0.89 |\n| **Mean** | 82.852  | 56.124 | 81.156    | 95.599       | 4.908          | 0.2373    | 0.911 |\n| **Std**  | 0.1290  | 0.3040 | 0.1875    | 0.1086       | 0.0645         | 0.0009    | 0.0378 |\n\n---\n\n**Table: Experiments in Fusion360 Dataset**\n\n| Instance | Median CD | IR   |\n|----------|------------------|------|\n| 1        | 1.15             | 1.63 |\n| 2        | 1.08             | 1.09 |\n| 3        | 1.14             | 1.51 |\n| 4        | 1.16             | 1.48 |\n| 5        | 1.11             | 1.42 |\n| 6        | 1.22             | 1.20 |\n| 7        | 1.10             | 1.46 |\n| 8        | 1.13             | 1.08 |\n| 9        | 1.15             | 1.27 |\n| 10       | 1.20             | 1.07 |\n| **Mean** | 1.144            | 1.321 |\n| **Std**  | 0.0408           | 0.1942 |\n\n---\n\n**Q.1: Instruction Format Details**\n\nCAD modeling instructions are structured as $C = ${$c_n $}$_{n=1}^N$, where $N$ is the sketch–extrusion pairs. Each instruction consists of sketch and extrusion components, both quantized as 8-bit discrete sequences (see Section 3 and Appendix A.1). The sketch component has variable length depending on the number of 2D primitives and structural boundary tokens, while the extrusion component is fixed at 11 tokens covering orientation, position, scale, depth, and Boolean operations. For parallelization and efficient training, each instruction sequence is padded to a fixed length of 110 tokens, which covers all samples in our current dataset.\n\n---\n\n**Q.4: Hierarchical KNN Design Rationale**\n\nThe hierarchical KNN aggregation serves as an intermediate step for selecting reliable neighborhoods among 2D projection points, which are then processed by learnable encoders (EdgeConv layers). This design augments learning with geometric priors rather than replacing it entirely. It is motivated by the observation that important CAD structures (sketch profiles, extrusion contours) exhibit locally coherent patterns in projection views. Our hierarchical KNN applies three-stage refinement considering spatial proximity, radial alignment, and surface normal similarity to identify geometrically consistent regions that correspond to underlying modeling processes. This helps the encoder learn more robust features for CAD instruction generation."}, {"review_id": "9EcGVDFlew", "reviewer": "Reviewer_6YMg", "summary": "This paper proposes an autogressive part decomposition based pipeline for learning CAD Modeling Sequences. Central to the pipeline is an autoregressive encoder-decoder module that decomposes an input point cloud in to a sequence of part-level latent features. These features are combined (with some attention mechanism) with triplane projection guidance refined from projected point clouds, are then decoded into per part parameters which form the final CAD program. Qualitative examples and quantative numbers demonstrate that the proposed method clearly outperforms a couple well-known baselines for this problem.", "questions": "My main concerns for the paper centers around how generalizable and extendable this pipeline is. Granted, the key design is proven to work for the particular dataset and test cases, but I am very unsure whether this will work in more general cases, for the following reasons:\n\n1. also branded as \"autoregressive\", the part decomposition pipeline lacks an explicit intermediate geometry representation, and instead just conditions on the previously generated latents. This, while fine for a bunch of coarse objects, can lead to problems when there exist fine grained geometries that require a sequence of precise operations. Moreover, as the sequences grow longer, it will be increasingly more difficult to reason about the part latents (especially when there are operations other than union) and the entire shape (and figure out what is left). Granted, the discriminator alleviate this a bit, but I still feel that a more principled solution is needed.\n2. A related issue is that without intermediate correction and geometry representation, there can be potentials for error accumulation / drifting as the sequences grow longer. I didn't notice this too much in the provided examples, but still, more concrete analysis might help more.\n3. CAD construction sequences are inherently ambiguous, and muliple paths exist for each shape. It seems very challenging for the current pipeline to handle this --- even if it is theoretically possible, I do suspect that the current method relies very strongly on similar examples seen in the training data, and will have issue in exploring other possible sequences, more so due to the unclear capacity of the decoder to actually perform geometric reasoning. Granted, this might not be an issue on common shapes with enough high quality data, but this might cause problems for other complex shapes that lack enough data (e.g. the hexagonal ring in Figure 7)\n4. Step 3 also relies heavily on the quality of step 1 decompositions. If CAD instructions acutally need to span across parts identified in step 1, I don't think the current method can handle this. In other words, I think the method is kinda equivalent to a single step autoregressive part-by-part CAD decoder, just with projection features being injected in the middle of the layers.\n\n\nI am still positive on the paper because it is effective for the current set of test cases. But explaning / providing insights to the questions above would further strengthen my take on this paper.", "limitations": "Yes", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 2, "strengths_and_weaknesses": "Strengths:\n- Well engineered pipeline that delivers results that clearly outperforms relevant works. Many design choices clearly shout considerable effort in exploring possible design choices e.g. the steps used to refine the projected triplane features (ablations show that without these refinements, such projections don't help) and the specific use of attention in fusing the part latents and the geometric features.\n- While the main paradigm (autoregressive decoding) and the particular model designs are fairly standard, the paper shows that with the right kind of data, feature representations and scaling (8 A100), such a pipeline can achieve very reasonable performances on this particular tasks without further, more complex inductive biases.\n- Comprehensive evaluations, ablations and discussions.\n\nWeaknesses:\n- Novelty mainly lies in the way the components are combined (particularly, how and where to inject projection guidance), but the techniques used in the 3 main steps are all fairly standard, and thus limiting the novelty of the work a bit.\n- Seems to have a strong reliance on having high quality training data in large scale, unclear if this paradigm is generalizable to more long-tailed part of the distribution (see questions)\n- Many cad shapes naturally have ambiguity / multiple ways in how they are constructed. The current pipeline does not appear to have the capacity of handling that, and in addition, might suffer from drifting and other common issues of an autoregressive model due to the lack of an explicit intermediate geomtric representation.", "was_revised": true, "final_justification": "I still have concerns, sure. But this is a good paper and should be accepted. (will keep the 4 but this is close to a 5)", "rebuttal": "We greatly appreciate your detailed and thoughtful evaluation. Your positive assessment of our pipeline design, projection features, attention mechanisms, and comprehensive ablation studies is highly valued. Below we address your insightful concerns with additional clarifications.\n\n---\n\n**W.1: Technical Novelty and Integration**\n\nWhile individual modules do build upon established techniques,  our main contribution lies in their thoughtful integration to address CAD-specific challenges. Our novelty centers on: (1) autoregressive part decomposition that produces interpretable, structure-aware latents as semantic anchors; (2) projection guidance that injects design-intent-aware features through rotation-guided triplane projections; and (3) non-autoregressive parameter decoding that efficiently generates sketch-extrusion instructions while preserving consistency. This cohesive design has demonstrated effectiveness and contributes to more interpretable CAD generation.\n\n---\n\n**W.2/W.3/Q.3: Model Generalization and Data Dependency**\n\nYou raised excellent points about data dependency. We acknowledge that high-quality data plays an important role, as in most deep learning domains. However, our framework goes beyond template memorization through structured part-wise decomposition and projection-guided decoding, offering generalization beyond replicating training sequences. We performed careful deduplication to prevent data memorization and ensure that the model doesn't rely on near-identical examples. As shown in Figure 1 (main paper) and Figures 12-13 (Appendix C.2), our method successfully reconstructs diverse shapes with complex sketch structures and intricate topologies, demonstrating robustness across various design variations, though extremely complicated configurations remain challenging.\n\n---\n\n**W.3/Q.3: Construction Ambiguity and Modeling Diversity**\n\nWe acknowledge that construction path ambiguity is a fundamental challenge in procedural CAD modeling, as the same geometry can often be constructed through different valid instruction sequences. Addressing such ambiguity often requires specifying some optimal criteria (e.g., minimizing sequence length, the number of sketch–extrusion pairs, or the use of curve primitives), which may diverge from natural human modeling habits. Rather than enforcing a single canonical path, our work focuses on how to effectively generate valid instruction sequences for the given shape. While our current framework employs a deterministic decoding strategy, future work will aim to model this ambiguity explicitly and explore criteria for defining optimal or human-aligned construction sequences.\n\n---\n\n**W.3/Q.1: Intermediate Representations and Structural Supervision**\n\nWe appreciate your insightful comments regarding the intermediate representations. In our current design, we adopt an autoregressive implicit part decomposition strategy conditioned on both the 3D point cloud features and previously generated latents. This approach is inspired by the incremental nature of CAD modeling, where even operations like Cut or Intersect can be viewed as negative geometric increments. To guide the decomposition process, we employ a Part Discriminator that evaluates the validity of each generated latent and provides supervision during training. Beyond this core motivation, we would like to share two of our experiences.\n\nFirst, for explicit intermediate representations, two common forms are part-level point cloud segments or part-specific point cloud features. We experimented with bypass tasks (e.g., part-level segmentation) to incorporate more structured intermediate cues. However, these efforts yielded only marginal gains in accuracy and came at the expense of increased computation and framework complexity. As a result, we opted for a more flexible implicit decomposition strategy coupled with part validity supervision, which has proven effective across a wide range of CAD modeling scenarios.\n\nSecond, regarding the autoregressive generation strategy, we also experimented with one-shot approaches that generate all part latents from the input point cloud in a single forward pass. However, we observed lower performance and frequent discontinuities in latent generation (e.g., premature invalid part latents). \n\nDespite these experiences, we recognize the importance of intermediate representations and will continue to explore more effective and efficient mechanisms to incorporate them into future iterations of our PartCAD framework.\n\n---\n\n**W.3/Q.2: Autoregressive Generation and Error Accumulation**\n\nWe agree that error accumulation or drifting is a common challenge in purely autoregressive frameworks. In our preliminary experiments, we observed this issue when extending the autoregressive formulation to the CAD instruction generation stage (i.e., directly generating the sequence tokens). As discussed in W.3/Q.1, introducing more explicit intermediate representations helps alleviate this issue by providing stronger geometric grounding. Beyond that, we also explored feature-level solutions, such as similarity-based mechanisms for distinguishing part latents, but they yielded limited gains.\n\nIn our current setup, where autoregression is applied only to the part decomposition stage, we did not observe significant drifting effects in our experiments, as evidenced by both quantitative results and visual reconstructions. In addition, several design choices help mitigate this issue. The Part Discriminator provides explicit supervision to guide the generation of valid parts and suppress the propagation of invalid latents. The rotation-guided projection introduces strong geometric priors during instruction decoding, while the localized and structured nature of sketch loops offers further geometric constraints across parts.\n\n---\n\n**Q.4: Cross-Part Operations and Decomposition Dependencies**\n\nWe understand your concern regarding potential limitations of the decomposition and decoding strategy and would like to provide the following clarification.\n\nFirst, in typical CAD modeling workflows, any cross-part operations (e.g., Join, Cut, or Intersect) are generally performed after a base body has been created. This modeling paradigm is also strictly followed in all CAD sequences within the DeepCAD dataset. Our framework explicitly models each CAD part as a sequence of sketch–extrusion pairs, with each part latent independently decoded into its corresponding instruction sequence. Each sketch–extrusion pair represents a complete and self-contained solid modeling operation (e.g., Newbody Creation, Cut, Join, Intersect). Importantly, these operations are executed incrementally and can only act on geometry that has already been constructed up to that point. No instruction is allowed to depend on future parts or not-yet-created geometry. This paradigm adheres to standard CAD modeling conventions and is consistent with the behavior of commercial CAD systems.\n\nSecond, while the final CAD instructions in our framework are generated in a single forward pass, the parameter decoder leverages both local 2D projections and global 3D context. The global context is encoded via autoregressively generated part latents, which inherently capture structural dependencies between each modeling step. This design enables geometry-aware and part-specific predictions by modeling both intra-part details and inter-part relationships.\n\nWe acknowledge the existence of certain scenarios (like lofting operations requiring simultaneous access to multiple parts) that fall beyond our current scope, and we're interested in developing hybrid formulations for more complex inter-part constraints in future work."}, {"review_id": "BLFw0IC9FG", "reviewer": "Reviewer_817B", "summary": "The paper introduces PartCAD, a semi-autoregressive framework that takes point cloud as input and generates structured CAD modeling instructions. Given a global point cloud feature, it first generates part latents in auto-regressive manner. The part latents are then used to form projected point features to guide the generation of CAD instruction parameters.", "questions": "See strengths and weaknesses section.", "limitations": "Yes.", "rating": 5, "confidence": 2, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 3, "strengths_and_weaknesses": "I am not too familiar with the task, dataset, and related works. Reading the paper, I appreciate the following strengths:\n1. The paper is relatively clear. The figures help to understand the proposed method. I also appreciate the output representation is explained in the Appendix.\n2. The effectiveness of each components in the proposed method: 1). Part awareness decoding, 2). Projection guidance, 3). Instruction generation are systematically ablated.\n3. Results show superior results. The authors also include results from real-world 3D printed CAD models.\n\nI do not see any major weakness from the paper. There are some parts that I am not too clear:\n1. Referring to Figure 3, in the part latent decomposition, the part latent is decoded into 3D point clouds which are then projected into three canonical planes according to the orientation of each part. How is the decoding process and how is the 3D point cloud supervised? Also, how is the rotation for each part supervised? Does the dataset provide such information?\n2. From the results, it seems the CAD models are rather simplistic, e.g., mostly are brackets with only a few sketches and extruded components. How about CAD models with complex shapes and a lot of holes? Is it limited by DeepCAD dataset or there are underlying challenges to reconstruct complex CAD models? e.g., long generation sequence resulting in error accumulation or model capacity. What is the highest number of part latents the proposed method can generate?", "was_revised": true, "final_justification": "I have read the authors' rebuttal and other reviewers' comments. My stance remains the same regarding the novelty and that I do not see any major weakness in the paper.", "rebuttal": "We sincerely appreciate the time and effort you devoted to reviewing our work. We are glad that you found the overall structure clear and that the figures and appendix supported the presentation effectively. Thank you for your positive comments on the design and evaluation of key components, including the part-aware decoding, projection guidance, and instruction generation, as well as your recognition of the real-world reconstruction results. Below please find the responses to the two points you raised for clarification.\n\n---\n\n**W.1: Part Latent Decomposition Process and Supervision**\n\nWe respond to this question in three aspects:\n\n(1) Part Latent Decomposition and Decoding: As described in the Autoregressive Implicit Part Decomposition part of Section 3, the input 3D point cloud is encoded and autoregressively decoded into several part latents via a part decoder (implemented as a four-layer Transformer). These part latents serve three purposes: (i) guiding final instruction generation, (ii) providing rotation cues for projection, and (iii) being supervised for part validity.\n\n(2) Orientation Prediction and Supervision: Each part latent is fed into the Orientation Predictor (implemented as a single-layer MLP) to estimate its rotation parameters, which guide the subsequent projection onto canonical planes. The predicted rotations are supervised using a cross-entropy loss ($L_\\text{rot}$) computed from the ground-truth orientation parameters (Euler angles).\n\n(3) Validity Supervision: To supervise the implicit decomposition of the 3D point cloud, a Part Discriminator (implemented as a one-layer MLP) predicts the probability that each part latent corresponds to a valid part. A binary cross-entropy loss $L_\\text{val}$ is computed between these predictions and the ground-truth validity labels.\n\nThe supervision details for both rotation and validity are described in the Optimization part of the Section 3 and all supervision signals (including rotation parameters and part validity one-hot labels) can be directly obtained from the dataset.\n\n---\n\n**W.2: Model Complexity and Scalability**\n\nBeyond the qualitative results presented in Figures 5–6 of the main paper, we also provide further examples in Figure 1 and Figures 12–13 (Appendix C.1), showcasing reconstruction results for CAD models with complex sketch structures and topologies. These examples highlight PartCAD’s capability to recover intricate sketch layouts and handle multi-body relationships and solid modeling operations. While longer instruction sequences may introduce greater prediction uncertainty, we have not observed significant error accumulation in practice. Empirically, modeling difficulty is influenced more by geometric complexity than by the number of part latents. For example, a geometrically complex single-part model can pose greater challenges than a multi-part assembly of simpler components.\n\nAs detailed in the Implementation Details part of Appendix A.1, our current experimental setup supports up to 10 part latents (i.e., sketch–extrusion pairs) per CAD model. Each part latent can include up to 6 sketch loops, with each loop consisting of at most 15 curve primitives. This configuration covers all modeling cases in the DeepCAD dataset."}, {"review_id": "8TbhvFcL1y", "reviewer": "Reviewer_yQun", "summary": "This paper introduces PartCAD, a semi-autoregressive framework designed to reconstruct CAD modeling sequences from 3D point clouds. The approach consists of (1) decomposing point clouds into part-aware latent representations; (2) a projection guidance module leveraging triplane projections to encode design intent; and (3) a non-autoregressive decoder that synthesizes sketch-extrusion parameters efficiently.", "questions": "1- Can you generate the CAD from sketch or image insdeat of point-cloud?", "limitations": "1- Real-world applicability may be limited if input point clouds are very noisy or incomplete beyond tested scenarios.\n\n2- The current implementation does not address ambiguity in the mapping from geometry to modeling sequence, nor does it quantify uncertainty or propose mechanisms to generate alternative plausible sequences.", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 2, "significance": 2, "originality": 3, "strengths_and_weaknesses": "# Weaknesses\n1- Limited Scope of CAD Operations: The approach is primarily demonstrated for sketch-extrusion-based CAD modeling. More complex operations (e.g., sweeps, lofts, free-form surfaces) or richer command vocabularies are not addressed, limiting generality.\n\n2- One-to-Many Mapping: The authors acknowledge the inherent ambiguity in mapping geometry to command sequences, but the paper offers little in terms of handling multi-modality or uncertainty (e.g., via distributional outputs or probabilistic modeling).\n\n3- Limited exploration of alternative representation: The work is positioned between CSG, B-Rep, and sequence models but does not provide much insight on where it best fits, or its limits compared to modern neural B-Rep/CSG generative models.\n\n# Strengths\n1- Technical Contributions: The part-wise decomposition and projection-guided features are well-motivated. The semi-autoregressive architecture, especially the use of triplane projections and a hierarchical KNN kernel for better local feature aggregation, appears novel within this context.\n\n2- Ablation Studies: The ablations highlight the necessity of the major architectural components, strengthening the empirical case for the proposed design.", "was_revised": true, "final_justification": "The authors have addressed my concerns, and the paper is very interesting and makes a significant contribution to AI and CAD. I am happy to increase my score.", "rebuttal": "Thank you for your careful assessment and recognition of our novel contributions, such as the semi-autoregressive architecture, part-wise decomposition, triplane projection guidance, and hierarchical KNN aggregation. We appreciate your acknowledgment of our technical soundness and clear ablation studies. Please find below our responses to your concerns, organized by weaknesses, questions, and limitations.\n\n---\n\n**W.1: Limited Scope of CAD Operations**\n\nWhile our experiments focus on sketch-extrusion operations (that constitute the majority of parametric CAD workflows), our framework is inherently operation-agnostic. The core contribution lies in projection-guided, part-aware geometry reasoning, which readily extends to other operations such as sweeping and lofting. Our approach introduces a learnable mapping from geometric features to modeling instructions that is not constrained to specific operation types. Extending to sweeps or lofts would require expanding the instruction vocabulary and incorporating additional primitives (guided curves, profiles), but the fundamental projection-guided reasoning and part-aware decomposition principles remain directly applicable.\n\n---\n\n**W.2 / L.2: One-to-Many Mapping and Ambiguity Resolution**\n\nYou raised an insightful point about the inherent ambiguity in geometry-to-sequence mapping. As discussed in the Limitation section of the main paper, multiple valid construction paths often exist for the same geometry, reflecting different design philosophies and modeling preferences.\n\nOur current deterministic decoding validates the proposed framework, but we recognize this limitation. In preliminary investigations, we found that resolving ambiguity requires defining optimization criteria (e.g., minimizing sequence length, the number of sketch-extrusion pairs, or the use of sketch primitives). However, these may not align with real-world practices, where experienced designers often prefer multiple simple operations over single complex ones for clarity and reusability.\n\nWe strongly agree with your suggestion on distributional outputs. Generating multiple plausible instruction paths represents a promising direction that could provide designers with meaningful alternatives while preserving semantic richness. This could involve variational architectures, mixture models, or beam search strategies to explore valid reconstruction sequences.\n\n---\n\n**W.3: Alternative Representation Exploration**\n\nOur work is strategically positioned within sequence modeling to reconstruct procedural CAD instructions from point clouds. Unlike neural B-Rep approaches (explicit surfaces/topology) or CSG methods (Boolean primitives), our sequential representation captures the temporal and logical structure of the modeling workflow itself. \n\nThis distinction is crucial, as we preserve not just geometric outcomes but procedural knowledge of how geometry was constructed. Sequential representations naturally support part-level modifications, constraint editing, and design iteration workflows fundamental to parametric CAD practice.\n\nOur experiments also demonstrate competitive accuracy against recent fitting-based methods, further validating the practical effectiveness of our framework. Finally, the instruction representation can be straightforwardly compiled into B-Rep or CSG forms for compatibility with existing CAD engines, whereas the reverse conversion remains under-constrained and not directly attainable.\n\n---\n\n**Q.1: Alternative Input Modalities**\n\nWhile our current work focuses on point cloud inputs for implicit part decomposition and projection-guided decoding, the framework is flexible. Core ideas of part-wise decomposition and projection-guided reasoning can extend to sketch or image inputs through modality-specific encoder adaptations. In particular, the projection-based decoding design is well-suited for integration with 2D sketch or image features. Such extensions would significantly broaden practical applicability for reverse engineering and design digitization.\n\n---\n\n**L.1: Real-World Point Cloud Challenges**\n\nWe acknowledge that noisy or incomplete point clouds are common in real-world applications. In our main paper (Section 4) and Appendix C.3, we evaluate the robustness of our method through real-scan experiments (using data from consumer-level 3D scanner), along with systematic tests involving surface perturbations (to simulate noise) and partial inputs (to simulate occlusion or incompleteness). The results show that our framework remains effective under such challenging conditions."}]

Author rebuttal:

Meta-review: This paper introduces a part-aware framework that reconstructs CAD instructions from raw point clouds. The algorithm first embeds the inputs into part-specific latent codes. It decodes precise sketch-extrusion instructions non-autoregressively in a single forward pass. The results show good performance on DeepCAD and Fusion360 benchmarks. 

All reviewer were positive before the rebuttal. The authors addressed minor issues raised by the reviewers during rebuttal. The scores remain positive after rebuttal. There is consensus that this paper should be accepted. The AC agrees with this decision.
Decision: Accept (poster)