Seek-CAD: A Self-refined Generative Modeling for 3D Parametric CAD Using Local Inference via DeepSeek
Authors: Xueyang Li
Jiahao Li
Yu Song
Yunzhong Lou
Xiangdong Zhou
Venue: ICLR 2026 Poster (2026)
Keywords: CAD generative modeling; parametric CAD sequence;
Primary area: applications to computer vision, audio, language, and other modalities

Abstract: The advent of Computer-Aided Design (CAD) generative modeling will significantly transform the design of industrial products. The recent research endeavor has extended into the realm of Large Language Models (LLMs). In contrast to fine-tuning methods, training-free approaches typically utilize the advanced LLMs, thereby offering enhanced flexibility and efficiency in the development of AI agents for generating CAD parametric models. However, the lack of a mechanism to harness Chain-of-Thought (CoT) limits the potential of LLMs in CAD applications. The Seek-CAD is the pioneer exploration of locally deployed inference LLM DeepSeek-R1 for CAD parametric model generation with a training-free methodology. This study is the investigation to incorporate both visual and CoT feedback within the self-refinement mechanism for generating CAD models. Specifically, the initial generated parametric CAD model is rendered into a sequence of step-wise perspective images, which are subsequently processed by a Vision Language Model (VLM) alongside the corresponding CoTs derived from DeepSeek-R1 to assess the CAD model generation. Then, the feedback is utilized by DeepSeek-R1 to refine the initial generated model for the next round of generation. Moreover, we present an innovative 3D CAD model dataset structured around the SSR (Sketch, Sketch-based feature, and Refinements) triple design paradigm. This dataset encompasses a wide range of CAD commands, thereby aligning effectively with industrial application requirements and proving suitable for the generation of LLMs. Extensive experiments validate the effectiveness of Seek-CAD under various metrics.

Published as a conference paper at ICLR 2026
SEEK-CAD: A SELF-REFINED GENERATIVE MODEL- ING FOR 3D PARAMETRIC CAD USING LOCAL INFER- ENCE VIA DEEPSEEK
Xueyang Li Jiahao Li"; Yu Song', Yunzhong Lou', Xiangdong I
CCollege of Computer Science and Artificial Intelligence, Fudan University, Shanghai, China School of Information and Intelligent Science, Donghua University, Shanghai, China [xueyangli21, 2511 2511300 55113050261 songy23) @m. fudan. edu. on (yzlou20, xdzhou? @udan.. enu.cn
ABSTRACT
The advent of Computer-Aided Design (CAD) generative modeling will signifi- cantly transform the design of industrial products. The recent research endeavor has extended into the realm of Large Language Models (LLMs). In contrast fine-tuning methods, training-free approaches typically utilize the advanced LLMs,, thereby offering enhanced flexibility and efficiency in the development of Al agents for generating CAD parametric models. However, the lack of a mechanism to harness Chain-of-Thought (CoT) limits the potential of LLMs in CAD applications. The Seek-CAD is the pioneer exploration of locally deployed inference LLM DeepSeek-R for CAD parametric model generation with training- ffeee methodol- ogy. This study is the investigation to incorporate both visual and CoT feedback within the self-refinement mechanism for generating CAD models. Specifically, the initial generated parametric CAD model is rendered into a sequence of step-wise perspective images, which are subsequently processed by a Vision Language Model (VLM) alongside the corresponding CoTs derived from DeepSeek-RI to assess the CAD model generation. Then, the feedback is utilized by DeepSeck-Rl to refine the initial generated model for the next round of generation. Moreover, we present an innovative 3D CAD model dataset structured around the SSR (Sketch, Sketch- based feature, and Refinements) triple design paradigm. This dataset encompasses a wide range of CAD commands, thereby aligning effectively with industrial appli- cation requirements and proving suitable for the generation of LLMs. Extensive experiments validate the effectiveness of Seek-CAD under various metrics.
INTRODUCTION
The CAD parametric model (also called design history), a crucial role in Computer-Aided Design (CAD), indicates the design logic of 3D CAD models, where its command and parameter sequences can be quickly edited to create or modify the shape of a 3D object Ww al. (202T): Jones al.) (2023). However, constructing parametric CAD model from scratch is time-consuming and hinders development of automation in industrial manufacturing. Hence, it attracts much attention on generative CAD modeling recently, including many interesting applications such CAD parts assembly Jones et al. (202 Ren et al. (2022), CAD parametric model generation Wu et al. (2021) Xu et al. (202cc), and modal CAD generation (e.g., Point cloud-to to CAD Text- to-t-to-CAD and etc. Khan et al. (2024bb; Li et al. (2024a): Dupont et al. (2024); Li et al. (2024c b): Ma al.
I): Willis et al. (2022); Wu et al. (2023), shape parsing Li et al. (2022);
(2023): Li et al.
(2024); Li et al.
(2025d); Zhang et al. (2025b); Khan et al. (2024b). Under the current trend of LLMs and VLMs performing outstandingly in computer vision tasks Wang et al. (023)) Schumann al. (2024); Wang & Ke (2024); Huang et al. 2204)) | /Zhu et al. (2024): Bensabath et al. (2024), integrating LLMSs and VLMs generative CAD modeling will pave the way for future innovations smart design systems.
"Equal contribution

---

Published as a conference paper at ICLR 2026
Fine-tuming is commonly used method for adapting general LLMs to domain-specife applications. In contrast to fine-tuning approaches, training-free feniing-free approaches typically utilize advanced LLMs i.e.
GPT-4o Achiam et al. (2023), thereby offering enhanced flexibilityy and efficiency in the creation of Al agents for generating CAD parametric models Yuan et al. (2024); Alrashedy et al. (2025).
However, the primary drawback is the absence of mechanism harness Chain-of-Thoughh (CoT),
which limits the potential of LLMS in CAD applications. Inspired by DeepSeek-RI |uoo et al. (2025)
with advanced capability of reasoning, we deploy DeepSeek-RI 1-32B-44 locally without training or finetuning as the backbone of our approach to explore its capability for generative CAD modeling.
Specifically, we present Seek-CAD, training-free generative framework for CAD modeling based on DeepSeck-Ri-ee ---ccc----32B-444 2-.2--4..202 By employing vetrievalaaugmented generation (RAG) strategy on local CAD code corpus, Seek-CAD produces Python-like CAD code for CAD parametric model generation. To ensure that the generated code aligns with prompt descriptions and faithfully encodes geometric features (e.g.. chanfer) and constraints (e.g., tangency, orthogonality). we introduce step-wic wise visual feedback mechanism that guides and refines the modeling process. In particular, we render step-wise perspective images that visually capture each stage of the CAD modeling process. These images are then evaluated using Gemini-2.0 Team et al. (2024) to assess their alignment with The resulting feedback is incorporated to
the chain-of of-thouggtthhthhhho (CoT) from DeepSeek-R1- R1-32R--300000- -8.4. iteratively refine the initial code and parameters.
Furthermore, we propose a novel CAD design paradigm called SSR (Sketch, Sketch-based feature, and Refinements), where each model is represented of a sketch, a sketch-based feature (e.g., extrude and revolve), and optionally, refinement features (e.g.. filler and shell). Complex shapes are constructed through boolean operations across SSR units. To support refinement features, we introduce simple yet effective reference mechanism, termed CapType (Figure B3). which establishes explicit links between topological primitives in the sketch and their resulting primitives generated during modeling. To evaluate our approach, we construct a new CAD dataset of 40k samples following the SSR modeling paradigm. The dataset covers diverse CAD features not included in existing datasets, and each sample is paired with a textual description generated by GPT-4o Achiam et al. (2023). For further details, please see Section A.2 The datatset has been released publicly and can be acessed in https: //gtthu// com/ Haap/SSunn-Hack//SSS SCekkCCD
sequence of SSR triples, each consisting
In summary, our key contributions are follows: (i) We present Seek-CAD. a training- free framework leveraging the locally deployed DeepSeck-R1. It incorporates a self-refinement capability through a sequential visual and CoT feedback mechanism, which enhances the generative modeling of CAD designs and significantly contributes to the effective generation of diverse CAD parametric models. (ii) We present an innovative SSR design paradigm, which serves an alternative to the conventional SE paradigm and demonstrates enhanced suitability for the generation of complex CAD models. (iii) Experimental results demonstrate that Seek-CAD can generate diverse and complex parametric CAD models with high geometric fidelity, enabling precise parametric control while supporting the generation of diverse CAD models.
RELATED WORK
2.1 GENERATIVE CAD MODELING
Generative CAD modeling has made a significant step recently Xu et al. 20022 2024b): Jayaraman let al. 2021); y Dupont al. (2024) ; Guo et al. (2022). notably with transformer-basel models, which treat CAD commands as parametric sequential data for learning and generation with a feed-forward or an auto-regressive strategy Wu al. (202I); Xu al. (2022) 2023); Ganin et al. (2021). Besides, ieffiusionbbseed Ho et al. (2020) methods have also been adopted to achieve the controllable generation or reconstruction of parametric CAD sequences Ma et al. (0024) Zhang et al. (022a)). Meanwhile, reinforcement learning offers another effective paradigm for generating CAD models Li et al. (2025a). Mamba-CAD Li et al. (202cc) makes a step forward to handle longer parametric CAD sequences to generate complex CAD models. As a CAD model contains explicit parametric commands, which implicitly indicate its design logic and shape geometry. it can be seen as a kind of multi-modal data inherently, which also raises many applications of generating point clouds, images, and texts Li et al. (2024b): You et al. (2024); Dupont et al. (2024); Khan et al. (2024a) Li al. (2024c). These methods mainly focus the SE (Sketch-Fxtrusion) paradigm,
reconstructing CAD models from
2

---

Published as a conference paper at ICLR 2026
which supports only limited set of simple CAD operations, making it incapable of generating diverse and complex CAD models that meet real-world design requirements. Instead, Seek-CAD adopts the SSR paradigm, which enables the inclusion of diverse CAD commands (similar to the complex feature set WHUCAD Fan et al. 2025)) such as fillet, chamfer, and shell, supporting the creation of more complex CAD models, which is closer industrial requirements, which is closer to industrial requirements. From another perspective, Seck-CAD is self-refined framework for generative CAD modeling without any training or finetuning, which is also different from these efforts under training strategy.
2.2
LLMs FOR CAD
With the success of LLMs in Computer Vision (CV) tasks Tan et al. (2024) Naeem al. (2023);
) [Shao
et al. )024)) Ghosh et al. 2024), many interesting applications of leveraging LLMs for CAD-related
tasks have raised much attention SeveetlyyText22C..
Khan al. (2024b) generates parametric CAD
models from natural language instructions using a transformer based network Vaswani et al. (2017)
with an annotation pipeline for CAD prompt using Mistral Mistral[Caaplo| (2023) and LLa VA Liu et al.
(2ap)o)
(2024). CAD-MLLM Xu a et al. (2024)), unified system to utilize a LLM to align multimodal inputs with parametric CAD sequences for generating CAD models. CAD-assistant Mallis al. (2024)
uses Vision-Large Language Model (VLLM) with tool-augmented planning to iteratively generate and adapt CAD designs via Python API of FreeCAD] FI2CAD Ocker et al. (2025) introduces a multi-agent system, LLM-based MAS architecture for CAD development processes that mimics an engineering team to automatically generate and refine parametric CAD models with human feedback. CAD-Llama Li et al. (202b)) enables pretrained LLMs generate parametric 3D CAD models through the adaptive pretraining on Structured Parametric CAD Code (SPCC). Unlike these methods, approach mainly focuses training-free strategy with the self-refined capability for generative CAD modeling.
The most related (2024) and CADCode Alrashedy et al. (2025). 3D-Premise enhances CAD code refinement by supplying GPT-4 Achiam et al. (2023) with an image of a whole object and its initial description, allowing it to identify and correct discrepancies between the intended design and the generated CAD code. Unlike 3D>-Premise, CADCode Verify prompts GPT-4 Achiam al. (023) to generate and answer a set of questions based on the initially provided description of a 3D CAD object, to adjust any discrepancies between the generated CAD model and the description. Compared to them, Seek-CAD differs in the following aspects: (i) Seek-CAD uses DeepSeek-R. 1-32B-Q4 (open-source reasoning model) for local deployment, integrated with a CAD code corpus via a siriivaallaumeneee generation framework, instead of relying GPT-4. (ii) Previous research evaluates object renderings in VLMs by focusing only on final CAD forms, overlooking intermediate phases, which limits feedback for complex models. Seek-CAD addresses this with step-wise feedback mechanism, showing both final and intermediate shapes to enhance VI.M feedback. (iii) Previous methods use predefined question templates to evaluate VLM alignment with descriptions and images. Seck-CAD. however, guides VLMs to assess alignment between DeepSeek-RI RI's chain-of-thought (CoT) and step-wise images, as CoT effectively illustrates the design logic, enabling clearer VLM understanding (Sec) 3.2
Seek-CAD other two training-free frameworks, 3D-PreMise Yuan et al.
3 SEEK-CAD FRAMEWORK
In this section, we introduce the Seek-CAD pipeline, which integrates local inference process (Sec 3.T and step-wise visual feedback strategy (32) to generate and progressively refine CAD models, based visual alignment signals derived from step-wise renderings. The framework of CAD illustrated in Figure|
3.1 LOCAL INFERENCE PIPELINE
LLMs are widely applied across various domains through training or finetuning, both of which require substantial computational resources. contrast, performing local inference with LLMs can significantly reduce the requirement for computational resources. Inspired by the advancements in reasoning capabilities of DeepSeek-RA. -1, we make a step forward to explore its potential for CAD generative modeling without additional training or finetuning.
3

---

Published as a conference paper at ICLR 2026
ANAAT CAN GONnARAA
SAD
Figure 1: The overview of our Seek-CAD framework. The whole pipeline can be divided into two parts consisting of "Initial CAD Code Generation" and "CAD Code Refinement", which are both embedded with a knowledge constraint depicted in Sec.3..1 to guide DeepSeek-R1 to generate CAD code following the SSR paradigm (Sec. J. For the first part, given query T is enhanced by conducting RAG on local CAD corpus that consisting 10, 000 CAD models. Next, Top-3 retrieved candidates would be concatenated with T' trigger DeepSeek-RI to generate an initial CAD code Iu. For the second part, Iu would go through the Step-wise Visual Feedback with CoT to have the iteration refinement. To achieve this, we first utilize a rendering script R(*) to obtain step-wise images of Io. which can represents the intermediate and ultimate shape of the object (M,, My)) simultaneously. @ denotes the concatenation of SSR triplets, where each triplet, represented by S; (S is rendered along with all its preceding triplets to preserve the correlations between object entitics. (More details in Sec. 3.2). Next, the step-wise images are fed into Gemini-2.0 to assess their alignment with the CoT from DeepSeek-RI. R1 This feedback determines whether the current code Ix is reasonable. In practice, we set k = 1 as the maximize iterations of code refinement.
(1) Pipeline Definition. This pipeline takes the text T as the input. It is a statement of how to design CAD model step by step, or can also be a description of the geometric appearance of objects. The goal can be defined as: To ~ P(To T: H) that maps the input text 7 to an initial set of CAD code To represented in the SSR paradigm (Sec(4). where H denotes our Seek-CAD.
(2) Knowledge Constraint. Similar to other LLMs, DeepSeek-RI may exhibit hallucinations SSrira manan et al. )202)); Huang et al. (002) Jiiag et al. (0024), occasionally generating CAD parametric models that deviate from the SSR paradigm. To address it, we propose the knowledge constraint Cons = ( D, 8) as the system prompt to make DeepSeek-R RI generate CAD code following the SSR paradigm, with the constraint Cons consisting of three parts: & specifies its functionality, D documents the SSR schema, and & provides an example pairing a textual description with SSR-based CAD code, as shown in Figure Appendix [A.]
(3) Retrieval Augment Generation (RAG). In order to augment the recognition of Seek-CAD within the SSR paradigm, we construct SSR-based CAD corpus CSSR {dd, c,) } to equip Seek- BeD with the capability to perform RAG. d, is the textual description and e; its corresponding CAD code, with N 10,000 CAD models. As usual settings of conducting RAG. we select hybrid search combining vector-based and full-text strategy. Specifically, for a given T, the similarity
score is computed by:
final x- Di + (1 - A) full 10,11.
(1)
where g = cos( 27, 24),
2T = v (T), 2, = (de) eve denotes an embedding model, bge-m3 Chen et al. (0224). g.ull Unnder (T,d.) is calculated with a traditional inverted index
without vectorization. The top-k candidates are selected as R, = Topk(g (. Practically, we set
A = 0.3, top-k = 3.
(4) Initial CAD Code Generation. To incorporate the retrieved content into the input context, we make each retrieved pair (dj,cj) E Rr concatenated with T. By integrating the knowledge constraints Cons, the initial CAD code To can be obtained as follows:
Io ~ P(J T @ (dz, oj), Cons).
The initially generated CAD code In is occasionally subject to compilation failures with the geometry kernel (e.g.. PythonOCC Paviot (2022) utilized in this study), which are attributed to syntax errors E. For remediation, pattern template Q is employed to automatically rectify E in Io, addressing issues such as mismatched parentheses and incorrect capitalization of variable names, depicted as: To P(To Q).
4

---

Published as a conference paper at ICLR 2026
(5) CAD Code Refinement. Upon addressing the aforementioned syntax enrors, we employ the geom- etry kernel to directly render Iu. thereby acquiring its sequential perspective images (Sec 3.2) Subse- quently, the sequential perspective images, in conjunction with the CoT obtained from DeepSeek-RI, are input into Gemini-2.0 for the purpose of evaluating their alignment. Finally, the step-wise visual feedback (Sec Fealt, would be delivered back to DeepSeek-R1 again to refine To get final CAD code I. This process may iterate N times based on whether Foa is positive or negative, To make it clear, we denote F' as an indicator to represent the statement of Featt. For example, if L 1, it means Feall is positive, that is, the CoT and step-wise perspective images are well matched and do not require any further modification, which can be defined with:
T- IN ~ {P(I2 Feult Cons) ==0
{m }
==
Analogous to the initial CAD code Io. which bears the potential for syntax errors, a syntax check shall also be executed on ls during each iterative step, as delineated in: 1a ~ P(Ix Q). In practice, the maximum iteration step N = 2 is established in our work to avert superftuuus adjustments, which may arise from the hallucinations of Gemini-2.0. Further elaboration on the iteration step within the refinement stage can be found in the "Refinement" section of See 5.2
3.2 STEP-WISE VISUAL FEEDBACK WITH COT FOR REFINEMENT
A significant capability of reasoning LLMs lies in their ability to refine and optimize initial outputs in response to feedback. The self-refined strategy has been adopted in CAD parametric model generation Yuan et al.) (024); AArashedy al. (2025). As CAD command sequences can be easily rendered into the perspective image of an object by using geometry kernel tools like PythonOCC, this coamaand-eecrrption"" to Elmage-Descrippi
can shift the aligned judgment from well handled by VLMs. In this study, we propose a novel step-wise visual feedback (SVF) strategy, which leverages not only the imagery of the object's final form but also retains visuals depicting the intermediate configurations throughout the entire construction process. Additionally, it incorporates the CoTs from DeepSeek-R I to guide the VLM during its evaluation.
which can be
(1) Obtain Step-wise Images. Specifically, the initial generated CAD code To is converted into sequence (Seeg) of n SSR triplets, S, (Recall See 4.. as defined with Lo - Seeg = [S1, S2, ... S. Next, we leverage the rendering script R(*) (based on PythonOCC) to subsequently compile this sequence S to generate their corresponding perspective images. To better illustrate the construction process from visual perspective, we capture both the intermediate object shapes, Mr, and the ultimate object shape, My. To capture Mr, for each step k E (1,...,,) n in the construction sequence Si S2 O...B @ Sk, the corresponding image in M, rendered by IZ(+). To maintain the correlations between entities of the object and make them visualized clearly, this rendering process would highlight the entity from the current SSR triplet S₁ while entities from all prior SSR triplets S, (where j < k) are hidden as 5,- To achieve this, adjust the transparency in R₂*) x) to ensure that the current shape of Sj to the S, intermediate shape is emphasized. To capture the ultimate shape of the object, My. the complete sequence Szey would be directly rendered without hiding any entities. The rendering process can be found in the "CAD Code Refinement" of Figure I Finally, each Tu can be defined with a set of perspective images M consisting of M, and My:
M, = [R(S)), R(S, @ S2)....... ..,, R(S) @ $.0... (.)ll,
(4)
Mu = R(S) @ 6 ... S.))...S..).
(5)
M = Mul.
(6)
where @ represents the concatenation of SSR triplets. In practice, only single image is rendered for each Sx. Benefiting from the highlight of each entity in the step-wise images, this effectively avoids occlusion issues encountered in the single-view rendering.
(2) Query for Calling Feedback. Instead of using VLMs to judge the alignment between the initial description T and M, Beek-AAD directly make judge the alignment between the thought from DeepSeek-R1, CoT [4,, 12, .2...,, J. and M. & E Col depicts a clear design logic of the current step according to the initial description T. which is highly compatible with current step-wise image Sk. This would help VLMs understand clearly how the object is constructed. Next, we feed M along with its corresponding thought CoT into Gemini (VLM) and prompt it to judge the alignment between M and CoT to generate feedback Foclis this process can be defined as:
Featl P(Foati G, G,M. CoT),
5

---

Published as a conference paper at ICLR 2026
facel
isketch
Extrude
Shell
Caplype"" Swatyy
SSA Irple
face2
Shrpet Chaster Cepptype
SSH Triplz
Unin
Extrude2
Chamter
CENSTOR'
sillets So v SSErp
SSt Inpic
Final Shope:
Ikketch3
Revolve
Fillezz
Figure 2: The SSR Design Paradigm. Each CAD model is constructed as sequence of SSR triplets, where each triplet consists of a sketch, a sketch-based feature (c.g., extrude, revolve), and optional refinement features (e.g., shell, thamfer.filles reference system (START. SWEPT, END) during modeling operations. Final shapes are formed by applying boolean operations (e.g.. Union, Cut, Intersect) between the outputs of SSR triplets.
Topological primitives is traced using the yyp
where G is our prompt query designed with two rules for generating Feau: (i) If M and CoT are well aligned, Foat should be positive feedback return. (ii) If M and CoT are mismatched, Foot would outline a clear statement to point out discrepancies between M and Co7, which would be delivered back DeepSeck-RI again refine the generated CAD code (Recall Equation
4 SSR TRIPLE DESIGN PARADIGM
(1) SSR Triple Design definition. The Sketch and Extrude (SE) paradigm persists as the predominant approach in contemporary feature-base based CAD modeling Khan et al. (2024a): Xu al. (2023): Zhang et al. (2025b); Wang et al. (2024); Yavartanoo et al. (2024), attributed to its versatility and faci litation of parametric editing. Current large-scale datasets for parametric sequence modeling Wu et al. (202T);
Willis et al. (2021) also adopt this paradigm. Nevertheless, the command sets provided by preceding datasets are constrained to basic operations such as sketch and extrude, and the curves incorporated predominantly confined to elementary types. Consequently. contemporary research endeavours leveraging these datasets tend to yield simpler and less diverse geometric forms, failing to adequately address the complexities inherent in real-world design requirements. To address this, we introduce a novel modeling paradigm called SSR (Sketch, Sketch- -based feature, and Refinements), in which each modeling step is represented
within sketches
SSR triplet
(8) where 1: 0, denotes 2D sketch feature, E is sketch based feature such extrude or revolve, and (r1, .2..... Tk) is an ordered sequence of zero or more refinement features, where each r; E R and R includes features such as fillet and chamfer. Each SSR triplet S, is compiled into a 3D geometry S CAD Kerneeereeee (S,) via CAD kernel like PythonOCC, and complete CAD model M, composed a SSR triples, is represented as sequence of geometry units joined by boolean operations:
S = = (2.,,,....,.7 or Ø),
M (S,, (S1, S2. op....., S,),,
where op; E {Unnoon Cut, Intersect] denotes a boolean operation applied be- tween adjacent geometry units. An example of this process is shown in Figure (2) CapType Reference Mechanism. In the context of complex geometric modeling, the integration of refinement features requires referencing particular topological primitives generated during inter- mediate modeling phases, which are not retained within the design history (parametric model). Consequently, we introduce the CapType reference mechanism to address this issue.
Facel
croteal eNer(v
Given an SSR triplet S [s (ri, . rr))), where is the 2D sketch containing a set primitives = (a), ..,,,........................... .022,...,,mpp am)) we where S' = (s, f) omits the refinement operations. The resulting geometry S' contains set of primitives B = {b1, b2. ....,.). The CapType reference mechanism defines a mapping A as:
Figure 3: Illustration of the proposed CapType reference mechanism.
define the intermediate geometry S' CAD_Kerne
((a, C) - b. aEA. A. be B, CE END,
(10)

---

Published as a conference paper at ICLR 2026
where C' denotes the CapType category: START and END refer the primitives at the start and end of the 3D operation f. respectively, while SWEPT refers to the primitives generated along the trajectory of the operation, illustrated in Figure B This mechanism allows each refinement operation r; R to reference a specific primitive b E B via Φ(a, C), enabling precise and reliable identification. As illustrated in Figure (e) and Figure 7 the method enables the generation of complex and diverse CAD models that align well with real-worid design requirements.
EXPERIMENTS
5.1 EXPERIMENTAL SETTINGS
(1) Metries. To evaluate how precisely the generated CAD commands depict the 3D object, we sample 2000 points separately from CAD models in Ground Truth GT and generated CAD models D. We use Chamfer Distance (CD). Hausdorff Distance (HD). and Intersection over the Ground Truth (loGT) Alrashedy et al. 2025) to measure the differences between GT' and 1). Besides, we utilize G-Score (score from I to 5, allowing decimals by Gemini-2.0) to judge the alignment between the description and the perspective image of its corresponding generated CAD model. To prove that the generative model is not mere replication of the local CAD corpus, we also compute Novel metric as: + Σi= I[s( LB,) < -] 2 p. where LA is a rendering image of the generated CAD model by SeekCAD and Ig, is rendering image of each CAD model in the local CAD corpus, and s(*) is a similarity function (T = 0.8, 0.8). In practice, we use ResNet-550 He et al. (2016) to encode La and TB before calculating their similarity. Note that cases failed to compile would be excluded when calculating these metrics. Given the generated CAD commands could be failed to compile, we further add Pass@k to better understand the mechanism of components in Seck-CAD. Pass @k denotes for each description, the probability of at least one set of generated CAD commands being compiled successfully in k times generation. We report mean values under all metrics.
(2) Comparison Methods. We have witnessed two training-free efforts of generative CAD modeling with the self-refined strategy: 3D-PreMise Yuan et al.] (2024) and CADCode Verify Alrashedy et al. (2025). To compare with them fairly, only the refined strategy in Seek-CAD (SVF) is separately replaced with refined strategies in 3lD-PreMise and CADCode CeDCodeVerify. while the rest of the components in Seek-CAD all consistent. Besides, we choose the latest finetune strategy (CAD-Llama Li et al. (0025b) as competitor to show the capability of Seck-CAD.
(3) Implementation Details. We deploy DeepSeek-R1:333 in Q4 quantization version as a backbone of Seek-CAD on one NVIDIA RTX 3090 GPU with Ollama Ollama The context length is set to 15,000 to endow inference speed 21.78 tokens per second. For the inference stage, we set temperature T = 0.7, top-p as 0.8 to make it capable of generating diverse CAD models in different trials. For RAG settings, we employ Dify Dify and bge-m3 Chen al. (2024). details refer to Appendix A.4 For the refinement stage, we adopt the Gemini-2.0 API Team et al. (2024) from Google Al to judge the discrepancies between step-wise perspective images and their corresponding thoughts BreepSeck-R::22B-44
The feedback from Gemini would be delivered back to Seek-CAD to again refine the generated CAD commands. We set the maximize iteration step of for the refinement stage.
5.2 EXPERIMENTAL RESULTS
consisting of an additional 500 CAD models which are completely different from 10, 000 CAD models in the local CAD corpus. Based on our framework. we compare our SVF with two other visual feedback strategies in one- step refinement, As shown in Table I the SVF strategy employed in Seek-CAD significantly outperforms the feedback methods used 3D- Premise and CADCode Verify across all metrics. This demonstrates that the CoT and step-wise images utilized in the SVF strategy indeed well-al well-aligned, and the object design logic con-
(1) Generation. To avoid data overlapping, we construct
Table 1: The quantitative results of generation abil- ity tested 500 CAD models.
Strategy
Melbod
CD HD]
loGT1 G-Scure?
Novel
0.5864
0.7023
3,3385
77.64%
313 Pi-Piis
0,2208
0.6137
04315
3.2022
49.57%
Training free
VADCodeVerify
0.2164
0.5917
0,6622
3.3927
55.38%
CAD (Ours)
0.5566
3,5185
tained within the CoT empowers the VLM (Gemini-2.0) provide clearer feedback, enabling the
7

---

for Published as a conference paper at ICLR 2026
30-PreMire CABCuleVarily
Sel-CAD
Groud frush
chonk adtu and der ond
war haaen vad ove you
und nome by witk boller unteer
pitees dape cleeiey kinphullelly Joste iniiee soaegirenn and solea ack. adbinnulyy jow culiciive
westigg iigh with
beddee hea the a /lomo the aut alou dee doe luce the de the core, offecien coole of ia Aariorma feleu with haced
olber Aer
Ardge
mi renelly
woriin, onver the coettty
prrmia de
pelte
oon' of mostect
Figure 4: (a) Visual illustrations of CAD generative comparison. (b) The visualizations of refinement capability through the SVF strategy (Recall Sec 3.2). Please enlarge to 225% to see the text clearly.
more precise refinement. Besides, all feedback methods based on our framework achieve close to or over 50% under the Novel metric. This indicates that while the local CAI corpus serves constraint on CAD command generation, it does not fully limit the creative ability of our framework to generate novel CAD models. Figure 4 a) gives comparable showcases of Ground Truth GT and the generated CAD models from Seek CAD with different refined strategies. Compared to 3D-PreMise and CADCode Verify, the SVF embedded in Beek-CAD makes the generated CAD model closer to GT, which again proves that SVF (Sec 3.2) is reasonable and effective to integrate step-wise images and the thought from DeepSeek-RI. Besides, Seek-CAD shows superior performance across CD, HD, IoGT, and G-Score metries compared to CAD-Llama. This highlights its ability to prioritize geometric accuracy and achieve higher text-matching fidelity, proving a stronger semantic understand- ing. Although it scores lower on novelty than CAD-Llama, this trade-off results in models that are geometrically closer to the ground truth (Figure fa). Crucially, Seek-CAD's 's ability to completely bypass the training phase shows it can rival the overall performance of fine-tuned models, presenting a significant advantage when training resources are limited.
(2) Refinement Step. To better understand the impact of visual feedback on CAD model generations, we explore the effects of performing 0. 1, and 2 rounds of SVF within Seck-CAD, which can be found in Table Compared to Round 0, the generated CAD models show significant im- provements across four metrics (CD, HD, IoGT, G-Score) after undergoing corrections in Round 1 and Round 2, which proves the effectiveness of SVF. Additionally, we found that the gains diminish significantly with an increas-
Table 2: The quantitative results of com- paring refinement rounds tested on 500 CAD models.
Refine Round Pascor2
CD)
HDJ
loGT) G-Score?
0.77
0.2275
0.6194
06688
3.1401
0.72
0.1979
0.5566
0.7226
3.5185
0.55
0.1966
0.5548
0.7347 3,5114
ing round of SVF iterations. For instance, compared to
Round 1, Round 2 shows only marginal improvements on the four metrics (c.g., IoGT from 0.7226 to 0.7347), but it increases the probability of code compilation failures (Pass 2 from 0.72 0.55). There are two main reasons for this: (i) Limited by the inherent reasoning ability of the base model (DeepSeek-R Bitcck-R1:32B-QM in Seek-CAD, is difficult for the model to make perfectly precise correc- tions based on SVF feedback. (ii) There is a certain probability that the generated CAD commands will fail to compile during each generation process. Each additional round of refinement would increase its probability. Hence, we set the maximum iteration step of 1 for the refinement stage to avoid excessive and potentially unnecessary modifications. Two cases are depicted in Figure 4b). In the right-hand instance, the initially generated CAD model exhibits a reversed extrusion direction, resulting in the failure to form holes in the corners and the middle of the object, which resolved after one round of refinement. It again demonstrates the effectiveness of the SVF strategy.
(3) A blation Study. To figure out the mechanism of Seek-CAD, we conduct ablation studies on 200 CAD models by removing some components in Seek-CAD to achieve an additional 7 frameworks tagged from A to G. which separately denote: A (w/o local CAD corpus). B (w/o knowledge constraint), C (w/o inter images in SVF), D (w/o ultimage image in SVF), E (w/o vector search in local CAD corpus), F (w/o text search in local CAD corpus), and G (w/o CoT in SVF). For the complete version of CAD, we denote it H. Note that all comparisons in the ablation
8

---

Published as a conference paper at ICLR 2026
study are based on the one-time refinement. As shown in Table 3 model A completely fails to generate compilable CAD commands, indicating that within a traming--ree framework, the local CAD corpus indeed imposes constraints to guide model to generate CAD commands based on the SSR format. This is highly effective for the Seek-CAD model, which lacks prior knowledge of SSR, providing technical approach for quickly achieving CAD model generations without any training. Compared to model H, the impact of models B, E, and F is primarily focused on the compilability of generated CAD commands. In partieular, the substantial decline in Pass @ for model B (from 0.68 to 0.44) highlights the critical role of the system prompt as an effective constraint during CAD command generation. Besides, models and F also exhibit a significant decrease in four other metrics (e.g., from 0.7451 to 0.6464 in IoGT, 3.8409 to 3.6315 in G-Score). This proves conducting hybrid research in the local CAD corpus is more effective. Furthermore, we found that the image utilization strategy within SVF mainly impacts the precision of the refinement, as evidenced by model C' accievinn worse scores across all metrics (e.g., 0.2295 vs 0.21 14 in CD) compared to model D. This validates that inter-images can provide more visual information than the ultimate-image, thereby enabling the VLM to better understand the construction process of objects and generate clear feedback to enhance further modifications. Model G shows a decline in generation quality (e.g., G- Score from 3.8409 to 3.6120) compared to model H. It indicates CoT helps Gemini-2.0 better understand the step-wise images and improve the quality of feedback. Finally, the complete model H surpasses other comparable versions across all metrics (e.g.. highest score 0.745 in IoGT), proving the design components in Seek-CAD are all effective and reasonable.
Table 3: Ablation Studies on 200 CAD models.
Pass 11 Pass6r21
CDL
HD]
loGT
G-Scoref
A
0.44
0.64
0.2295
0.6307
0.6287
3.5895
0.79
0.3114
0.5914
0.6713
3.7254
D
0.67
0.80
0.1961
0.5573
0.7036
3.7761
0.56
0.77
0.2178
0.5947
0.6563
3.6642
0.6464
3,6315
G
0.65
0.76
0.2247
0.6254
0.6373
3.6120
0.68
0.81
0.1923
0.5382
0.7451
3,8409
(4) VLM feedback quality. To provide deeper insight, we conducted new statistical analysis of the VLM feedback, categorizing the responses into three types: "Yes" (Aligned)," "No" (Mis- aligned), and'Unnure" .We performed this analysis on the 500 CAD samples from our test set (utilizing the optimal refinement step N = 1). The detailed statistics are presented in Table 4 Based on it, the impact of each type can be summarized:
(i) "Unsure" (Useless): This category represents cases where the VLM failed make definitive judgment. In these cases, the feedback is useless (ineffective), as it does not trigger meaningful correction, but it effectively acts as "pass" and does not actively mislead the model. (ii) "Yes" and "No" (Helpful): We carefully verified samples from these two categories by human. We found that these judgments were overwhelmingly valid. "Yes" correctly validated accurate models, and "No" indeed identified logical discrepancies between the CoT and the images. (iii) "Harmful": We acknowledge that harmful hallucinations (e.g., claiming a curve is "not smooth" when it is) are theoretically possible and might appear in larger-scale testing, our manual verification indicates they were not a dominant factor here.
Table 4: The quantitative analysis of the VLM feedback on 500 CAD models.
Helpful
Useless
Harmful
("Yes"/'No") (67/374)
"Unsure" 59
88.2%
11.8%
(5) Performance vary with CAD model complexity. To further uncover the capabilities of Seek- CAD, we use the total number of CAD commands within the SSR paradigm as the metric for complex- ity. Specifically, we categorized the generated CAD models into three groups based on their command sequence length: Low [0. 30), Medium [31, 70], and High (71,) ). The results can be found in Table 5 The increased sequence length makes the generation task harder, increasing the difficulty of perfectly matching the target Ground Truth (leading to lower geometric scores). However, it also introduces more degrees of freedom in the generation process. This enhances the diversity of the generated models, thereby boosting their Novelty.
Table 5: The results of performance vary with CAD model complexity.
Length CD) HDJ.
loCTT*
G-Scoref
Novelf
D.30 0.1898 0.5131 0.7356
3,9324
56.25%
(1,70 0.2001
0,5704
0.7021
3.4935
61.76%
(6) Robustness. We conduct a new set of comparative experiments conducted on the DeepCAD dataset Wu al.)
(71. 0.2093 0.5924 0.6759
3.1133
69.34%
(2021) to validate the robustness of our framework. For this experiment, wereplaced our local RAG corpus with 4,000 CAD models collected from the

---

Published as a conference paper at ICLR 2026
styeer saar fno man glinder alamntrr sife
suget of
loogils
aaii cxladarr aum sea Avios
wady Mr Aob
luck and Aestow edlen of cythelez
1.t, resaccttety House
the let cxtuder Aaneery
and right cylinler f2.5 sluneker) have the sove sermal Seeaion de the sour owe, berb then sugert to the sast gildie Finaly 40 eyloderr have a hole the
Adjor the proper partive for the
Reesss fosle cyliddr and cxintt triample Alack aud a restagulor bloc on in bonow ficr the loggth of cntoar 0.332234.
Romonee Asdes to mate colidder and place cose (La diamesey mit begght cay of wast gytiadre
aliiner be erthegonal the op yyliddrr and make pf pas through the wain glidie
The demo of CAD editing
Bolpoat lo oold fyad drinke An any yos
The vorel chope shat
revenner Nor eydor Tei onde kod oyteely whi my
other fasiina fhe strmally foddr gromese bron cat, Jaly,
(b) The showecases of similar generations
(c) The gallery of generated CAD models
Figure 5: Various Showcases by Seek-CAD. Please enlarge to 180% to see the text clearly.
DeepCAD datasetand another 300 CAD models (different from 4,000 CAD models in the local RAG corpus) as the test set. The comparative results can be found in Table demonstrates that even on the simpler SE- SE-paradigm dataset, Seek-CAD continues to outperform the baselines across evaluation metrics. This validates the feasibility and robustness of our framework, confirming that its effectiveness is not solely dependent on our proposed SSR-based dataset.
(7) Various Showeases by Seek-CAD. We showcase more capabilities of our Seek-CAD,incluus innluiig CAD editing, Similar generations, and Gallery of generated CAD models. (i) CAD editing is an applicative sought in a wide range of industrial sectors. As Seek-CAD is a framework built on DeepSeek-R1, it supports multiple rounds of dialogue to achieve substan- tial editing that includes but is not limited to "Add", "Remove", and "Scale" modification. Figure 5aa a) shows demo to edit the vanilla generated CAD model based on the user's 's description iteratively. (ii) Similar generations. For the same textual descriptions, Seck-CAD can generate similar CAD models as shown in Figure bb)), which offers useful suggestions for ini- tial CAD design. Besides, the description in Figure ()) contains only functional specifications of the objects, in contrast to that in Figure 5 which includes specific di- mensional parameters. It indicates Seek-CAD is capable of interpreting functional descriptions to produce valid
Table 6: The quantitative results of gen- eration ability tested on the DeepCAD dataset.
Methol
CDL
HD]
loGT) G-Seunef
Novelt
3D-PreMise 0.207 0.5823 0,7375
3,3192
CADCodeVerity 0.2035 0.5755
0.7531
3.652
51.18%
Seck-CAD(our) 0.1811
0.5231 0,8095
4,0604
54.78%
CAD models without relying on explicit parameter guidance. (iii) The gallery of generated CAD models. Figure 5ic) provides some generated CAD models from Seck-CAD with feeding textual descriptions from the test set. This shows that Seek-CAD is capable of generating relatively complex models, which not demonstrated by previous methods based on SE paradigms CadQuery. (8) Limitations and Discussions. Seek-CAD has several limitations. First, the step-wise visual feedback contains biases from VLMs due to two main issues: (i) VLMs, confined to their training, struggle to accurately describe object geometries without specific-doman training, and (ii) complex models can't be easily summarized. Second, using DeepSeek- RI for visual feedback introduces redundant information, as full CoTs are fed to VLMs. Third, -erpSeck--1-32BB --Q exhibits weaker computational capabilities for geometric constraints compared to DeepSeek-RI -1-56e model. Specif- ically, even when the VLM provides correct feedback, the 32B-Q4 model sometimes struggles to generate the precise parameters required to satisfy these constraints. This limitation could be signifi- cantly mitigated when scaling up to DeepSeek-Ri-on -6. Fourth, the CapType system struggles with selecting certain topological primitives, like intersection intersection-gennratted edges, which need intermediate B-Rep modeling data. Specifically, if a logical error is related to a primitive that CapType cannot reference (c.g., "the fillet on that intersection is missing"). ) the loop cannot currently fix it because the system has no mechanism to point to that specific location.
10

---

Published as a conference paper at ICLR 2026
REFERENCES
Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, lige Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et Gpt-4 technical report. arXiv preprint arXiv:2303.08777 2023.
Kamel Alrashedy, Pradyumna Tambwekar, Zulfiqar Haider Zaidi, Megan Langwasser, Wei Xu, and Matthew Gombolay. Generating cad code with vision-language models for 3d designs. In The Thirteenth International Conference on Learning Representations, 2025.
Léore Bensabath, Mathis Petrovich, and Gul Varol. A cross coossedttaset study for text-based 3d human motion retrieval. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1932-1940, 2024.
Devendra Singh Chaplot. Albert jiang, alexandre sablayrolles, arthur mensch, chris bamford, devendra singh chaplot, diego de las casas, florian bressand, gianna lengyel, guillaume lample, lucile saulnier, lélio renard lavaud, marie-anne lachaux, pierre stock, teven le scao, thibaut lavril, thomas wang, timothée lacroix, william sayed. arXiv preprint arXiv:23100 06.25, 2023.
Jianly Chen, Shitao Xiao, Peitian Zhang, Kun Luo, Defu Lian, and Zheng Liu. Bge m3-embedding: Multi-lingual, multi-functionaliiyy, guati-gra text embeddings through self-knowledge distillation. arXiv preprint arX 2024.
Dify. Dify. httpp://dify.....
Docker. Docker. https: /tttps://ww.... www.://ccer.coo
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 European Conference on Computer Vision, pp. 19-36. Springer, 2024.
Rubin Fan, Fazhi He, Yuxin Liu, Yupeng Song, Linkun Fan, and Xiaohu Yan. parametric and feature-based cad dataset to support human- noman-cr interaction for advanced 3d shape learning. INTEGRATED COMPUTER-AIDED ENGINEERING, 32(1):73-94 2025.
FreeCAD. Freecad. https://wwwt wttp:://www..rat. freecad.e.. org/
Yaroslav Ganin, Sergey Bartunov, Yujia Li, Ethan Keller, and Stefano Saliceti. Computer-aided design language. Advances in Neural Information Processing Systems, 34:5885-5897, 2021.
Akash Ghosh, Arkadeep Acharya, Raghav Jain, Sriparna Saha, Aman Chadha, and Sctu Sinha. Clip- syntel: clip and I1m synergy for multimodal question summarization in healtheare. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 22031 2003122009, 2024.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501. 2025.
Haoxiang Guo, Shilin Liu, Hao Pan, Yang Liu, Xin Tong, and Baining Guo. Complexgen: Cad reconstruction by b-rep chain complex generation. ACM Transactions on Graphics (TOG), 41(4): 1-18, 2022.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference computer vision and patlern recognition, pp. 770-778, 2016.
Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in neural information processing systems, 33:6840-683 2020.
Bin Huang, Xin Wang, Hong Chen, Zihan Song, and Wenwu Zhu. Vtimellm: Empower Ilm grasp video moments. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 14271-14223 2024.
11

---

Published as a conference paper at ICLR 2026
Lei Huang, Weijiang Yu, Weitao Ma, Weihong Zhong, Zhangyin Feng, Haotian Wang, Qianglong Chen, Weihua Peng, Xiaocheng Feng, Bing Qin, et al. A survey on hallucination in large language models: Principles. taxonomy, challenges, and open questions. ACM Transactions Information Systems, 43(2):1-55, 2025.
Pradeep Kumar Jayaraman, Aditya Sanghi. Joseph G Lambburne, Karl DD Willis, Thomas Davies, Hooman Shayani, and Nigel Morris. Uv-net: Learning from boundary representations. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 11703- 11712, 2021.
Ling Jiang, Keer Jiang, Xiaoyu Chu, Saaransh Gulati, and Pulkit Garg. Hallucination detection in llm-enriched product listings. Proceedings of the Seventh Workshop on e-Commerce and NLP@ COLICG 2024, pp. 29-39, 2024.
Benjamin Jones, Dalton Hildreth, Duowen Chen, llya Baran, Vladimir Kim, and Adriana Schulz. Automate: A dataset and learning approach for automatic mating of cad assemblies. ACM Transactions on Graphics (TOG), 10(6):1-18, 2021.
Benjamin T Jones, Michael Hu, Milin Kodnonghua, Vladimir G Kim, and Adriana Schulz. Self- supervised representation learning for cad. In Proceedings of the IEEE/CVE Conference on Computer Vision and Pattern Recognition, pp. 21327-21336, 2023.
Mohammad Sadil Khan, Elona Dupont, Sk Aziz Ali, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. 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, pp. 4713-4722 2024a.
Mohammad Sadil Khan, Sankalp Sinha, Talha Uddin, Didier Stricker, Sk Aziz Ali, and Muham- mad Zeshan Afzal. Text2cad: Generating sequential cad designs from beginner-to-expert level text prompts. Advances in Neural Information Processing Systems, 37:7552-7579, 2024b.
Changjian Li, Hao Pan, Adrien Bousseau, and Niloy J Mitra. Free2cad: Parsing freehand drawings into cad commands, ACM Transactions on Graphics (TOG), 41(4):1-16, 2022.
Jiahao Li, Yusheng Luo, Yunzhong Lou, and Xiangdong Zhou Recad: Reinforcement learning enhanced parametric cad model generation with vision-language models, 2025a. URL https
7/arxiv. wwx.ivoorg/bbar. hbtp://b//2551/ 06328
Jiahao Li, Weijian Ma, Xueyang Li, Yunzhong Lou, Guichun Zhou, and Xiangdong Zhou. Cad-Ilama: Leveraging large language models for computer-aided design parametric 3d model generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025b.
Pu Li, Jianwei Guo, Huibin Li, Bedrich Benes, and Dong-Ming Yan. Sfmead: Unsupervised cad reconstruction by learning sketch-based feature modeling operations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 4671 16800, June 2024a.
Xueyang Li, Haotian Chen, Yunzhong Lou, and Xiangdong Zhou Cf-cad: A contrastive fusion network for 3d computer-aided design generative modeling. In International Conference on Database Systems for Advanced Applications, pp. 435-450. Springer, 2024b.
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, pp. 8461-8470 2024c.
Xueyang Li, Yunzhong Lou, Yu Song, and Xiangdong Zhou. Mamba-cad: State space model for 3d computer-aided design generative modeling. In Proceedings of the AAAI Conference Artificial Intelligence, 2025c.
Yuan Li, Cheng Lin, Yuan Liu, Xiaoxiao Long, Chenxu Zhang, Ningna Wang, Xin Li, Wenping Wang. and Xiaohu Guo. Caddreamer: Cad object generation from single-view images. In Proceedings of the IEFF/CVF Conference Computer Vision and Pattern Recognition, 2025d.
12

---

Published as a conference paper at ICLR 2026
Haotian Liu, Chunyuan Li, Yuheng Li, Bo Li, Yuanhan Zhang, Sheng Shen, and Yong Jae Lee. Llavanext: Improved reasoning, ocr, and world knowledge, 2024.
Weijian Ma, Shuaiqi Chen, Yunzhong Lou, Xueyang Li, and Xiangdong Zhou. Draw step by step: Reconstructing cad construction sequences from point clouds via multimodal diffusion. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp- 27154-27163, 2024.
Dimitrios Mallis, Ahmet Serdar Karadeniz, Sebastian Cavada, Danila Rukhovich, Niki Foteinopoulou, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. asd-aasistnnt: Tool-augmented vllms as generic cad task solvers? arXiv preprint arXiv:24 13810, 2024.
Muhammad Ferjad Nacem, Muhammad Gul Zain Ali Khan, Yongqin Xian, Muhammad Zeshan Afzal, Didier Stricker, Luc Van Gool, and Federico Tombari. 12mvformer: Large language model generated multi-view document supervision for zero-shot image classification. In Proceedings of the IEEE/CVF Conference on Computer Vision and Paternn Recognition, pp. 15169-15179, 2023.
Felix Ocker, Stefan Menzel, Ahmed Sadik, and Thiago Rios. From idea to cad: A language model- driven multi-agent system for collaborative design. arXiv preprint arXiv:2503.004417, 2025.
Ollama. Ollama. sttps://ollant com/
Thomas Paviot. "pythonoce". zenodo. 2022.
Daxuan Ren, Jianmin Zheng, Jianfei Cai, Jiatong Li, and Junzhe Zhang. Extrudenet: Unsupervised inverse seetch-and-extrude for shape parsing. European Conference on Computer Vision, pp. 482-498. Springer, 2022.
Raphael Schumann, Wanrong Zhu, Weixi Feng, Tsu-Jui Fu, Stefan Riezler, and William Yang Wang. Velma: Verbalization embodiment of Ilm agents for vision and language navigation in street view. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 18924-18933,
2024.
Hao Shao, Yuxuan Hu, Letian Wang, Guanglu Song, Steven L. Waslander, Yu Liu, and Hongsheng Li. Lmdrive: Closed-loop end-to-end driving with large language models. In Proceedings the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 15120-15130, June 2024.
Gaurang Sriramanan, Siddhant Bharti, Vinu Sankar Sadasivan, Shoumik Saha, Priyatham Kattakinda, and Soheil Feizi. LIm-check: Investigating detection of hallucinations in large language models. Advances in Neural Information Processing Systems, 37:34188- 0088888--111,1 2024.
Reuben Tan, Ximeng Sun, Ping Hu, Jui-hsien Wang, Hanieh Deilamsalehy, Bryan A Plummer, Bryan Russell, and Kate Saenko. Koala: Key candiicond long video-Ilm. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp. 13581-13591, 2024.
Gemini Team, Petko Georgiev, Ving Ian Lei, Ryan Burnell, Libin Bai, Anmol Gulati, Garrett Tanzer, Damien Vincent, Zhufeng Pan, Shibo Wang, et al. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. arXiv preprini arXiv:2403.05536 2024.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention all you need. Advances in neural information processing systems, 30, 2017.
Junchi Wang and Lei Ke. LIm-seg: Bridging image segmentation and large language model reasoning. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp.
1765-1774, 2024.
Siyu Wang, Cailian Chen, Xinyi Le, Qimin Xu, Lei Xu. Yanzhou Zhang, and Jie Yang. Cad-gpt: Synthesising cad construction sequence with spatial enhanced multimodal 1lms. 2024.
URL httt:ttss:// ptttttss//ariiiee wwwpaawwwwv.rroreaaaaaaee /2122./222...22 99633
13

---

Published as a conference paper at ICLR 2026
Wenhai Wang, Zhe Chen, Xiaokang Chen, Jiannan Wu, Xizhou Zhu, Gang Zeng, Ping Luo, Tong Lu, Jie Zhou, Yu Qiao, et al. Visionllm: Large language model is also an open-ended decoder for vision-centric tasks. Advances in Neural Information Processing Systems, 36:61501-61513,, 2023.
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 on Graphics (TOG), 40(4): 1-24, 2021.
Karl DD Willis, Pradeep Kumar Jayaraman, Hang Chu, Yunsheng Tian, Yifei Li, Daniele Grandi, Aditya Sanghi, Linh Tran, Joseph G Lambourne, Armando Solar-Lezama, et al. Joinable: Learning bottom-up assembly of parametric cad joints. In Proceedings of the IEEE/CVF conference computer vision and pattern recognition, pp. 15849-15860, 2022.
Ruihai Wu, Chenrui Tie, Yushi Du, Yan Zhao, and Hao Dong. Leveraging se (3) equivariance for learning 3d geometric shape assembly. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 14311-14320. 2023.
Rundi Wu, Chang Xiao, and Changxi Zheng. Deepcad: A deep generative network for computer- aided design models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 6772-6782, 2021.
Jingwei Xu, Chenyu Wang. Zibo Zhao, Wen Liu, Yi Ma, and Shenghua Gao. Cad-mllm: Unifying muutimoodality-codiitoon cad generation with milm. arXiv preprint arXiv:2411.0495. 2024a.
Xiang Xu, Karl DD Willis, Joseph G Lambourne, Chin- Yi Cheng. Pradeep Kumar Jayaraman, and Yasutaka Furukawa. Skexgen: Autoregressive generation of cad construction sequences with disentangled codebooks. arXiv preprint arXiv:2207.0465: 2022.
Xiang Xu, Pradeep Kumar Jayaraman, Joseph George Lambourne, Karl DD Willis, and Yasutaka Furukawa. Hicrarchical neural coding for controllable cad model generation. In International Conference Machine Learning, pp. 38443-38461. PMLR, 2023.
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 Graphies (TOG), 1314 2024b.
Mohsen Yavartanoo, Sangmin Hong, Reyhaneh Neshatavar, and Kyoung Mu Lee. Text2cad: Text to 3d cad generation via technical drawings. 2024. URL. 06206
Yang You, Mikaela Angelina Uy, Jiaqi Han, Rahul Thomas, Haotong Zhang, Suya You, and Leonidas Guibas. Img2cad: Reverse engineering 3d cad models from images through vlm-assisted condi- tional factorization. arXiv preprint wrXiv:2408.014331 2024.
Zeqing Yuan, Haoxuan Lan, Qiang Zou, and Junbo Zhao. 3d-premise: Can large language models generate 3d shapes with sharp features and parametric control? arXiv preprint arX1v:2401.06437. 2024.
Aijia Zhang, Weiqiang Jia, Qiang Zou, Yixiong Feng, Xiaoxiang Wei, and Ye Zhang. Diffusion-cad: Controllable diffusion model for generating computer-aided design models. IEEE Transactions on Visualization and Computer Graphics, 2025a.
Zhanwei Zhang, Shizhao Sun, Wenxiao Wang, Deng Cai, and Jiang Bian. Flexcad: Unified and versatile controllable cad generation with fine-tuned large language models. In International Conference on Learning Representations, 2025b.
Yong Zhu, Zhenyu Wen, Xiong Li, Xiufang Shi, Xiang Wu, Hui Dong, and Jiming Chen. Chatnav: Leveraging Ilm to zero-shot semantic reasoning in object navigation. IEEE Transactions on Circuits and Systems for Video Technology, 2024.
14

---

Published as a conference paper at ICLR 2026
A APPENDIX
A.I KNOWLEDGE CONSTRAINT
We design a knowledge constraint the system prompt to guide Seek-CAD in generating CAD code that conforms to the SSR paradigm, which helps reduce hallucination to some extent. It consists of three parts including State of functionality, CAD Code Documentation, and an Example as following:
#Statement of functionality:
You ore of CAD-assiiant help wer create models. will given description of the shape geometry of 3D objects (e.g. triangle square, rectangle, and prism), and may contain bey parameters (eg. length, height, width, and radius) and construints the entities (egg langent, parallel, and orthogomal). Your job is to help wers complete whole CAD derign logic and show the summary of soal must follow Code Documentation when you give the total CAD commands code. will give you à CAD Code de to show how it works.
commands based on their descriptions.
definition of each
command and its parameter from IICAD
STips Please give specific and reasonuble parameter values to ensure the grometric constraints (e.g. Tungent, Intersect, Orthogonal) between entiries when there multiple shetches.
#Tips 28 You connot iguore any parameter filled with corresponding CAD commands
sTips Finally, please use the most effective simple CAD command answer: example,
user query to construct chamfer edge. please use "Chamfer" command directly instead of usiing other CAD commands to replace it.
sCAD Code Documentution
toh Methods: 'moveTofx, yj Set the starting point of the loop. 'Iine Toft, y) Drass a straight line from the current point '(x,y)"
PoreePiintrrepp p2) Draw a circular are from the curvent point through pl to "p2". circeeecallass : Draw full circle centered at the current point with the given 'ruduus.
splineTof "poinns"" " Create a smonch splie curve through the given sequence of points from the curreent point.
pointTogffoy) Assign a the current point (weed after curve methou).
curve purveTagtogg" Assign tag the most recent curve (used after curve method).
gu Profile Clars: Represents claxed shape made up of one or more loops. #aB Consiructor: Profile(tagNNong
Optionally provide 'uug' to islentify the profile.
NeA Method:- "addLLopp' "(oops) :: Add one or more 'Lopp objects to the profile.
Sketch Class: Defines 2D sheich
given plane.
tets Constructor:- "Shetch(pimme)" Must provide "panne" diesionary with: normall: A 3D vectur Ts. y. s) indicating the plane's is normal direction.
origin
point y, z! specifiing the sketch's 's origin.
x': A vector [Ex. zf" defining the Xaaris direction in the plane.
#*8 Method:- "udldProfilef pprofieee)) Adi one or Prrofile objects to sketch.
No Shape Creation
#*8 ssirudefshetch. distance-fu, (G. bl) - Shape' Create 3D solid by extruling the profiles in shetch.
'aa: Extrucioon distance in the shotch's normal divection. 'b': Exteusion distiance tn the opposite direction.
Neir Revolvefsketch, axis (point, divection). angie-(a, b)) -s Shape': : Create a 3D solid by revolving a profile around given axis. Ff, y, indiccting the divection. aa: Angle in the normal direction.- bb: Angle in the opposite direction.
pointt A 3D point Ts, y, 2f the axis. "divection' : 3D
Shape Class: Represents solid body. Supports Booleun and modification operations. #o Boolean Operations:
unionls Shape) Shape' : Merge the current shape with shope 's'.
shape.cutls:: cutls: Shape) - Shape': Subtruct shape from the current shape.
shope intersectós Shape) Shape' Keep only intersecting volume between the curvent shape and shape 's'. ten Modifiers: 'shape. Ch Chanfer(width, entities) ; Apply chanfor to togged adges curves.
'shope Fillstradius, entitios): : Round corners with fillet radius. 'shope. Shellthiekness, eutities)". Hollow out shape with specified wall thickness.
# #Examplett
# Description The resulting model is L-shaped prismatic solid with two perpendicular rectangular one extending vertically and the other horizonially forming the characteristic I. shape in 3D space. Additionally, there are four vertical rectangular pillar-hie primms the virtaal bounding rectongle.
extending downward from each
# Generated Answers Based on your description, can help you ereate the CAD command summary for generating deseribed shape. Here is the complete CAD code command design with valid parameters:
shil Shatch(plame- ("normal". [0.00 0.0, 1.9]. "origin", " (0.0, 0.0 0.03, "x" [1.0. 0.9, 0.9)))
0 Profilet)
pi O.addELoupfLoopp moveTorO 0. 66.667... 0.-2,667), limeTo00.254444 25..0254.222.6 6ow...oneo................
(oc.2o1..285,-- 2.55..0.540..incoooo.... (228,,000)
RineTo(0.0 -1.667))
sh0. adddeedPPei
shope0) - Extrude(sh0, distance- 0.9114)
Sketchrplane- "normal": [9.0) 0.0, 1.0j.
"origin": (0.00 0.0, 0.0 "t" (1.0. 0.0 0.99))
0 Prufile()
pl OadddLopp(Loop
skl addProlilepp 0.p 1.pl pp 3)
shapel Extrudefsk1, distance-0.865 0.8636)
shope0- = shappe. anton(shppe)
Figure 6: The knowledge constraint adopted Seek-CAD.
15

---

Published as a conference paper at ICLR 2026
A.2 CAD DATASET BASED ON SSR PARADIGM
We extend the data parsing methodology of DeepCAD by utilizing Onshape's Developer API and FeatureScript to parse CAD models based on the ABC dataset. Our method supports core modeling commands including sketch, extrude, revolve, fillet, chamfer, and shell. During the parsing process, models containing unsupported operations (such as mirror) are not immediately discarded. Instead, we filter them only if the proportion of unsupported commands exceeds threshold of 0.2. Unsupported commands are ignored, and only supported operations are retained for further processing.
For commands like fillet, chamfer, and shell, first extract the primitives they operate (e.g., edges for chamfer or faces for shell), and then use PythonOCC APIs to match these primitives to specific sketch elements through their CapType designation. We note that the proposed CapType reference system cannot identify certain edges or faces that are not directly associated with aketch-defined primitives such those generated by the intersection of solid bodies. Therefore, when refinement commands (chamfer, fillet or shell) involve such primitives that cannot be identified via CapType schema, we exclude those primitives from the commands. Finally, all parsed data is converted into unified JSON format compatible with DeepCAD, which can be directly rendered using PythonOCC for visualization.
To further illustrate the characteristics of our dataset, Figure 7 presents qualitative comparison between our dataset and DeepCAD. The statistical distributions of command sequence lengths and the number of curves per CAD model are shown in Figure 8
DeepCAD dataset
Our dataset
Figure 7: Qualitative comparison between our dataset and the DeepCAD Wu et al. 2021) dataset. Compared DeepCAD, our dataset captures more realistic and structurally complex industrial designs, supporting broader range of modeling operations such as spline, revolve, chamfer, fillet, and shell. Our extended dataset also features richer geometric details and greater diversity modeling strategies.
Dataset Dataset
DeepCAD
8
Count (x101)
Count (x110)
Feature Length
Average
Length
Figure 8: Statistical comparison between our complete dataset and the DeepCAD Wu et al. 2021 dataset, which also is subset of our dataset. The left plot illustrates the distribution feature lengths, while the right plot shows the distribution of average curve lengths.
16

---

Published as a conference paper at ICLR 2026
A.3 CAD CODE REPRESENTATION
Since existing CAD scripting tools such as CADQuery do not directly support CapType reference mechanism and SSR design paradigm, we define a concise and effective Python-based representation tailored for SSR-driven CAD modeling. As shown in Listing the CADShape class encapsulates an SSR triplet and supports boolean operations- such as union, cut, and intersect. w-wth other SSR triplets. The final CAD model is represented by CADShape instance, which can either be single SSR triplet or the result boolean operations among multiple SSR triplets.
For refinement features (e.g., chamfer, fillet, and shell), the target edge face primitives are determined using the CapType introduced Section g In particular, applying a chamfer or fillet to face affects all edges that face. Finally, convert the code into the JSON format similar to DeepCAD, which is then rendered using PythonOCC.
Listing 1:
Python interface for SSR-based CAD modeling. The CADShape class provides concise and extensible representation that supports structured modeling under the SSR design paradigm.
class Loop:
def iniii_nte_____ (self) -> None:
Define start point of this 1oop
def moveTo (self,
float, y: float) -> Self: ...
Graw straight line to point
def lineTo (self, x: float, y: float) -> Self: Arc to p2 via pl def thresPointArccseltt,, pl: Tuple float, float], p2: Tuple float, float!) -> Self:
Spline through given points
def splineTo (self, *9: Tuple [float, float]] self: Close 1oop (make line back to start point) def close (self) -> Self:
Draw circle with center current point def circle (self, radius: float) -> Self:
assign tag to the current point
def paintTag (self, tag: str) -> Self:
assign tag to the current
def aseet,agseel, tag: str) -> Self:
class Profile:
Create a face with optional tag for reference
def _nit__isi_l_ tag: Opticnal[str] None) -> None: Add one or more loops to the face def (sele +loops: Leep) -> None:
class Sketch:
plane format: ("origin": [x, Yr 2], "x_axis": [x, y, 2], "normal": [x, y, z]}
def Lnit (self, plane: Dict) -> None: ...
def addProfile sprofiles: Profile) None:
class CADShape (ABC):
def inn_t_nit___l_____ (self) None: ...
entities: 1ist of dicts, each with { ("capType"; "START" "END" "SWEEP
", 'referenceId's str),
specifying referenced entities def (sa1,, width: float, entities: List (Dict]) -> Self:
def Fillet(self, radius: float, entities: [ist(D Self:
def (self, thickness: float, entities: (Dict] -> Self: def (seln, shape: CADShape) -> Self:
def cut (self, shape: CADShape) -> Self: ...
def intersect (self, shape: CADShape) Self: ...
17

---

Published as a conference paper at ICLR 2026
class Extrude (CADShape)
def init_ (self, sketch: Sketch, distance: Union [float, Tuplo float float]]> -> None:
class Revolve (CADShape):
axis format: "point": (x, y, 21,
"direction"; 1x, y, 2í), axis is defined by point and direction
def _nnit_ (self, sketch: Sketch, axis: Dict, angle: Union Union[float,
Tuple[float, float]]) -> None:
A.4 RAG SETTINGS
To equip the -SR-based CAD corpus locally for the eetrieval-augment generation Seck-CAD, Dify Dify in 0.15.3 version, which docker-based Docker platform. For each query, use bge-m3 Chen et al. (2024) to embed into vector that is used to calculate similarity score with CAD models stored the local SSR-based corpus. Practically, we select Top-3 samples based on a hybrid searching strategy (Sec 3.D for the augmentation retrieval. To incorporate the retrieved content into the input for Seek CAD, we apply chunk-based prompt construction strategy. Each retrieved pair (dj. 8z) E Rr is formatted as:
[Chunkj] ] = pesscription:
"dy || "CAD code: "85>
(11)
where @ denotes string concatenation. The final prompt for Seek-CAD becomes:
T + sy) "Query: "I Chunkj
+ ... Chunkg.
(12)
A.5 NOVEL VISUALIZATIONS
Benefiting from the prior knowledge of DeepSeek-R1, Seek-CAD is capable of generating not only industry-oriented CAD models but also non-industrial ones that differ in style from those in our local CAD corpus. As shown in Figure this demonstrates that Seek-CAD does not rely entirely our local CAD corpus and is able to generate models with certain degree of novelty.
Figure 9: Novel showcases generated by Seek-CAD, which different from the style of CAD models in the local CAD corpus.
18

---

Published as a conference paper at ICLR 2026
A.6 ENLARGED VERSION OF SHOWCASES IN FIGURE 5 C) OF THE MAIN MANUSCRIPT
We provide enlarged version of showcases in Figure (()) for clear view shown in Figure I0
Figure 10: The enlarged version of showcases in Figure () of the main manuscript.
A.7 MORE SHOWCASES OF CAD EDITING
Almn
caalie monoly and donenally of nyty qates waing reffors For insamon comoc floge 13h0s,
Foy sede Sne
Asl soy Ne
Rewen de bel
sight Seaee cusr
woal syscaly puoepeas it bak holes mobale for
chancartonn by rocorgster grlat
bober of New
naNs acompeent by no alttoed postll otlaios en bogesbe prine, mosing speaed crieedin
Figure 11: The showcases of similar generations.
A.8 MORE SHOWCASES OF SIMILAR GENERATIONS
4 pebuuat shew Suowe ty conadigg de oreyvee shesh mesiggote
ongghal mncaugsis crmvlla ane faaten rnsaal mecanpiie creas oflabtiia protadeer
peritaud apoovw and too the betoo carsee of the desste indussiis cheste
doppe
vad hour mabss doooed wetke Unlogeed channe tha aaares
ontfonaly
fnswess iecepomat halo
adgpoal oxladiii deto. Adbiiunsty remasgoer plas elgwe' chansel
paires
slcck showe gutddr and New the betie ruch with chanter apalod' is thi coldiiaa mag cndchandii en oaur and adoc.
cimale
Figure 12: The showcases of similar generations.
19

---

Published as a conference paper at ICLR 2026
(1) Domo
Query
Inikil CAD madel
The CAB andil faatoo Nack growaty
PerSSeok-Rt
showing qoomir splodeiie edge ri9ht plane faawdyy disbeer
(Ouguu Code)
Chain-of-Thoggee (CoT)
Gemini-20
Rendering Step-wibse wike images
Instaction for Gemiln--2 1.0
what fey evl
alprere adees or C.d oureene winng elles youu maree choid
are
prshalty comwae cpeviiee soungg Joan skace resiutes messtoor rghn vegene changer soaded cussiio craight San.
diggs Thi codi ailivol audker cxoude will conmand)
piv sugen
Feedback
should oun cnailigg sleuc for for malk pugfie The geettonatii par ivtten shank Aftr cotwalay adding etper help reves)
dee abjer does out
dertiittiss or
Foose
arodde and Call cocsuedd conewryy
porttly plane anabioen oppeogmano thes
wit cotroda shoge skolld untews wath fiww
Finalized CAD model
atsgsttr dimesaivn cradat our dlan' wouth over nolirs dhor uan exhone bare demte wals.
DeepSork-Rt
(Ouputt the SSR Code)
Fosals coummainng abjuc wile anihh / shaal dtarat modess fearealy cams clusne usdg
chic vake
paines New, parkieg Akis styp says
(2) Demo
Query T
Initial CAD modd
coupotty shope cunting of Sire Doewing quer comple Lobaged kntiomss poratll
DeopSes-R1
(Omtput
original Lebagge berblle stsotee onsion cteannd moreed whihe renving mersre tp soker uertual
Chaln-af-Thoee (CoI)
Rendering Step-wilke images
Gemini-200
Uhyy mnal CAP mabi ksoed sterh degl arkloy
Instruction for Gemini-20
They sur campasio shape made of Woove maasgaaer prltes will antirr we jorning Luhrpe, enganel dur calle ousees Back
/ubllyy dliuored
C.S mole crecee
rericel prines
ove slocking how profis, Moace dushapo and ovcec coceaglee cone a right cugle aniqo dleaifir.
Merooodio chape othacs chapr of gioe resi
Syver
Anck
Feedback
ectudle dlokk glur Avijic Afte sloc I' Mllen the crnwo when the romied and bortioeet petton mor.. per
a cinple mmmapole poir with rourdedd enners Enkape
aver sondined receced area dee aoke prive. slock uudter unilagg vilion the luger
deselled objerr diuld wik contininng en Locopet mus ssep weer recemnstor prome. the aronke ingh Ca0 comment spain
resile ther remanaote priten, ddfeseestyy
camer comvar utheret stope from the wate moeled
log
pask, dumod
Finelized CAD model
duech models Sioee sxffie hegli pritess
DespSeoo-RR
Fiaals I'll Jenccee code supornsally sauting dorr dnougt andractios and ovaniig oll beokas spensoen sydiol
(Outpaa the SSR Code)
Figure 13: The showcases of complete generation process.
A.9 THE DETAIL. SHOWCASE OF COMPLETE GENERATION PROCESS
Here we provide two demo showcases of complete generation process by Seek-CAD, including the input query T, CoT from DeepSeek-R1, initial generated CAD models, feedback content, and finalized CAD model (Figure 13).
20

---

Published as a conference paper at ICLR 2026
A.10 MORE SHOWCASES BY SEEK-CAD
Figure 14: The more generated showcases by Seek-CAD.
A.11 THE ENLARGED VERSION OF KEY DESIGN MODULES WITHIN SEEK-CAD FRAMEWORK
Initial CAD Code Generation
Rendeing Jerjp
Anuxcedge Contrait
Carua
Condilares
#F #aneriinllin- You (D--ssittnnna
crvite CAD modeh....
cCAD Code Decsmentaaiin baned on the SSR
DespSesi-Ri
cylindrical shope diralar peofle
unifaratt along
perpendionar forwing
Chein (Col) follonting
Gonernie CAD Code Skenckeptoner "marmoul" 10.8 -1.0, 8.l, "oriigen" a.d. fL.. 9.0)) pi Profilett pll Anddlaspt Loop Sie
top faces. top nufass featares on cxpanded circador grvene concentic connut suroundingg contral cytindrical rwid rembing ring-like recesve ares.
sarface
(2) Next
Finalli....
a
CAD Code Refinement (Max iterutions k=2)
Step-wise Visual Feedback
Knuwledge Canmralor
Intermedion Stape M,
Fanctionadiy You C4D-Atritans help
CAD modeli...
ACAD Coke Decamontstion hace SSR
Arrampiok
AiS1)
RrSTggs2) Shape
Governted CAD Code Skerehgpooeee
DeepSeck-Ri
RrSH
a.j)) Profilee)
&df,
allgardd
Gommie--244
Step-uéie vésual feedback
Final Code
(b)
Figure 15: The enlarged version of key design modules: (a) Initial CAD Code Generation. (b) CAD Code Refinement.
21


Reviews:
[{"review_id": "fkktgBwQb7", "reviewer": "Reviewer_TUi8", "summary": "Authors proposed seek-cad, a training free approach for generating CAD code from textural input. It formulate data in a novel SSR template, and use a captype reference to effectively support chamfer and fillet operations on new surfaces introduced by CAD operations. The RAG system is also novel with an additional one round of step-wise visual feedback in the code refinement stage showing to help improve generation quality.", "questions": "(1) Why not use a single vllm model like Qwen-VL or InternVL. The proposed design using DeepSeek for text and Gemini 2.0 for visual is fairly complicated. Is there a particular reason why authors use this pipeline?\n\n(2) How is the dataset constructed? What method is used to avoid data leaking from training to test set? Does it have the clearance from OnShape to be allowed to be publicly released? \n\n(3) How important is the RAG data? Does the increase in complexity help? \n\n(4) Is it possible to use exsiting public CAD data as the RAG data and see how it compares to baselines? This seems like the fair way to compare without the results been affected by the new dataset. \n\n(5) Please provide implementation details in the paper for reproducible results.", "limitations": "", "rating": 6, "confidence": 5, "soundness": 3, "presentation": 2, "contribution": 3, "strengths": "The proposed training-free approach is novel and the first few works that explored this direction. The SSR data format with captype reference is also more general and applicable to real-world scenarios than simple sketch-and-extrude. SVF is also a nice solution for incorporating step-vise visual feedback into the system and enable the model to verify each step in the built process. Evaluation on the new dataset demonstrate the improvement of seek-cad.", "weaknesses": "Writing and paper layout can be improved. Figure 1 is too small, and SSR definition is in the later paragraph whereas a lot of reference to it is at the front. Overall, this makes reading the paper difficult than it should be. \n\nEvaluation is done entirely on the authors’ new SSR dataset. There is no comparison to previous methods on existing public CAD data like DeepCAD / Omni-CAD / WHUCAD. Figure 7 and 8 shows their dataset is much more complex than DeepCAD, this raise the concern that metric improvement could come from the 10,000 more complex RAG data, e.g better novelty than other methods.\n\nAuthors did not clearly explain how the test set is different from training set. E.g what kind of deduplication or similarity filter was applied. \n\nAuthors do not provide concrete implementation details for Eq. (1) and Eq. (2) — only high-level descriptions of what those equations represent conceptually. This makes reproducing the work fairly complicated.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "j9GVyRyaXn", "reviewer": "Reviewer_vupC", "summary": "This paper presents Seek-CAD, a training-free framework for generating 3D parametric CAD models from text. It uses a locally deployed LLM (DeepSeek-R1) to generate code following a novel SSR design paradigm. A key innovation is a self-refinement loop where step-wise renders of the CAD model are evaluated by a VLM (Gemini-2.0) against the LLM's Chain-of-Thought reasoning; the resulting feedback iteratively improves the code. The authors also contribute a new 40k-sample dataset based on the more complex SSR paradigm. Experiments show Seek-CAD outperforms existing methods in geometric fidelity and text alignment.", "questions": "Beyond compilation failures, what are the most common types of geometric or logical errors that the refinement loop fails to correct?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1.The use of step-wise visual renders paired with the LLM's Chain-of-Thought for feedback is new. This provides a richer, more granular signal for refinement than methods using only the final render.\n\n2.The proposed SSR triple and the CapType reference mechanism enables the generation of complex CAD models beyond the limitations of prior \"Sketch-Extrude\" methods.", "weaknesses": "1.The paper mentions that models failing to compile are excluded from metric calculation. A more detailed analysis of the reasons for compilation failures would be insightful. \n\n2.While the CapType mechanism is innovative, the description in the appendix mentions that when refinement commands involve primitives not identifiable by CapType, those primitives are simply excluded. How often does this happen in the dataset/generation? Does it lead to models that are missing intended refinements?\n\n3.The RAG corpus has 10,000 samples. Was an ablation study performed on the size of this corpus? Is there a point of diminishing returns, or could a smaller corpus suffice?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "8lc6lNbRBy", "reviewer": "Reviewer_AAaN", "summary": "The paper proposes Seek-CAD, a training-free framework that locally runs DeepSeek-R1-32B-Q4 with RAG over a CAD-code corpus to generate SSR-style CAD programs, then iteratively self-refines them using step-wise visual feedback: rendering intermediate + final shapes and asking a VLM (Gemini-2.0) to judge alignment with the LLM’s CoT, feeding that back for correction.", "questions": "1- Can you provide analysis on when/why Gemini-2.0 feedback helps vs. hurts?\n\n2- Can you provide failure case analysis beyond the two examples in Figure 4(b)?\n\n3- How does performance vary with CAD model complexity (e.g., number of features)?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1- Method novelty in feedback: evaluates intermediate renders + CoT rather than final-image only; ablations show inter-image cues matter.\n\n2- Empirical signal: Seek-CAD beats prior training-free refiners and edges a tuned model on geometric fidelity (CD/HD/IoGT), with qualitative evidence.", "weaknesses": "1- VLM Feedback Quality: The authors acknowledge that VLMs struggle with geometric descriptions without domain-specific training (Section 5.5), but this fundamental limitation undermines the core refinement mechanism. No quantitative analysis is provided on how often Gemini-2.0's feedback is actually helpful vs. harmful.\n\n2- Compilation Failure Rate: The Pass@k metric reveals concerning compilation failure rates. Even after 2 refinement rounds, only 55% of generated models compile successfully (Table 2). This significantly limits practical applicability. The paper doesn't adequately address strategies to improve this.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "hJtfePI7dR", "reviewer": "Reviewer_fiYb", "summary": "This paper introduces Seek-CAD, a novel framework for generating 3D parametric CAD models. The framework's core features are that it is training-free and locally deployable.\n\nIt uses an open-source LLM  as its core, combining RAG with a novel \"SSR\" design paradigm to generate complex CAD code.\n\nIts core innovation is a self-refinement loop.\n\nExperiments show Seek-CAD exceeds other training-free methods in geometric accuracy and even surpasses the fine-tuned CAD-Llama model.", "questions": "The refinement loop (LLM $\\rightarrow$ VLM $\\rightarrow$ LLM) is expensive in time, and Table 2 shows its success rate (Pass@k) drops significantly with more iterations. Compared to a one-pass, fine-tuned model (CAD-Llama), is Seek-CAD still competitive in terms of actual wall-clock time and API call costs?\n\n\nThe system relies on a VLM (Gemini) as a \"referee\" to validate the LLM's (DeepSeek) CoT. If the VLM and the LLM share the same misunderstanding of the user's prompt (e.g., they both misinterpret the meaning of \"chamfer\"), will the system \"confidently\" refine toward a wrong answer, because the referee (VLM) will incorrectly validate the executor's (LLM) flawed logic?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "The framework's key innovation is using a VLM to align the LLM's Chain-of-Thought (CoT) with step-wise visual renderings, thereby validating the design process rather than just the final product.\nDespite being training-free, Seek-CAD surpasses the fully fine-tuned CAD-Llama on key geometric metrics, proving the potential of its \"generate-verify-refine\" agent loop.\nThe system is a practical, self-contained solution, using a locally deployed LLM (DeepSeek-R1) and an essential local RAG corpus instead of relying on expensive, closed-source APIs.", "weaknesses": "The entire refinement loop's effectiveness hinges on the VLM's (Gemini-2.0) ability to accurately assess the alignment between the CoT and the step-wise images. The paper admits in its limitations (Sec 5) that VLMs can have biases or misunderstand complex geometry. If the VLM hallucinates or misinterprets (as seen in Fig 4b), it will provide faulty feedback, causing the LLM to make incorrect \"corrections.\"\n\n\nThe \"LLM $\\rightarrow$ Render $\\rightarrow$ VLM $\\rightarrow$ LLM\" loop is computationally slow. More critically, Table 2 shows that going from Round 1 to Round 2 of refinement yields marginal performance gains (e.g., IoGT only 0.72 $\\rightarrow$ 0.73) but causes the code compilation success rate (Pass@2) to drop sharply (from 0.72 to 0.55). This suggests multi-turn refinement may lead the LLM into a state of confusion or over-correction, breaking the code's validity.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)