Paper deep dive
IterCAD: Iterative Program Repair for CAD Code Generation from Orthographic Views
Yuchuan Wu, Ke Niu, Haiyang Yu, Zhuofan Chen, Xiangyang Xue, Bin Li
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/26/2026, 5:21:45 AM
Summary
The paper introduces IterCAD, an iterative framework for generating executable parametric CAD code from dimension-annotated orthographic views. Unlike one-shot methods, IterCAD reformulates the task as a progressive program repair process where the model iteratively analyzes current CAD results, reasons about discrepancies with target views, and decides whether to REVISE the code or STOP. The authors construct IterCAD-RS, a structured supervision set for revise-or-stop behavior, and employ a three-stage training strategy involving initial generation, revision learning, and multi-turn reinforcement learning optimization (GRPO). Experiments on the CADExpert benchmark demonstrate that IterCAD significantly improves code executability and geometric fidelity compared to strong one-shot baselines.
Entities (8)
Relation Signals (7)
IterCAD-RS → derivedfrom → CADExpert
confidence 95% · we construct IterCAD-RS, a structured supervision set built on top of the SFT training split of CADExpert
IterCAD → evaluatedon → CADExpert
confidence 95% · Experiments on CADExpert show that IterCAD consistently improves code executability and geometric fidelity
IterCAD → outperforms → one-shot baselines
confidence 95% · Experiments on CADExpert show that IterCAD consistently improves code executability and geometric fidelity over strong one-shot baselines.
IterCAD → uses → IterCAD-RS
confidence 95% · To make iterative repair learnable, we further construct IterCAD-RS... and develop a three-stage training strategy
IterCAD → optimizeswith → GRPO
confidence 90% · In Stage III, we further optimize the full multi-turn repair process with GRPO over sampled repair trajectories.
IterCAD → differsfrom → CAD-RL
confidence 85% · In contrast, our method focuses on iterative program revision... whereas existing RL-based CAD generation methods still primarily optimize the quality of the final generated program
IterCAD → differsfrom → CADCodeVerify
confidence 85% · Different from simply eliciting longer reasoning traces... In contrast to CADCodeVerify... our method adopts a unified iterative formulation
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Generating executable parametric CAD code from dimension-annotated orthographic drawings is a challenging task requiring geometric understanding, procedural reasoning, and precise numerical prediction. Existing vision-language approaches typically formulate this problem as one-shot generation, preventing the model from inspecting intermediate CAD results and correcting early mistakes, often leading to non-executable code or geometrically inconsistent outputs. In this paper, we propose IterCAD, an iterative framework that reformulates orthographic-view-to-CAD generation as a progressive program repair process. Instead of predicting the final CAD code in a single pass, IterCAD repeatedly analyzes the current CAD result, reasons about its discrepancy with the target views, and explicitly decides whether to REVISE the code or STOP the refinement process. To make iterative repair learnable, we further construct IterCAD-RS, a structured revise-or-stop supervision set containing both repairable intermediate CAD states and already-correct states, and develop a three-stage training strategy for initial generation, revision learning, and multi-turn RL optimization. By closing the loop between visual understanding, geometric verification, and code refinement, IterCAD progressively corrects structural and parametric errors. Experiments on CADExpert show that IterCAD consistently improves code executability and geometric fidelity over strong one-shot baselines.
Tags
Links
- Source: https://arxiv.org/abs/2608.24020v1
- Canonical: https://arxiv.org/abs/2608.24020v1
Trouble viewing inline? Open PDF directly →
Full Text
54,315 characters extracted from source content.
Expand or collapse full text
IterCAD: Iterative Program Repair for CAD Code Generation from Orthographic Views Yuchuan Wu email: ycwu24@m.fudan.edu.cn Affiliation: Fudan University, Shanghai, China , Ke Niu email: kniu22@m.fudan.edu.cn Affiliation: Fudan University, Shanghai, China , Haiyang Yu email: hyyu20@fudan.edu.cn Affiliation: ByteDance Inc., Shanghai, China , Zhuofan Chen email: zfchen23@m.fudan.edu.cn Affiliation: Fudan University, Shanghai, China , Xiangyang Xue email: xyxue@fudan.edu.cn Affiliation: Fudan University, Shanghai, China and Bin Li email: libin@fudan.edu.cn Affiliation: Fudan University, Shanghai, China Abstract. Generating executable CAD code from dimension-annotated orthographic drawings is a challenging task requiring geometric understanding, procedural reasoning, and precise numerical prediction. Existing vision-language approaches typically formulate this problem as one-shot generation, preventing the model from inspecting intermediate CAD results and correcting early mistakes, often leading to non-executable code or geometrically inconsistent outputs. In this paper, we propose IterCAD, an iterative framework that reformulates orthographic-view-to-CAD generation as a progressive program repair process. Instead of predicting the final CAD code in a single pass, IterCAD repeatedly analyzes the current CAD result, reasons about its discrepancy with the target views, and explicitly decides whether to REVISE the code or STOP the refinement process. To make iterative repair learnable, we further construct IterCAD-RS, a structured revise-or-stop supervision set containing both repairable intermediate CAD states and already-correct states, and develop a three-stage training strategy for initial generation, revision learning, and multi-turn RL optimization. By closing the loop between visual understanding, geometric verification, and code refinement, IterCAD progressively corrects structural and parametric errors. Experiments on CADExpert show that IterCAD consistently improves code executability and geometric fidelity over strong one-shot baselines. Keywords: Computer-Aided Design, CAD Code Generation, Large Vision-Language Models, Reinforcement Learning Figure 1. Comparison of one-shot CAD generation and IterCAD. While one-shot methods often fail to produce correct CAD programs, IterCAD progressively improves the program through iterative state assessment and revision.Comparison between one-shot CAD generation methods and IterCAD. One-shot methods may produce execution failures or incorrect geometry, while IterCAD repeatedly assesses and revises the current CAD program until obtaining a correct result. 1. Introduction As a fundamental tool in industrial design and manufacturing, Computer-Aided Design (CAD) (Sun et al., 2025) has long been essential for the digital creation of engineering products through formalized modeling languages. In modern production pipelines, design concepts are typically translated into precise and editable CAD models before fabrication, simulation, and downstream verification. As a result, automatically generating high-quality CAD code has become an important research problem with both academic significance and practical value. Compared with directly reconstructing low-level geometric representations such as point clouds, voxels, or meshes, generating parametric CAD code (Wu et al., 2021; Seff et al., 2021) is more aligned with real-world engineering requirements. CAD code is compact, editable, and semantically meaningful: it explicitly encodes the construction logic of a shape, supports downstream modification and validation, and can be directly integrated into industrial design workflows. Therefore, CAD code generation is not merely a 3D reconstruction problem, but a structured code generation task that requires both geometric understanding and procedural reasoning. From the perspective of practical design workflows, generating CAD code from orthographic engineering drawings is particularly meaningful (Wang et al., 2025). In real industrial scenarios, engineers commonly communicate geometric intent through orthographic projections with precise dimension annotations, rather than through free-form natural language descriptions. Such drawings naturally provide the structural and numerical information required for CAD modeling, making them a more realistic and scalable input modality for automatic CAD generation. However, converting dimension-annotated orthographic views into executable CAD code remains highly challenging, since the model must simultaneously infer the underlying 3D geometry, recover the correct sequence of modeling operations, and predict precise numerical parameters. Existing vision-language approaches (Wang et al., 2025; Niu et al., 2025b; Niu et al., 2026) have shown promising progress by directly mapping input drawings to CAD code in a one-shot manner. However, this paradigm suffers from an inherent limitation for orthographic-view-to-CAD generation. Generating correct CAD code is a strongly coupled sequential process: an early mistake in workplane selection, operation ordering, geometric topology, or dimensional prediction can propagate through subsequent steps and lead to invalid or geometrically inconsistent results. More importantly, once such an error is made, one-shot methods have no opportunity to inspect the generated result, identify the discrepancy with the target drawing, and revise the code accordingly. As shown in Figure 1, existing one-shot methods may produce either non-executable code or incorrect geometry, while many failures in fact remain repairable if the model is allowed to check the current CAD result and refine it iteratively. We argue that this limitation is especially severe in the setting of dimension-annotated orthographic-view-to-CAD generation. Unlike tasks where approximate outputs may still be acceptable, CAD code generation demands strict executability and geometric faithfulness. A small deviation in a hole diameter, extrusion depth, or Boolean operation may render the code unusable or significantly alter the final shape. At the same time, CAD code generation also presents a favorable property for iterative refinement: intermediate outputs take the form of executable CAD code that can be inspected, compared against the target views, and further revised. This suggests that CAD code generation should not be treated as a single-pass prediction problem, but rather as a progressive refinement process in which the model can repeatedly examine its current result and correct its own mistakes. Based on this insight, we propose IterCAD, an iterative framework for CAD code generation from dimension-annotated orthographic drawings. Instead of producing the final answer in one step, IterCAD enables the model to repeatedly analyze the current CAD result, reason about its mismatch with the target views, and explicitly decide whether to REVISE the code or STOP the refinement process. To make such iterative repair learnable, we further construct IterCAD-RS, a structured revise-or-stop supervision set, and develop a dedicated three-stage training recipe for initial generation, revision learning, and multi-turn policy optimization. By closing the loop between visual understanding, geometric verification, and code revision, IterCAD progressively corrects both structural and parametric errors, leading to more accurate and executable CAD reconstruction. Different from simply eliciting longer reasoning traces, IterCAD introduces a structured iterative paradigm tailored to the characteristics of CAD modeling. It allows the model to recover from erroneous initial generations, refine nearly correct CAD code with subtle dimensional inconsistencies, and terminate the process explicitly once sufficient consistency has been achieved. Extensive experiments demonstrate that IterCAD consistently improves both executability and geometric accuracy over strong one-shot baselines. Table 1. Perturbation taxonomy used to construct IterCAD-RS. Starting from a correct structured CAD state (ShapeSpec), we inject one or two geometric perturbations to synthesize executable but geometrically inconsistent intermediate states for revise-or-stop supervision. Structural Family Perturbation Target Representative Operations Typical Resulting Errors Body-level Sketch plane Change XY/YZ/XZ workplane Wrong global orientation or projection mismatch Body-level Base profile geometry Modify primitive type, polygon side count, or profile scale Incorrect outer silhouette or overall geometry Body-level Extrusion parameter Modify extrusion height or depth Incorrect thickness or global dimensions cut Inner profile geometry Change inner profile type or size Wrong cavity shape or incorrect inner dimensions cut Modifier existence Remove the cut operation Missing inner structure hole_pattern Hole multiplicity Increase or decrease the number of holes Incorrect hole count hole_pattern Hole layout Modify radial offset or distribution radius Wrong hole arrangement hole_pattern Hole size / existence Change hole diameter or remove the pattern Incorrect or missing hole structure edge_finish Finish type Switch between fillet and chamfer Incorrect edge treatment edge_finish Finish magnitude / existence Modify finish value or remove the operation Wrong or missing local edge detail Topology-level Modifier insertion Add an extra cut, hole_pattern, or edge_finish Spurious geometric structure Our main contributions are summarized as follows: • We reformulate dimension-annotated orthographic-view-to-CAD generation as an iterative program repair problem, in which the model operates on executable intermediate CAD states and learns to make explicit REVISE/STOP decisions. To support this formulation, we construct IterCAD-RS, a structured revise-or-stop supervision set containing both repairable CAD states paired with REVISE targets and already-correct CAD states paired with STOP targets. • We propose IterCAD, a unified iterative framework that integrates discrepancy-aware reasoning, explicit revise-or-stop decision-making, and iterative CAD code refinement in a closed loop. Building on this framework, we develop a dedicated three-stage training recipe that progressively teaches the model initial CAD generation, intermediate-state revision, and multi-turn self-repair policy optimization. • Extensive experiments on CADExpert (Niu et al., 2025b) show that IterCAD consistently outperforms strong one-shot baselines in both code executability and geometric fidelity. Further analyses verify the effectiveness of the iterative program repair formulation, IterCAD-RS, and the proposed three-stage training strategy. 2. Related Work 2.1. CAD Code Generation from Visual Inputs Large vision-language models have demonstrated substantial value across diverse application domains (Peng et al., 2025; Fu et al., 2026; Niu et al., 2025c; Fu et al., 2023; Yu et al., 2025a; Yu et al., 2025b; Yu et al., 2023). Building on these advances, recent research has increasingly explored their potential for CAD code generation. CAD code generation aims to produce executable and editable 3D design programs directly from user inputs, such as text descriptions, images, or engineering drawings (Xu et al., 2024; Alrashedy et al., 2024; Guan et al., 2025; Alam and Ahmed, 2024; Qin et al., 2025). Compared with general code generation, this task requires not only structured program prediction but also accurate spatial reasoning, geometric consistency, and numerical precision. Even small structural or parametric errors may lead to non-executable programs or geometries that deviate substantially from the target design. Recent studies have explored CAD generation from visual inputs under different formulations. CAD-MLLM (Xu et al., 2024) and GenCAD (Alam and Ahmed, 2024) use vision-language models to directly translate visual inputs into CAD commands or programs, enabling end-to-end visual-to-code generation. Img2CAD (Chen et al., 2025) adopts a two-stage framework that decouples structure prediction from parameter regression, improving flexibility in program synthesis. CAD2Program (Wang et al., 2025) introduces a more expressive code representation to better support complex CAD construction. CAD-Llama (Li et al., 2025) and CAD-Coder (Guan et al., 2025) further improve structured parametric CAD generation through hierarchical annotations or expert-designed intermediate descriptions. Beyond direct visual-to-code prediction, some works have begun to incorporate verification or improvement mechanisms into CAD generation. In particular, CADCodeVerify (Alrashedy et al., 2024) introduces an automated verification-and-improvement pipeline in which a pre-trained vision-language model inspects the rendered CAD result, generates and answers validation questions, and feeds the resulting feedback back to the generator for refinement. This line of work shows that CAD generation can benefit from going beyond pure one-shot prediction, especially since generated CAD programs are structured, executable, and amenable to downstream checking. Nevertheless, existing approaches still mainly treat refinement as an external feedback step applied to the generated final program, rather than explicitly modeling CAD generation itself as a learned multi-turn repair process over intermediate executable states. In contrast to CADCodeVerify, which relies on prompting-based automated verification at inference time, our method adopts a unified iterative formulation in which the model directly operates on intermediate CAD states, progressively revises them, and explicitly learns a revise-or-stop policy for adaptive refinement. 2.2. Reinforcement Learning in CAD Generation Reinforcement learning (Sutton, 1988; Watkins and Dayan, 1992; Sutton et al., 1999; Schulman et al., 2015; Schulman et al., 2017; Mnih et al., 2016; Jia et al., 2025) has recently emerged as a promising direction for improving CAD code generation beyond standard supervised fine-tuning (Niu et al., 2025a). Instead of relying solely on next-token prediction, RL-based methods optimize generated CAD programs with task-specific objectives, such as executability, geometric accuracy, and alignment with design intent. Among existing works, CAD-RL (Niu et al., 2026) is a representative effort in this direction. It introduces a multimodal chain-of-thought-guided reinforcement learning framework for precise CAD code generation, showing that reward-driven optimization can substantially improve the numerical accuracy, executability, and reasoning quality of generated CadQuery programs. This line of work highlights the value of incorporating execution-aware and geometry-aware feedback into CAD generation. However, existing RL-based CAD generation methods still primarily optimize the quality of the final generated program, rather than explicitly modeling generation as a multi-turn repair process over intermediate executable CAD states. In contrast, our method focuses on iterative program revision, where the model repeatedly inspects the current CAD result, decides whether to REVISE or STOP, and performs adaptive multi-step correction accordingly. 3. Iterative Repair Formulation and IterCAD-RS Construction Orthographic-view-to-CAD generation is naturally suited to an iterative program repair paradigm, since intermediate CAD code is executable and can be further revised based on discrepancies with the target orthographic views. In this section, we first formulate the task as a multi-turn revise-or-stop process, and then describe the construction of IterCAD-RS, a structured revise-or-stop supervision set for iterative program repair. 3.1. Multi-turn Program Repair Formulation We formulate orthographic-view-to-CAD generation as an iterative program repair process rather than a one-shot prediction problem. Given the input orthographic views x, the model progressively refines CAD code over multiple turns until it decides to stop. The initial state is defined as (1) s0=(x,EMPTY),s_0=(x, EMPTY), where no CAD code has been generated yet. At turn t, the state is defined as (2) st=(x,ht−1),s_t=(x,h_t-1), where ht−1h_t-1 denotes the interaction history available before turn t. In our setting, this history contains the model outputs from previous turns, including the generated <think> rationale, the <decision>, and the current cad <code>. Therefore, the model does not merely revise the latest CAD code in isolation, but performs the next repair step by conditioning on its own earlier reasoning process, decisions, and current code state. At each turn t, the model outputs a structured response (3) ot=(rt,at,yt),o_t=(r_t,a_t,y_t), where rtr_t denotes the <think> rationale, at∈REVISE,STOPa_t∈\ REVISE, STOP\ is the decision in the <decision> field, and yty_t is the CAD code in the <code> field. The interaction history is updated as (4) ht=ht−1⊕ot,h_t=h_t-1 o_t, where ⊕ denotes appending the current-turn output to the history. If at=REVISEa_t= REVISE, the updated CAD code yty_t is used as the input state for the next turn; if at=STOPa_t= STOP, the iterative process terminates and yty_t is taken as the final prediction. The trajectory terminates when (5) at=STOPort=Tmax.a_t= STOP t=T_ . This formulation highlights several important properties of our setting. First, intermediate outputs are structured and executable intermediate states rather than transient text tokens, and can therefore support subsequent refinement. Second, stopping is modeled as a learned action instead of a hand-crafted post-processing rule, enabling the model to adapt the number of refinement steps to the difficulty of each sample. More broadly, this formulation internalizes the core steps of CAD generation—reasoning over the input views, evaluating the current code state, deciding whether further correction is needed, and producing the next revision—within a single unified model, rather than relying on external verification tools or manually designed control heuristics. In this sense, IterCAD goes beyond one-shot CAD code prediction toward a more adaptive and self-refining paradigm for CAD code generation. 3.2. IterCAD-RS: Structured Revise-or-Stop Supervision for Iterative Program Repair A key supervision bottleneck for iterative program repair is that standard orthographic-view-to-CAD datasets provide only the final correct CAD code, but not the intermediate states needed for learning revise-or-stop behavior. To address this, we construct IterCAD-RS, a structured supervision set built on top of the SFT training split of CADExpert (Niu et al., 2025b), which augments each ground-truth sample with both repairable intermediate states and positive stopping states. Specifically, instead of perturbing raw code strings directly, we first convert each correct CadQuery program into a structured geometric state representation, denoted as ShapeSpec, and then apply controlled semantic perturbations in this space to synthesize executable but geometrically inconsistent intermediate states. These perturbations cover both body-level and modifier-level attributes, producing realistic errors that remain executable while deviating from the target orthographic views, as summarized in Table 1. We further apply validity-preserving filtering to remove degenerate or unchanged cases. For each synthesized wrong state, we pair it with the original correct target and automatically generate a short repair description, denoted as fix_text, which serves as supervision for the <think> field. This yields revision samples of the form (views,wrong code)→(repair rationale,REVISE,correct code),(views,wrong code)→(repair rationale, REVISE,correct code), while correct or semantically equivalent executable states are used to construct STOP supervision. In this way, IterCAD-RS provides explicit supervision for both intermediate revision and termination behavior. More details on perturbation design, filtering rules, and data statistics are provided in the supplementary material. 4. Methodology Figure 2. Overview of IterCAD. Stage I learns first-turn initial draft generation from dimension-annotated orthographic views. Stage I learns structured revise-or-stop behavior from intermediate CAD states. Stage I further optimizes the full multi-turn repair process with GRPO over sampled repair trajectories, yielding a unified iterative policy for initial generation, revision, and adaptive stopping. 4.1. Overview of IterCAD As illustrated in Figure 2, IterCAD formulates orthographic-view-to-CAD generation as an iterative program repair process rather than a one-shot prediction problem. The overall framework consists of three training stages. In Stage I, the model learns to generate an initial CAD draft from dimension-annotated orthographic views, establishing the basic vision-to-code mapping. In Stage I, the model learns revise-or-stop behavior from intermediate CAD states: given the target views together with a current CAD state, it reasons about the mismatch between the current CAD code and the target specification, and outputs either a STOP decision if the current code is already satisfactory or a REVISE decision followed by updated CAD code otherwise. In Stage I, we further optimize the full multi-turn repair process with GRPO over sampled repair trajectories. While the first two stages equip the model with the basic capabilities for initial generation and intermediate revision, they do not by themselves ensure that the model can effectively coordinate these abilities over a multi-turn process. By optimizing over diverse sampled trajectories, Stage I encourages the model to jointly leverage prior generation and revision knowledge, learn when additional refinement is truly beneficial, and decide when the current state is sufficient to terminate. 4.2. Training Data The three training stages of IterCAD use different but complementary forms of supervision, all built upon CADExpert (Niu et al., 2025b), an industrial-oriented benchmark for executable and editable CAD code generation. Each sample in CADExpert contains dimension-annotated orthographic views together with the corresponding executable CADQuery code, providing the basic supervision for orthographic-view-to-CAD learning. In Stage I, we directly use 8,960 standard orthographic-view-to-CAD pairs from the SFT training split of CADExpert to train the model for initial CAD code generation. In Stage I, we further construct IterCAD-RS on top of this split, yielding 22,000 structured revise-or-stop supervision samples derived from intermediate CAD states. In Stage I, we use an additional 4,480 training samples for multi-turn RL optimization. The data used in Stage I is disjoint from that used in Stages I and I. Overall, the training data progresses from direct generation supervision, to structured revise-or-stop supervision, and finally to trajectory-level optimization. More details on data construction are provided in the supplementary material. 4.3. Three-stage Training Recipe As illustrated in Figure 2, IterCAD is trained with a three-stage recipe rather than end-to-end joint optimization from scratch. This design is motivated by the observation that initial CAD draft generation, revise-or-stop decision making, and full multi-turn self-correction are related but distinct capabilities. While the first two stages provide the model with the basic abilities for initial generation and intermediate repair, they do not by themselves ensure effective coordination of these abilities during iterative inference. Therefore, we progressively train the model from supervised initial drafting, to structured revise-or-stop learning, and finally to trajectory-level RL optimization, yielding a more stable and effective training process for iterative program repair. 4.3.1. Stage I: Initial Draft Generation In Stage I, we train the model to produce the first-turn structured response from the input orthographic views. Different from standard one-shot CAD code generation, the model does not directly output only the final CAD code. Instead, it is trained under the same interaction format used in later stages, where the current CAD state is initialized as empty and the model performs the first revision step accordingly. Formally, given the input orthographic views x and an empty initial code state, the model predicts (6) (x,EMPTY)→(r1,REVISE,y1),(x, EMPTY)→(r_1, REVISE,y_1), where r1r_1 denotes the <think> rationale and y1y_1 denotes the CAD code in the <code> field. Since no valid CAD code exists at the first turn, the decision is always set to REVISE, and the model is required to generate an initial executable CAD draft. This stage serves two purposes. First, it establishes the basic vision-to-code capability from dimension-annotated orthographic views. Second, by aligning the output format with the later revise-or-stop stages, it provides a consistent initialization for iterative program repair, so that subsequent stages can directly build on the same structured interaction pattern. 4.3.2. Stage I: Revision/Stop Supervision In Stage I, we train the model with structured revise-or-stop supervision on intermediate CAD states. Given the target orthographic views x together with the interaction history ht−1h_t-1, the model predicts a structured output (7) (x,ht−1)→(rt,at,yt),(x,h_t-1)→(r_t,a_t,y_t), where rtr_t denotes the <think> rationale, at∈REVISE,STOPa_t∈\ REVISE, STOP\ is the decision in the <decision> field, and yty_t denotes the CAD code in the <code> field. Here, ht−1h_t-1 contains the model outputs from previous turns, including the generated rationale, decision, and current CAD code. Therefore, the model does not revise the current code in isolation, but predicts the next action by conditioning on its own earlier reasoning process, decisions, and code state. The supervision used in this stage is provided by IterCAD-RS, which contains two complementary types of samples: revision samples, where executable but geometrically inconsistent intermediate states are paired with repair rationales, REVISE decisions, and corrected CAD code; and stopping samples, where already-correct or semantically equivalent executable states are paired with STOP decisions. In this way, Stage I teaches the model not only how to perform targeted correction when geometric discrepancies exist, but also how to decide when the current state is already sufficient to terminate. Importantly, the training targets preserve the same structured output protocol used at inference time, namely <think>, <decision>, and <code>. As a result, Stage I equips the model with the core abilities required for iterative program repair: interpreting intermediate states, producing explicit revise-or-stop decisions, and generating updated CAD code in a unified format. 4.3.3. Stage I: Multi-turn RL Optimization After the first two supervised stages, the model has acquired the basic abilities required for iterative CAD repair, including initial draft generation, intermediate-state revision, and explicit stopping. However, supervised training alone does not guarantee that the model can effectively coordinate these abilities during multi-turn inference. In particular, while Stage I and Stage I teach the model how to generate, revise, and stop under supervised targets, they do not by themselves ensure that these behaviors will be integrated into a coherent repair policy over full trajectories. To address this, in Stage I we further optimize the complete multi-turn repair process using GRPO (Shao et al., 2024). Starting from an initial CAD draft, the model interacts with its own intermediate CAD states and produces a repair trajectory (8) τ=(s0,o1,s1,…,oT,sT),τ=(s_0,o_1,s_1,…,o_T,s_T), where each turn output oto_t follows Eq. (3). The Stage I objective is to maximize the expected trajectory-level reward (9) maxπθτ∼πθ[R(τ)], _ _θ\ E_τ _θ [R(τ) ], where R(τ)R(τ) evaluates the overall quality of the multi-turn repair process. A key property of this stage is that optimization is performed over sampled multi-turn trajectories instead of isolated single-step corrections. This is important in our setting, since IterCAD is intended to learn a revise-or-stop policy over executable intermediate CAD states, rather than a final-step correction heuristic. By optimizing Eq. (9) over diverse sampled trajectories, GRPO encourages the model to jointly leverage the generation and revision knowledge acquired in the previous stages, learn when further refinement is beneficial, and decide when the current state is already sufficient to terminate. As a result, Stage I turns the model from a supervised reviser into a true multi-turn iterative repair policy. Table 2. Main results on CADExpert. IterCAD-Q3VL and IterCAD-Q3.5 denote our method instantiated with Qwen3-VL-8B-Instruct and Qwen3.5-9B, respectively. Best results are shown in bold, and second-best results are underlined. Model IoU (%) ↑ Mean CD ↓ Med CD ↓ Exec. (%) ↑ LLaVA-1.5 (Liu et al., 2024) 0.73 29.36 8.14 4.79 Phi-3.5-Vision (Abdin et al., 2024) 3.44 27.92 7.75 8.50 InternVL2.5 (Chen et al., 2024) 11.98 22.27 7.36 23.92 Qwen2.5-VL (Bai et al., 2025b) 19.21 20.68 6.64 31.27 InternVL3 (Zhu et al., 2025) 24.59 21.40 6.62 29.68 Gemini2.5 Pro (Comanici et al., 2025) 30.86 14.13 5.97 39.40 GPT5-Mini (Singh et al., 2025) 35.15 9.89 4.81 47.13 Doubao-1.6 (Guo et al., 2025) 35.62 7.54 4.35 52.89 Qwen3-VL (Bai et al., 2025a) 37.04 6.96 3.84 54.79 Qwen3.5 (Qwen Team, 2026) 43.91 5.36 3.17 59.61 CAD-RL (Niu et al., 2026) 71.84 1.38 0.36 97.32 CME-CAD (Niu et al., 2025b) 80.71 1.00 0.11 98.25 IterCAD-Q3VL 85.10 0.8564 0.1069 97.31 IterCAD-Q3.5 91.61 0.5387 0.1038 99.33 4.4. Reward Design To optimize IterCAD under the multi-turn revise-or-stop setting, we design a composite reward that combines final CAD quality, structural validity, and decision correctness. Since the last turn may output STOP without providing a new <code> block, we evaluate the trajectory using an effective final code, i.e., the CAD code corresponding to the terminal program state. If the last turn outputs REVISE with a valid <code> block, we use that code directly; otherwise, we trace back to the most recent valid CAD code in the trajectory history. Based on the effective final code, the overall reward is defined as (10) R=Rfinal+λfRformat+λsRsyntax+λdRdecision,R=R_final+ _fR_format+ _sR_syntax+ _dR_decision, where λf=0.10 _f=0.10, λs=0.05 _s=0.05, and λd=0.20 _d=0.20. Here, RfinalR_final serves as the dominant learning signal, while the remaining terms act as auxiliary regularizers. Specifically, RformatR_format measures whether the model follows the required structured interaction protocol, encouraging stable outputs in the <think>, <decision>, and <code> format. RsyntaxR_syntax focuses on code validity, rewarding syntactically well-formed executable code while serving only as a lightweight regularizer. RdecisionR_decision focuses on revise-or-stop behavior, encouraging the model to stop only when the current CAD state is already sufficiently good and discouraging premature stopping or invalid decisions. Finally, RfinalR_final evaluates the geometric quality of the effective final code and remains the primary optimization target throughout training. Overall, this reward is outcome-centric but behavior-aware: it prioritizes the correctness of the terminal CAD state while also regularizing the model to produce valid structured outputs and make appropriate stopping decisions. More detailed definitions and implementation details are provided in the supplementary material. 5. Experiments 5.1. Dataset and Metrics We conduct all experiments on CADExpert (Niu et al., 2025b), an industrial-oriented benchmark for executable and editable CAD code generation, following its standard benchmark setting for orthographic-view-to-CAD generation. Following prior work (Niu et al., 2025b), we evaluate model performance using four complementary metrics: Intersection-over-Union (IoU), Mean Chamfer Distance (Mean CD), Median Chamfer Distance (Med CD), and Executability (Exec.). IoU measures volumetric overlap between predicted and reference shapes, Mean CD and Med CD measure geometric discrepancy in point cloud space, and Executability measures whether the generated CAD code can be successfully executed. Higher values are better for IoU and Exec., while lower values are better for Mean CD and Med CD. 5.2. Implementation Details We evaluate IterCAD on two backbone models: Qwen3.5-9B (Qwen Team, 2026) and Qwen3-VL-8B-Instruct (Team, 2025). For both backbones, we adopt the same three-stage training recipe, where the Stage I checkpoint initializes Stage I, and the Stage I checkpoint further initializes Stage I. Stage I and Stage I are trained with supervised fine-tuning, while Stage I is optimized with GRPO. Unless otherwise specified, all three stages use a learning rate of 1×10−51× 10^-5 and are trained for one epoch. For Stage I, we use 44 rollouts per training sample, and set the maximum number of refinement turns to 44. The same rollout setting is used for both backbone models. At inference time, the model follows the same iterative repair protocol as in training. Given the input orthographic views, it first produces an initial CAD draft and then iteratively predicts either REVISE or STOP. The process terminates when the model outputs STOP or when the maximum number of refinement rounds reaches 44. No external stopping heuristic is used. For the main benchmark results, both backbone models are evaluated under the same training and inference pipeline. 5.3. Main Results Table 2 reports the main results on CADExpert. IterCAD achieves the best overall performance, with IterCAD-Q3.5 ranking first on all four metrics. Specifically, it reaches 91.61% IoU, 0.5387 Mean CD, 0.1038 Med CD, and 99.33% executability, establishing a new state of the art for orthographic-view-to-CAD generation. Compared with the strong multi-expert baseline CME-CAD, IterCAD-Q3.5 improves IoU from 80.71% to 91.61%, reduces Mean CD from 1.00 to 0.5387, and increases executability from 98.25% to 99.33%. While CME-CAD strengthens one-shot generation through expert decomposition, IterCAD uses a unified model to iteratively inspect and repair executable intermediate CAD states. The substantial improvement therefore suggests that explicit self-correction is more effective than strengthening single-pass prediction alone. This conclusion is further supported by IterCAD-Q3VL. Despite using the lighter Qwen3-VL-8B-Instruct backbone, it surpasses CME-CAD on all geometric metrics, achieving 85.10% IoU, 0.8564 Mean CD, and 0.1069 Med CD while maintaining high executability. The consistent gains across two backbones indicate that the improvement primarily comes from the iterative repair formulation rather than a particular model architecture. This robustness is particularly important because the two backbones differ in capacity and pretraining, yet benefit from the same repair strategy. Compared with general-purpose pretrained VLMs, both specialized CAD methods retain a large advantage, confirming the need for task-specific modeling of geometry, code structure, and executability. Moreover, the gains span both geometric overlap and execution reliability, indicating that iterative refinement improves not only accuracy but also practical usability. Overall, IterCAD improves geometric fidelity without sacrificing code validity, supporting multi-turn repair as an effective alternative to one-shot CAD code generation. Table 3. Ablation study of IterCAD on CADExpert. S1, S2, and S3 denote Stages I, I, and I, respectively, and MT denotes multi-turn inference. Best results are shown in bold. S1 S2 S3 MT IoU (%) ↑ Mean CD ↓ Med CD ↓ Exec. (%) ↑ Base model: Qwen3.5-9B ✓ × × × 57.42 3.5819 0.1939 96.39 ✓ ✓ × × 54.46 3.4506 0.3520 93.65 ✓ ✓ × ✓ 60.40 2.8102 0.1590 93.37 ✓ × ✓ ✓ 64.26 2.6319 0.1448 94.28 ✓ ✓ ✓ × 89.91 0.7492 0.1193 98.51 ✓ ✓ ✓ ✓ 91.61 0.5387 0.1038 99.33 Base model: Qwen3-VL-8B-Instruct ✓ × × × 37.37 5.1648 3.9749 85.48 ✓ ✓ × ✓ 28.30 5.8017 5.4882 79.87 ✓ ✓ ✓ × 83.17 1.1057 0.1493 96.38 ✓ ✓ ✓ ✓ 85.10 0.8564 0.1069 97.31 Figure 3. Iterative repair behavior on CADExpert. (a) Round-wise IoU. (b) Cumulative stopping ratios by refinement turn. (c) Average inference time under one-turn and multi-turn settings.Three plots compare IterCAD across refinement turns. The first shows increasing IoU, the second shows that most samples stop within the early turns, and the third compares one-turn and multi-turn inference time for the two backbones. 5.4. Ablation Studies Table 3 reports the ablation results of IterCAD on CADExpert. The full configuration consistently achieves the best performance on both backbones, showing that the three-stage training recipe and multi-turn inference are all important to the final gains. A notable observation is that the improvement cannot be explained simply by using more supervision. For example, adding Stage I does not directly improve performance over Stage I under single-turn inference, and can even hurt both accuracy and executability. This suggests that Stage I introduces a more structured but also more challenging learning problem: it teaches the model to interpret intermediate CAD states and predict revise-or-stop behavior, but these abilities are not yet fully utilized when inference is restricted to a single pass. Importantly, once multi-turn inference is enabled, the Stage I+I model becomes clearly stronger than its single-turn counterpart. On Qwen3.5-9B, adding multi-turn inference to the Stage I+I setting improves IoU from 54.46 to 60.40 while also reducing both mean and median Chamfer Distance. This result provides early evidence for the validity of our formulation: although Stage I alone does not immediately improve one-shot generation, it equips the model with intermediate-state revision ability that becomes useful when the model is actually allowed to refine its prediction across turns. Stage I is therefore crucial. It turns locally supervised generation and revision abilities into a coherent trajectory-level repair policy. This effect is already visible in the Stage I+I setting on Qwen3.5-9B, which outperforms Stage I alone, indicating that trajectory-level optimization can already activate useful repair behavior. However, the full model still performs much better, showing that Stage I and Stage I are complementary: Stage I provides explicit supervision on intermediate repair, while Stage I teaches the model how to coordinate generation, revision, and stopping across turns. Finally, comparing the full model with and without multi-turn inference shows that the learned iterative policy remains useful at test time. Enabling multi-turn inference consistently improves both geometric metrics and executability on the two backbones. This confirms that IterCAD does not benefit only from better training, but also from refining intermediate CAD states during inference. 5.5. Multi-turn Inference Analysis To better understand how IterCAD behaves at test time, we analyze the quality progression, stopping behavior, and inference efficiency of multi-turn inference in Figure 3. Several clear patterns can be observed. First, iterative refinement consistently improves geometric quality across turns. As shown in Figure 3(a), IoU increases monotonically for both backbones as the refinement proceeds. For IterCAD-Q3.5, IoU improves from 89.91 at Turn 1 to 91.61 at Turn 4, while for IterCAD-Q3VL it increases from 83.17 to 85.10. Most of the gain is obtained in the early turns, especially from Turn 1 to Turn 2, while later turns provide smaller but still consistent improvements. This indicates that the model is able to correct major errors early and then make finer adjustments in later rounds. Second, the stopping behavior is highly adaptive rather than uniform. Figure 3(b) shows that most samples terminate within the first two or three turns. For IterCAD-Q3.5, 90.8% of samples stop by Turn 2 and 98.9% by Turn 3; for IterCAD-Q3VL, the corresponding ratios are 88.4% and 96.5%. Only a very small fraction of samples require all four turns. This result suggests that the learned stopping policy is effective: the model does not simply run for the maximum number of steps, but instead adjusts the refinement depth according to the difficulty of the current sample. Finally, the additional cost of multi-turn inference remains moderate. As shown in Figure 3(c), the average inference time increases from 0.338 s to 0.397 s per sample for IterCAD-Q3.5, and from 0.258 s to 0.435 s for IterCAD-Q3VL, when switching from one-turn to multi-turn inference. Combined with the cumulative stopping statistics, this shows that the computational overhead of iterative repair is bounded in practice, since most samples terminate early. Overall, these results indicate that IterCAD achieves a favorable trade-off between refinement quality and inference efficiency: multi-turn inference yields consistent gains, while adaptive stopping prevents unnecessary computation. More qualitative examples of the iterative repair process, including step-by-step reasoning and CAD refinement trajectories, are provided in the supplementary material. 6. Conclusion In this paper, we presented IterCAD, an iterative program repair framework for CAD code generation from dimension-annotated orthographic views. Instead of treating orthographic-view-to-CAD generation as a one-shot prediction problem, IterCAD reformulates it as a multi-turn revise-or-stop process over executable intermediate CAD states. To make such iterative repair learnable, we further introduced IterCAD-RS, a structured revise-or-stop supervision set, together with a three-stage training recipe for initial draft generation, intermediate revision learning, and multi-turn RL optimization. Experiments on CADExpert show that IterCAD consistently improves both geometric fidelity and code executability over strong baselines. Further ablation and multi-turn inference analyses verify that these gains come from the coordinated effect of structured intermediate supervision, trajectory-level optimization, and adaptive stopping. Overall, our results suggest that orthographic-view-to-CAD generation is better modeled as an iterative repair problem than as a one-shot generation task, and highlight the value of self-refining generation for executable CAD modeling. Acknowledgements. This work was supported by the Program for Professor of Special Appointment (Eastern Scholar) at Shanghai Institutions of Higher Learning (Grant No. GZ2022001). References Abdin et al. (2024) M. Abdin, J. Aneja, H. Awadalla, A. Awadallah, A. A. Awan, N. Bach, A. Bahree, A. Bakhtiari, J. Bao, H. Behl, A. Benhaim, M. Bilenko, J. Bjorck, S. Bubeck, M. Cai, Q. Cai, V. Chaudhary, D. Chen, D. Chen, W. Chen, Y. Chen, Y. Chen, H. Cheng, P. Chopra, X. Dai, M. Dixon, R. Eldan, V. Fragoso, J. Gao, M. Gao, M. Gao, A. Garg, A. D. Giorno, A. Goswami, S. Gunasekar, E. Haider, J. Hao, R. J. Hewett, W. Hu, J. Huynh, D. Iter, S. A. Jacobs, M. Javaheripi, X. Jin, N. Karampatziakis, P. Kauffmann, M. Khademi, D. Kim, Y. J. Kim, L. Kurilenko, J. R. Lee, Y. T. Lee, Y. Li, Y. Li, C. Liang, L. Liden, X. Lin, Z. Lin, C. Liu, L. Liu, M. Liu, W. Liu, X. Liu, C. Luo, P. Madan, A. Mahmoudzadeh, D. Majercak, M. Mazzola, C. C. T. Mendes, A. Mitra, H. Modi, A. Nguyen, B. Norick, B. Patra, D. Perez-Becker, T. Portet, R. Pryzant, H. Qin, M. Radmilac, L. Ren, G. de Rosa, C. Rosset, S. Roy, O. Ruwase, O. Saarikivi, A. Saied, A. Salim, M. Santacroce, S. Shah, N. Shang, H. Sharma, Y. Shen, S. Shukla, X. Song, M. Tanaka, A. Tupini, P. Vaddamanu, C. Wang, G. Wang, L. Wang, S. Wang, X. Wang, Y. Wang, R. Ward, W. Wen, P. Witte, H. Wu, X. Wu, M. Wyatt, B. Xiao, C. Xu, J. Xu, W. Xu, J. Xue, S. Yadav, F. Yang, J. Yang, Y. Yang, Z. Yang, D. Yu, L. Yuan, C. Zhang, C. Zhang, J. Zhang, L. L. Zhang, Y. Zhang, Y. Zhang, Y. Zhang, and X. Zhou Phi-3 technical report: a highly capable language model locally on your phone. External Links: 2404.14219, Link Cited by: Table 2. Alam and Ahmed (2024) M. F. Alam and F. Ahmed Gencad: image-conditioned computer-aided design generation with transformer-based contrastive representation and diffusion priors. arXiv preprint arXiv:2409.16294. Cited by: §2.1, §2.1. Alrashedy et al. (2024) K. Alrashedy, P. Tambwekar, Z. Zaidi, M. Langwasser, W. Xu, and M. Gombolay Generating cad code with vision-language models for 3d designs. arXiv preprint arXiv:2410.05340. Cited by: §2.1, §2.1. Bai et al. (2025a) S. Bai, Y. Cai, R. Chen, K. Chen, X. Chen, Z. Cheng, L. Deng, W. Ding, C. Gao, C. Ge, et al. Qwen3-vl technical report. arXiv preprint arXiv:2511.21631. Cited by: Table 2. Bai et al. (2025b) S. Bai, K. Chen, X. Liu, J. Wang, W. Ge, S. Song, K. Dang, P. Wang, S. Wang, J. Tang, H. Zhong, Y. Zhu, M. Yang, Z. Li, J. Wan, P. Wang, W. Ding, Z. Fu, Y. Xu, J. Ye, X. Zhang, T. Xie, Z. Cheng, H. Zhang, Z. Yang, H. Xu, and J. Lin Qwen2.5-vl technical report. External Links: 2502.13923, Link Cited by: Table 2. Chen et al. (2025) T. Chen, C. Yu, Y. Hu, J. Li, T. Xu, R. Cao, L. Zhu, Y. Zang, Y. Zhang, Z. Li, et al. Img2cad: conditioned 3-d cad model generation from single image with structured visual geometry. IEEE Transactions on Industrial Informatics. Cited by: §2.1. Chen et al. (2024) Z. Chen, W. Wang, Y. Cao, Y. Liu, Z. Gao, E. Cui, J. Zhu, S. Ye, H. Tian, Z. Liu, et al. Expanding performance boundaries of open-source multimodal models with model, data, and test-time scaling. arXiv preprint arXiv:2412.05271. Cited by: Table 2. Comanici et al. (2025) G. Comanici, E. Bieber, M. Schaekermann, I. Pasupat, N. Sachdeva, I. Dhillon, M. Blistein, O. Ram, D. Zhang, E. Rosen, et al. Gemini 2.5: pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities. arXiv preprint arXiv:2507.06261. Cited by: Table 2. Fu et al. (2023) T. Fu, X. Wang, H. Yu, K. Niu, B. Li, and X. Xue Denoising-mot: towards multiple object tracking with severe occlusions. In Proceedings of the 31st ACM International Conference on Multimedia, p. 2734–2743. Cited by: §2.1. Fu et al. (2026) T. Fu, M. Zhao, K. Niu, K. Peng, and B. Li OmniPT: unleashing the potential of large vision language models for pedestrian tracking and understanding. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40, p. 4031–4039. Cited by: §2.1. Guan et al. (2025) Y. Guan, X. Wang, X. Xing, J. Zhang, D. Xu, and Q. Yu CAD-coder: text-to-cad generation with chain-of-thought and geometric reward. arXiv preprint arXiv:2505.19713. Cited by: §2.1, §2.1. Guo et al. (2025) D. Guo, F. Wu, F. Zhu, F. Leng, G. Shi, H. Chen, H. Fan, J. Wang, J. Jiang, J. Wang, et al. Seed1. 5-vl technical report. arXiv preprint arXiv:2505.07062. Cited by: Table 2. Jia et al. (2025) W. Jia, J. Lu, H. Yu, S. Wang, G. Tang, A. Wang, W. Yin, D. Yang, Y. Nie, B. Shan, H. Feng, I. Li, K. Yang, H. Wang, J. Tang, T. Fu, C. Jin, C. Feng, X. Lv, and C. Huang MEML-grpo: heterogeneous multi-expert mutual learning for rlvr advancement. External Links: 2508.09670, Link Cited by: §2.2. Li et al. (2025) J. Li, W. Ma, X. Li, Y. Lou, G. Zhou, and X. Zhou CAD-llama: 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, p. 18563–18573. Cited by: §2.1. Liu et al. (2024) H. Liu, C. Li, Y. Li, and Y. J. Lee Improved baselines with visual instruction tuning. External Links: 2310.03744, Link Cited by: Table 2. Mnih et al. (2016) V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu Asynchronous methods for deep reinforcement learning. In International conference on machine learning, p. 1928–1937. Cited by: §2.2. Niu et al. (2025a) K. Niu, Z. Chen, H. Yu, Y. Chen, T. Fu, M. Zhao, B. Li, and X. Xue Creft-cad: boosting orthographic projection reasoning for cad via reinforcement fine-tuning. arXiv preprint arXiv:2506.00568. Cited by: §2.2. Niu et al. (2025b) K. Niu, H. Yu, Z. Chen, Z. Yao, W. Jia, X. Ge, J. Tang, B. Cui, B. Li, and X. Xue Cme-cad: heterogeneous collaborative multi-expert reinforcement learning for cad code generation. arXiv preprint arXiv:2512.23333. Cited by: 3rd item, §1, §3.2, §4.2, Table 2, §5.1, §5.1. Niu et al. (2026) K. Niu, H. Yu, Z. Chen, M. Zhao, T. Fu, B. Li, and X. Xue From intent to execution: multimodal chain-of-thought reinforcement learning for precise cad code generation. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40, p. 8160–8167. Cited by: §1, §2.2, Table 2. Niu et al. (2025c) K. Niu, H. Yu, M. Zhao, T. Fu, S. Yi, W. Lu, B. Li, X. Qian, and X. Xue ChatReID: open-ended interactive person retrieval via hierarchical progressive tuning for vision language models. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 24245–24254. Cited by: §2.1. Peng et al. (2025) K. Peng, M. Zhao, H. Yu, T. Fu, and B. Li Interpretable oracle bone script decipherment through radical and pictographic analysis with lvlms. arXiv preprint arXiv:2508.10113. Cited by: §2.1. Qin et al. (2025) F. Qin, S. Lu, J. Hou, C. Wang, M. Fang, and L. Liu Drawing2CAD: sequence-to-sequence learning for cad generation from vector drawings. In Proceedings of the 33rd ACM International Conference on Multimedia, p. 10573–10582. Cited by: §2.1. Qwen Team (2026) Qwen Team Qwen3.5: towards native multimodal agents. External Links: Link Cited by: Table 2, §5.2. Schulman et al. (2015) J. Schulman, S. Levine, P. Abbeel, M. Jordan, and P. Moritz Trust region policy optimization. In International conference on machine learning, p. 1889–1897. Cited by: §2.2. Schulman et al. (2017) J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347. Cited by: §2.2. Seff et al. (2021) A. Seff, W. Zhou, N. Richardson, and R. P. Adams Vitruvion: a generative model of parametric cad sketches. arXiv preprint arXiv:2109.14124. Cited by: §1. Shao et al. (2024) Z. Shao, P. Wang, Q. Zhu, R. Xu, J. Song, X. Bi, H. Zhang, M. Zhang, Y. Li, Y. Wu, et al. Deepseekmath: pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300. Cited by: §4.3.3. Singh et al. (2025) A. Singh, A. Fry, A. Perelman, A. Tart, A. Ganesh, A. El-Kishky, A. McLaughlin, A. Low, A. Ostrow, A. Ananthram, et al. Openai gpt-5 system card. arXiv preprint arXiv:2601.03267. Cited by: Table 2. Sun et al. (2025) Y. Sun, X. Li, and Z. Sha Large language models for computer-aided design fine tuned: dataset and experiments. Journal of Mechanical Design 147 (4), p. 041710. Cited by: §1. Sutton et al. (1999) R. S. Sutton, D. McAllester, S. Singh, and Y. Mansour Policy gradient methods for reinforcement learning with function approximation. Advances in neural information processing systems 12. Cited by: §2.2. Sutton (1988) R. S. Sutton Learning to predict by the methods of temporal differences. Machine learning 3 (1), p. 9–44. Cited by: §2.2. Team (2025) Q. Team Qwen3 technical report. External Links: 2505.09388, Link Cited by: §5.2. Wang et al. (2025) X. Wang, J. Zheng, Y. Hu, H. Zhu, Q. Yu, and Z. Zhou From 2d cad drawings to 3d parametric models: a vision-language approach. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 7961–7969. Cited by: §1, §1, §2.1. Watkins and Dayan (1992) C. J. Watkins and P. Dayan Q-learning. Machine learning 8 (3), p. 279–292. Cited by: §2.2. Wu et al. (2021) R. Wu, C. Xiao, and C. Zheng Deepcad: a deep generative network for computer-aided design models. In Proceedings of the IEEE/CVF international conference on computer vision, p. 6772–6782. Cited by: §1. Xu et al. (2024) J. Xu, C. Wang, Z. Zhao, W. Liu, Y. Ma, and S. Gao Cad-mllm: unifying multimodality-conditioned cad generation with mllm. arXiv preprint arXiv:2411.04954. Cited by: §2.1, §2.1. Yu et al. (2023) H. Yu, X. Wang, B. Li, and X. Xue Chinese text recognition with a pre-trained clip-like model through image-ids aligning. In 2023 IEEE/CVF International Conference on Computer Vision (ICCV), Vol. , p. 11909–11918. External Links: Document Cited by: §2.1. Yu et al. (2025a) H. Yu, S. Yi, K. Niu, M. Zhuo, and B. Li UMIT: unifying medical imaging tasks via vision-language models. External Links: 2503.15892, Link Cited by: §2.1. Yu et al. (2025b) H. Yu, M. Zhao, J. Lu, K. Niu, Y. Wang, W. Yin, W. Jia, T. Fu, Y. Liu, J. Liu, and H. Chen EVE: towards end-to-end video subtitle extraction with vision-language models. External Links: 2503.04058, Link Cited by: §2.1. Zhu et al. (2025) J. Zhu, W. Wang, Z. Chen, Z. Liu, S. Ye, L. Gu, H. Tian, Y. Duan, W. Su, J. Shao, Z. Gao, E. Cui, X. Wang, Y. Cao, Y. Liu, X. Wei, H. Zhang, H. Wang, W. Xu, H. Li, J. Wang, N. Deng, S. Li, Y. He, T. Jiang, J. Luo, Y. Wang, C. He, B. Shi, X. Zhang, W. Shao, J. He, Y. Xiong, W. Qu, P. Sun, P. Jiao, H. Lv, L. Wu, K. Zhang, H. Deng, J. Ge, K. Chen, L. Wang, M. Dou, L. Lu, X. Zhu, T. Lu, D. Lin, Y. Qiao, J. Dai, and W. Wang InternVL3: exploring advanced training and test-time recipes for open-source multimodal models. External Links: 2504.10479, Link Cited by: Table 2.