acceptodds
Under review as a conference paper at ICLR 2027

VisCAD: A foundation model suite with multimodal industrial CAD intelligence

Abstract

AI-assisted computer-aided design (CAD) for industrial products involves two challenging phases. Part-level generation maps diverse forms of user intent, including renders, text descriptions, 2D drawings, and real photographs, to executable programs in a CAD domain-specific language. Assembly-level generation must additionally handle interacting parts, plan mating relations, estimate poses, and place all parts correctly. Existing specialized CAD models are commonly trained on narrow input domains (renders or texts) and often generalize poorly, while general-purpose frontier models cover broader inputs but perform inconsistently across CAD domains. We present \viscad, a foundation model suite designed to provide both broad generalization and strong CAD capability for realistic industrial products. In its core is \viscadm, a 27B model trained through mid-training and post-training for part-level design generation. On \pcb and \rcb, \viscadm achieves the highest average part-level score among the evaluated models, reaching 0.5540 compared with 0.5496 for the strongest frontier model. Reusing \viscadm as a test-time verifier can further raise the score to 0.5797, an approximately 5 percent relative improvement over the previous state of the art. \viscad also includes a domain-specific harness that leverages frontier models for complex assembly generation and demonstrates advantages over general-purpose harnesses in both quantitative and qualitative evaluations.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
AI CAD, Multimodal foundation model

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_88KJOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper focuses on CAD generation from multimodal design intent input. It trains a multimodal foundation model for part generation, develops a data construction pipeline and a multi-stage training strategy, and designs an agent framework for assembly tasks.

Critical strengths

Investigating CAD program generation from multimodal design intent inputs (text descriptions, engineering drawings, real product photographs, and rendered views) is a reasonable research direction.

Critical weaknesses
  1. Lines 90–93 mention a test-time scaling method (parallel-TTS) as one of the contributions. However, the paper does not describe how this method is designed and implemented.

  2. The description of the data curation pipeline is unclear. According to Section 4.1, Data CURATION PIPELINE, the data construction process consists of two paths: intent i → CAD program p → shape s, and shape s → CAD program p→ intent i. I have several questions regarding these two paths.

    • As mentioned in Lines 69–70, intent is multimodal, including text descriptions, engineering drawings, real product photographs, and rendered views. However, the description of the i→ p → s pipeline in Section 4.1 indicates that image editing is first applied to the intent. Does this step only apply to image-based intents? How are intents in the form of text descriptions and engineering drawings handled?

    • Line 232 states that the i → p → s pipeline searches for the nearest-neighbor CAD program (p) given an intent (i) and a shape (s). This is confusing. First, the process would seem more naturally structured as i → s → p. More importantly, how is the CAD program retrieved? Is there a library containing a large number of CAD programs without corresponding intent labels? If so, how to ensure that a suitable CAD program can always be found in this library for a given intent? If no such library exists, how is the CAD program search performed?

    • For the s → p→ i path, the main text provides only a brief description in Lines 233–234. This is an important part of the data construction process and deserves a more detailed explanation.

  3. The training pipeline in Section 4.2 is also confusing.

    • Lines 248–251 state that, during the Robust SFT stage, crawled product images are used as intents, and a teacher model is employed to generate multiple candidate CAD programs for the same intent. This raises several questions: Where does the teacher model come from? Do the crawled product images have corresponding ground-truth (GT) CAD programs? How is this training stage implemented?

    • The Continual High-quality SFT stage is described in only one sentence in Lines 251–252, making it difficult to understand how this stage is trained.

    • Furthermore, the paper states that intents include text descriptions, engineering drawings, real product photographs, and rendered views. However, the training pipeline in Section 4.2 mentions only image-based intents. How are text-description and engineering-drawing inputs incorporated into the training process?

  4. What metrics are reported in the main results table (Table 1)? The Design Artifacts and Metrics section does not adequately define or explain them.

Questions for authors

Please refer to the weaknesses

3 comments
AuthorsOpenReview ↗

Response to Reviewer 88KJ

Thank you for the review. We clarify the method using the existing descriptions and the concrete implementation details supplied below. The algorithm-level description and the remaining reproducibility details should be distinguished.

1. Parallel test-time scaling.

We respectfully disagree that parallel TTS lacks an algorithmic description.

Section 6.2 describes sequential refinement and parallel selection. In parallel selection, M1 generates k programs for the same intent and reuses itself as a listwise reranker over candidate programs and rendered geometry. Table 3 compares k=8 without thinking, k=8 with thinking, and k=16 with thinking; the text also reports that sequential refinement did not improve results. The core selection procedure and these comparisons are therefore present in the paper.

Recomputing the displayed rows gives base M1 0.5530 and the 16-candidate variant 0.5833, an increase of approximately 0.03037. The original base aggregate requires correction. This is an observed selection gain under the reported settings; it does not establish superiority to frontier models at equal sampling budgets. The exact prompt, sampling parameters, candidate packaging, and invalid-candidate handling still need documentation for reproduction.

2. Program search and data dependencies.

We maintain that the described search generates and refines programs rather than requiring library retrieval.

The described image-origin procedure normalizes visual evidence, obtains a proxy shape, and uses teacher generation, execution, and feedback to produce/refine a CAD program. It is a program-synthesis procedure and does not require a pre-existing nearest-neighbor program library. The proxy shape supplies a reference for checking the executed candidate; it can be constructed before the program.

For program-origin data, executing the known program produces a shape, which can be projected into visual intents. For shape-origin data, STEP/STL assets can directly supply renders, while missing programs require synthesis and verification. Thus rendering depends on the shape and need not wait for program recovery. We will replace the compressed pathway notation with these explicit dependencies.

The image-editing description concerns the visual branch. It does not specify how text labels or dimensioned engineering-drawing supervision are constructed. Drawing-style image augmentation is not sufficient evidence of the latter. Those per-modality construction details remain missing from the present account and cannot be inferred from the image pathway alone.

3. Teacher, training stages, and acceptance criteria.

We maintain that the teacher and the two selection criteria can be specified concretely.

M1 initializes from Qwen3.8-27B. It first receives large-scale SFT with CadQuery targets (approximately 0.5-1.0M examples), using visual intents rendered from executed programs. Subsequent SFT uses FreeCAD targets. Gemini-3.1-Pro is the primary distillation teacher.

Robust SFT uses approximately 150,000 industrial-image examples with synthesized program targets, retained when they execute successfully in FreeCAD. These are teacher-generated targets; crawled images are not assumed to have vendor ground-truth programs. High-quality SFT uses approximately 10,000 curated examples, selecting executed candidates with IoU > 0.7 against the training reference gt_shape. This specifies a geometric acceptance condition beyond execution success.

A generated gt_shape remains a proxy. Passing the threshold does not guarantee correct hidden geometry, and multiple teacher targets do not guarantee removal of shared errors. We will use verifier-refined to describe the targets rather than imply global optimality. Generation/refinement budgets, stopping rules, and the text/drawing training construction still require explicit documentation; the stated stages and threshold do not substitute for those details.

4. Metrics in the main table.

We maintain that the paper supplies an explicit scoring protocol.

Section 5.1 and the appendix define the four components. Executability counts all assigned tasks. Solid IoU measures filled-volume overlap and Surface IoU boundary-voxel overlap, using signed-PCA alignment, uniform-scale normalization, R=96, and 2% padding. The Part Judge assesses shape, salient features, and functional plausibility from input evidence and output renders; the prompts are included in the appendix.

Eq. (4) averages executability, Solid IoU, Surface IoU, and Judge/100. Quality terms use evaluator-available artifacts, whereas executability uses the assigned set. These definitions specify what the reported quantities measure and how they are combined. They concern executed geometry, not absolute dimensions, feature histories, or editability. We will make the definitions and their denominators more prominent in the main text.

Thanks for the replies. However, my concerns remain unresolved.

  1. As one of the contributions, Parallel TTS lacks the necessary explanation in both the Introduction and the method section. While its performance improvement is only validated in experimental analysis, I cannot recognize the motivation for introducing it or its contribution.
  2. The response addresses the data construction process for the Image intent, but it still does not answer how to handle the intent of text descriptions and engineering drawings.
  3. The training process uses Gemini-3.1-Pro as the distillation teacher. How can the effectiveness of using such a general-purpose LLM as a teacher model for CAD-specific tasks be demonstrated?

Considering the above, I will not change my score.

AuthorsOpenReview ↗

Response to Reviewer 88KJ

Thank you for the follow-up. We address the three remaining concerns with concrete records from our pipeline.

(1) Motivation and mechanism of parallel test-time selection. CAD candidates vary in quality and can be verified through execution. Using the off-the-shelf Qwen3.8-27B, we sampled 16 programs per input across 2,845 inputs. The per-sample execution success rate was 0.856, and every input had at least one executable candidate. Successful candidates averaged 0.382 Solid IoU; selecting the best per input using ground truth achieved 0.529. This oracle result is an upper bound, not a deployable result, but shows the potential benefit of selection.

Our selector uses no ground truth. Given the original input, candidate programs, and six-view renders, a VLM ranks the candidates in one request. On a fixed pool of eight VisCAD-M1 samples per input, random selection among executable candidates achieved 0.3865/0.1570 Solid/Surface IoU; listwise selection achieved 0.4108 ± 0.0018 / 0.1721 ± 0.0016 over five runs. Thus, the gain extends beyond filtering execution failures.

An input-modality ablation on eight slices with 2,472 inputs yielded Solid IoU of 0.3633 for random selection, 0.3475 for code only, 0.3749 for renders only, and 0.3835 for code plus renders. This suggests that rendered geometry is the main selection signal.

(2) Text and engineering-drawing intents. Neither branch uses the photo-editing or image-to-3D steps in Section 4.1. Text descriptions are passed directly to Gemini-3.1-Pro without images; engineering drawings are rasterized from PDF and passed with reconstruction instructions. The teacher generates FreeCAD Python programs, which must execute to produce a valid shape with exactly one solid and a non-empty STEP export. Failed programs receive up to two execution-guided repair attempts.

With 12 candidates per input, 4,249/4,800 text candidates passed initially and 98.0% after repair. For engineering drawings, 60.6% passed initially and 89.4% after repair. We will clarify the per-modality procedures in the revision.

(3) Evidence that a general-purpose model can serve as a CAD teacher. First, Gemini-3.1-Pro evaluated zero-shot under our protocol is among the strongest models on both benchmarks, providing evidence of its CAD-generation capability without task-specific fine-tuning.

Second, the pipeline treats the teacher as a candidate generator rather than accepting its outputs unconditionally. Every candidate must pass the execution validator described above, and failed candidates can be repaired using execution feedback. Across the text and engineering-drawing batches, 5,748 of 7,272 candidates passed initially, increasing to 6,913 after repair.

Reviewer_n6DmOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

VisCAD combines part-level CAD generation with a separate assembly-generation workflow. VisCAD-M1 is a 27B multimodal model trained through CAD mid-training and two stages of supervised fine-tuning to generate FreeCAD programs from text, drawings, renders, and photographs. It also ranks its own candidate outputs to improve generation quality. VisCAD-H1 uses frontier models and a shared intermediate representation to plan parts, mating relations, and placements across CAD platforms. Experiments on two benchmarks report competitive part-level performance, further gains from self-reranking, and improved assembly judge scores on 50 cases.

Critical strengths
  1. VisCAD-M1 improves substantially over the reported Qwen3.8-27B baseline, with further gains from self-reranking. The assembly workflow also provides a sensible separation of part planning, geometry, and placement.

  2. Unlike most prior specialized CAD models, which are trained and evaluated mainly on CAD-native renders or text, VisCAD-M1 also accepts engineering drawings and real product photographs through the same interface. The evaluation spans 2,845 part-level tasks over nine slices covering all four intent types. This breadth makes it possible to see both where the extended coverage helps, e.g., executability on industrial text and photographs

Critical weaknesses
  1. Applying Eq. 4 to VisCAD-M1’s five slices in Table 7 and averaging gives 0.5530, rather than the 0.5596 reported in Tables 1, 3, and 7. The same calculation reproduces the averages for Claude, Gemini, GPT-5.5, and VisCAD-M1 with TTS. If the slice values are correct, M1 does not lead on PubCADBench, contrary to Section 5.2. This discrepancy directly affects a central performance claim. Please correct me if I have misunderstood the aggregation procedure or made a calculation error.

  2. Several slice-level statements in Sec. 5.2.1 do not match the tables, which are as following: (1) Orthographic Solid IoU is 0.4604 for M1 versus 0.4613 for Claude-Opus-4.8 (Table 7). (2) Real Picture Solid IoU is 0.4456 for M1 versus 0.4501 for Kimi-K3 (Table 8). (3) The text describes executability as “almost all above 0.95”, but many P3D-Image entries in Table 7 fall well below that.

This weakness is decisive because “better than SOTA frontier models” is the central claim of the first contribution.

  1. The training ablations do not fully support the proposed three-stage recipe. Table 2 evaluates mid-training on 8B and 32B models rather than the final 27B model, and it is unclear whether both variants undergo the same later training stages.
Questions for authors
  1. Could the authors explain how the slice scores are combined into the reported AVG and whether the discrepancy noted above affects the claim of leading on both benchmarks? (Applying Eq. 4 to the five VisCAD-M1 slices in Table 7 and averaging their scores gives 0.5530, rather than the reported 0.5596. The same calculation reproduces the reported averages for several other models.)

  2. How were the PubCADBench subsets selected from the five source benchmarks? Were they randomly sampled or filtered by category or difficulty, and were the same subsets used for all models?

  3. Is VisCAD-H1’s output an actual multi-part assembly with separate solids, mates, and placements?

3 comments
AuthorsOpenReview ↗

Response to Reviewer n6Dm

Thank you for checking the results. We give the corrected arithmetic, the slice-level comparisons that remain supported, and the scope of the training and assembly evidence.

1. Aggregation and the corrected benchmark ordering.

We stand by the self-reranking gain after correcting the base aggregate.

Applying Eq. (4) to the five displayed PubCADBench slices gives M1 profiles of 0.586901, 0.652337, 0.598257, 0.461750, and 0.465508. Their equal-weight mean is 0.55295035, or 0.5530. With RealCADBench at 0.548453, the equal-weight two-benchmark average is 0.550702, or 0.5507. The reported 0.5596/0.5540 summary cells do not follow from those entries and require correction.

Base M1 therefore does not lead PubCADBench: Claude is 0.5579 and Gemini 0.5533. Its overall mean is numerically close to Gemini's 0.5496, without a significance claim. The displayed Qwen3.8-27B slices give approximately 0.4754 overall, below M1's 0.5507; this is a descriptive comparison under the reported evaluation, not an attribution to an individual training stage.

The 16-candidate PubCADBench result recomputes to 0.58332045, a within-model gain of 0.03037 over corrected base M1. The overall TTS score remains approximately 0.5797. Equal-budget frontier reranking is not evaluated. Other summary inconsistencies also need reconciliation; corrections should use one aggregation rule for every model.

2. Slice-level statements.

We stand by the specific slice-level advantages supported by the tables.

Claude's orthographic Solid IoU is 0.4613 versus M1's 0.4604, and Kimi's real-picture conditional Solid IoU is 0.4501 versus M1's 0.4456. These columns do not support M1 leadership. P3D-Image execution rates also prevent the blanket statement that almost all frontier results exceed 0.95. The wording and boldface will be corrected accordingly.

The tables do support narrower strengths: M1 leads the base-model rows on Solid and Surface IoU for BenchCAD, CADBench, and RealCADBench rendered images. On real pictures, M1's execution rate is 0.9877 versus Kimi's 0.5722. This execution difference does not reverse the conditional-IoU ordering. Both quantities should remain visible, with their different denominators, rather than being summarized as a uniform win.

3. Training sequence and ablation scope.

We maintain that the stated training sequence and causal attribution are separate questions.

Final M1 initializes from Qwen3.8-27B, receives large-scale SFT with CadQuery targets (approximately 0.5-1.0M examples), and subsequently uses FreeCAD targets. Gemini-3.1-Pro is the primary teacher. Robust SFT uses execution-success filtering; high-quality SFT requires IoU > 0.7 against the training reference shape.

Table 2 reports 8B/32B configurations rather than a matched ablation of final 27B M1. The manuscript also does not establish identical subsequent stages and budgets for those variants. Consequently, that table cannot identify the causal contribution of mid-training to final M1. The separate three-target versus one-target comparison reports training outcomes under those settings; it does not replace a matched 27B ablation. We will state these distinctions explicitly.

4. Public subset selection.

We confirm that every compared model was assigned the same 1,100 public tasks.

The 200/300/200/200/200 tasks were selected for diversity from the five source benchmarks. All compared models were assigned the same 1,100 examples. This directly answers whether different models used different test subsets: they did not. The specific selection procedure and selected IDs still need to accompany this description.

Pixel-identical examples were removed, but training/evaluation disjointness was not enforced at SKU or geometry-family level. We therefore do not claim verified unseen-family generalization. Evaluator-available quality subsets can also differ even when assigned task sets are identical.

5. Multi-part assembly outputs.

We stand by the described per-part generation and placement workflow.

Section 4.3 describes per-part generation followed by global placement from a reviewed IR. The reported examples illustrate that workflow, and the Assembly Judge evaluates delivered geometry, arrangement, and functional plausibility. However, the manuscript does not establish that the exported outputs retain solver-enforced native mates or verified kinematics. A placement plan and an assembly rendering alone cannot answer that stronger part of the question. The cross-backend examples likewise show realization rather than constraint preservation under edits.

Thank you for the detailed response. I appreciate the authors' clarifications and acknowledge the strengths of the proposed approach.

However, the corrected benchmark results weaken the original performance claims, and the limited ablation evidence still makes it difficult to assess the contributions of the proposed training stages. Therefore, I believe my main concerns remain and will maintain my original score.

AuthorsOpenReview ↗

Response to Reviewer n6Dm

Thank you for the follow-up. The corrected aggregates change how Table 1 should be read, but they do not weaken the central claim of the paper: CAD-specific training turns a weak generalist backbone into a competitive CAD program generator.

Under the same FreeCAD protocol and Eq. 4 aggregation, the untuned Qwen3.8-27B backbone scores only 0.4933 / 0.4575 / 0.4754 on PCB / RCB / overall. VisCAD-M1 reaches 0.5552 / 0.5489 / 0.5521—an absolute gain of +0.0766 (+16.1% relative to the same backbone). Micro success rises from 0.832 to 0.949; macro Solid IoU from 0.336 to 0.403; Surface IoU from 0.122 to 0.164; and Judge from 60.9 to 69.3. On this protocol the base model sits 0.074 below Gemini-3.1-Pro, while VisCAD-M1 matches the frontier band 0.5521 vs 0.5496. The right conclusion is not that specialization failed; it is that specialization is what closes a large CAD competence gap.

This gap is statistically large, not a fourth-decimal ranking effect. On the 1,100 public PCB tasks (equal slice weight; failed/unavailable IoUs set to zero for sensitivity analysis; 4,000 paired bootstrap replicates), VisCAD-M1 improves Success by +0.0853, Solid IoU by +0.0924, and Surface IoU by +0.0537. All three 95% intervals exclude zero. By contrast, the 0.001-scale difference versus frontier models is not the quantity that carries the scientific claim; the same-backbone lift of nearly eight points on Eq. 4 is.

Table 2 remains a valid smaller-scale recipe study. At the actual 27B scale, the archived trajectory under a fixed geometry composite (Success + failure-zero Solid IoU + failure-zero Surface IoU)/3 rises from 0.4140 for Qwen3.8-27B to 0.4829–0.4880 after broad FreeCAD SFT and to 0.5019 at the VisCAD-M1 specialized checkpoint. The dominant jump is base → CAD SFT, with a further specialized-stage gain on top. Together with the frozen endpoint comparison above, this shows that the performance of VisCAD-M1 is produced by CAD adaptation of the backbone, not by the backbone alone.

The same conclusion is reinforced at test time with the generator held fixed. On a pool of eight VisCAD-M1 samples per input across all 2,845 evaluation cases, random choice among executable candidates yields Solid IoU 0.3865, while listwise code+render selection yields 0.4108 ± 0.0018 over five runs. CAD outputs therefore benefit from execution-aware verification beyond merely discarding failed programs.

Reviewer_YftGOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

VisCAD combines a 27B part generator with a separate assembly agent framework. Following CAD mid-training, multiple-target industrial SFT, and curated refinement training, VisCAD-M1 maps text, engineering drawings, photographs, and renders to FreeCAD Python. The photo-based data curation path uses edited images and generated meshes as intermediate supervision. At inference, the model can select candidates from sampled programs and their rendered outputs. VisCAD-H1 uses a frontier model to construct a bill of materials, per-part intermediate representations, global poses, and backend programs.

Across 1,100 public and 1,745 industrial part tasks, the reported aggregate score is 0.5540, compared with 0.5496 for the strongest frontier model in the comparison, and reaches 0.5797 after reranking. A separate 50-case assembly study reports scores of 85.0, 68.0, and 52.0 for VisCAD-H1, Codex, and Claude Code. The intended contribution is broad CAD capability through data curation and structured execution; the central questions concern supervision validity and the semantics of the assembly representation.

Critical strengths
  1. The suite covers a useful and broad range of industrial design evidence.Using text, engineering drawings, photographs, and renders as inputs for executable CAD generation has practical value. The intent–program–shape organization provides a coherent framework for combining native CAD data with incomplete industrial assets.

  2. Reranking and explicit assembly planning are reasonable choices for addressing CAD generation failures. Table 3 shows that the same part model improves from 0.5596 to 0.5833 on the public benchmark when using 16 candidates. Reporting that sequential refinement yields no benefit is also informative. For assemblies, specifying parts and interfaces before translation can reduce omissions and separate local construction from global layout.

Critical weaknesses

The evaluation does not establish native CAD geometric accuracy or industrial usability. Section 5.1 and Appendix B execute the programs, export result.stl, then remove pose and uniform-scale differences and compare the predicted and reference meshes on a voxel grid of resolution 96. The export does not preserve analytic curve and surface types or parameters, and voxelization further reduces geometric detail. Consequently, a true cylinder and an approximation consisting of sufficiently many planar faces may receive similar scores despite having different native geometry. These are useful global-shape metrics, but they do not directly validate native curve and surface recovery or feature-parameter accuracy. The paper reports neither native CAD geometric-deviation results nor discretization-error or convergence analysis.

The assembly and portability results do not close this gap either. Section 4.3 does not provide an intermediate-representation schema or executable semantics for interface references, units, local coordinate frames, and mate satisfaction. It remains unclear whether the global gate solves constraints, checks residuals, or obtains VLM approval. The assembly judge uses views, a bill of materials, and supplied geometric facts, but this does not independently establish the correctness of interfaces or degrees of freedom. Figure 7 shows one object on three backends without quantitatively checking native geometry, mating relations, or behavior after parameter edits.

The assembly reporting also contains discrepancies. Table 10 lists 49, 48, and 45 exports for VisCAD-H1, Codex, and Claude Code, whereas Table 9 gives 49, 49, and 50, respectively. Recomputing the means of the available scores gives 85.04, 69.00, and 57.73 rather than 85.0, 68.0, and 52.0; consistently assigning zero to failures also fails to reproduce the three reported scores. These records need to be reconciled before the assembly margins can support the corresponding claims.

  1. The learning pipeline lacks a sufficiently defined criterion for determining the trustworthiness of geometric supervision. In the photo-based path in Section 4.1 and Figure 2, image editing and image-to-3D generation produce a silver-standard shape that then guides program refinement. A generated mesh may introduce a nonexistent hidden wall or omit a hole; optimizing CAD toward that mesh may preserve the error while improving mesh agreement. The paper acknowledges that shapes are imperfect, but does not define the program-search objective, checks that preserve the original evidence, or confidence rules that could prevent this failure. Thus, “near-optimal” must be defined relative to an explicit target. This concern applies to the generated-supervision path, not to native program–shape pairs.

The multiple teacher programs in Section 4.2 can represent useful alternative constructions, but increasing their number alone cannot suppress shared semantic errors. If ordinary SFT fits all targets, a repeatedly omitted hole will be reinforced rather than corrected. The paper does not specify a dedicated loss, reliability weighting, or acceptance criterion that explains the claimed robustness. Similarly, the test-time method is described as listwise selection over programs and rendered outputs, yet no CAD-specific scoring rule is provided. The contribution can reasonably be positioned as a training and search recipe, but its mechanism and novelty should be characterized accordingly. The final initialization and the transition from CadQuery to FreeCAD supervision also remain unclear.

The part-level base model leads by only 0.0044, without uncertainty estimates; the rules for excluding geometry or SKU families shared between training and evaluation are also unspecified. Clear data separation and controlled comparisons are needed to establish whether the proposed supervision improves generalization beyond adding data and sampling.

Questions for authors
  1. For subsets with native CAD references or explicit engineering-drawing dimensions, can you report native geometric deviations, curve and surface parameter errors, and key dimensions in the original units? Please specify discretization tolerances and sensitivity to mesh and voxel resolution, and distinguish industrial-input reconstruction capability from usability for manufacturing or assembly.
  2. On the generated-mesh path, what objective and acceptance checks define a “near-optimal program”? How do you distinguish image-editing or mesh hallucinations from reasonable hidden-geometry completion? What mechanism prevents shared teacher errors from being reinforced?
  3. Please provide an intermediate-representation instance defining units, coordinate frames, interface references, mates, and degrees of freedom, together with numerical acceptance criteria. Which native geometric and constraint properties are preserved after backend translation and parameter edits? How are failures detected?
  4. Please identify the source runs and reconcile Tables 9 and 10 using one explicit aggregation rule, while calibrating the assembly judge against blinded assessments by CAD practitioners. Are the stated mating and functional advantages confirmed beyond appearance?
  5. Please specify the final model initialization, supervision transition, and geometry or SKU-family exclusion rules. Do the base-model advantage and reranking gains remain under paired uncertainty analysis, failure-inclusive aggregation, and selection controls with the same sampling budget?
2 comments
AuthorsOpenReview ↗

Response to Reviewer YftG

We clarify the training criteria, recomputed results, and scope of the CAD and assembly evidence.

1. Scope of the geometry measurements.

We maintain that mesh agreement is a defined measurement of geometric reconstruction.

Solid IoU measures occupied-volume overlap and Surface IoU boundary overlap after alignment. These scores capture the geometric consequences of errors in relative dimensions, proportions, and spatial structure. The Part Judge assesses shape, salient features, and functional plausibility from input evidence and output renders.

Uniform-scale alignment removes absolute dimensions, and STL/voxel evaluation does not preserve analytic-surface parameters or feature histories. The cylinder example therefore identifies a genuine distinction between mesh agreement and native-CAD accuracy. Native deviations, curve/surface parameter errors, tessellation convergence, and behavior under edits are not reported. The supported interpretation of these results is geometric reconstruction under the specified mesh protocol, rather than manufacturing readiness.

2. Initialization, supervision transition, and acceptance criteria.

We maintain that the different training stages use explicit acceptance criteria.

M1 initializes from Qwen3.8-27B. It first undergoes large-scale SFT with CadQuery targets (approximately 0.5-1.0M examples), followed by SFT with FreeCAD targets. Gemini-3.1-Pro is the primary distillation teacher. Robust SFT retains programs that execute successfully in FreeCAD. High-quality SFT selects executed shapes with IoU > 0.7 against the training reference gt_shape.

For generated gt_shape, passing the threshold does not establish hidden-geometry accuracy. Native program-derived pairs have different provenance. We will describe accepted targets as verifier-refined rather than globally near-optimal. Multiple targets provide alternative supervision, and the paper compares three versus one target per input. Neither this comparison nor the acceptance threshold establishes a mechanism that eliminates correlated teacher errors. The exact refinement budget and stopping rule still require documentation.

3. Assembly workflow and the evidence for portability.

We stand by the documented assembly workflow and the illustrated cross-backend outputs.

Section 4.3 describes BoM construction, per-part geometry/interfaces, global pose review, and backend realization. Figure 7 shows outputs in FreeCAD, Fusion, and SolidWorks for the illustrated case. The Assembly Judge evaluates Q/F/D from views, BoM, and geometric facts.

These materials describe the workflow and show cross-backend outputs; they do not establish executable IR semantics, a numerical mate solver, residual bounds, verified degrees of freedom, or preservation under parameter edits. A concrete IR instance and numerical validation are not supplied by those images. Blinded expert validation of the 50-case assembly study is also not reported. We will limit the portability and assembly claims to the evidence actually shown.

4. What the displayed assembly records support.

We stand by H1's highest mean under both calculations on the displayed case sheet.

Recomputing the 50 displayed cases gives 49/48/45 available outputs for H1/Codex/Claude Code, with available-score means 85.04/69.00/57.73. Assigning zero to failed exports over all 50 tasks gives 83.34/66.24/51.96.

This is an arithmetic check of the displayed cases, not an audit of the source runs. Table 9 does not follow one consistent rule from these entries and requires reconciliation with those runs. The recalculation supports the stated ordering for the case sheet, but does not verify the original summary values, compute-matched superiority, or mechanical correctness.

5. Corrected part aggregates and comparison conditions.

We stand by the self-selection gain computed from the corrected displayed aggregates.

The displayed slices give base M1 0.5530 on PubCADBench and 0.5485 on RealCADBench, hence 0.5507 overall. Gemini's overall score is 0.5496. This small numerical difference is not a significance result. The 16-candidate row gives 0.5833 on PubCADBench, an increase of approximately 0.03037 over corrected base M1; the overall TTS result remains approximately 0.5797. These numbers support a measured within-model selection gain, not a new general search mechanism or equal-budget superiority over frontier rerankers.

PubCADBench uses diversity-based sampling with identical assigned tasks across systems. Pixel-identical duplicates were excluded, but SKU/geometry-family overlap between training and evaluation was not excluded. The results therefore do not establish unseen-family generalization. Paired confidence intervals, failure-inclusive part-quality means, and equal-budget selection controls are not supplied by the aggregate tables. We will align the claims with these comparison conditions.

AuthorsOpenReview ↗

Supplementary Response to Reviewer YftG

We add two concrete results on metric validity and selection controls.

Metric validity and human calibration. Your concern that voxel IoU is only a coarse proxy is empirically supported, and so is the value of adding the Part Judge. Across 30 annotation batches we collected human pairwise preferences between two candidate outputs for the same input: 4,745 pairs with a stated preference, 693 ties, and 55 marked unjudgeable. Solid IoU agrees with the human choice on only 57.9% of decided pairs, rising to 71.3% when the IoU gap is at least 0.3. The Part Judge agrees on 65.3% overall, 73.1% when the score gap is at least 10, and 83.2% when the gap is at least 30. The Judge therefore tracks human preference more closely than Solid IoU alone, which is why Eq. (4) includes it rather than relying on voxel overlap. Neither quantity is a substitute for native CAD checks (analytic surfaces, feature parameters, absolute dimensions, editability); those require separate protocols, which we treat as complementary rather than as a reason to discard the current reconstruction metrics.

Selection controls on a fixed candidate pool. The proposed rule is not an uncontrolled “sample more and hope” procedure. On a fixed pool of eight VisCAD-M1 candidates per input over all 2,845 evaluation cases, the selector receives only the original input, candidate code, and candidate renders—no ground truth, no IoU, and no Judge score. Random choice among executable candidates yields Solid / Surface IoU of 0.3865 / 0.1570. Listwise code+render selection yields 0.4108 ± 0.0018 / 0.1721 ± 0.0016 over five independent selector runs. The gain is therefore beyond filtering failed executions, and it is stable under resampling of the selector.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.