CAD-Coder:Text-Guided CAD Files Code Generation

Changqi He; Jiajun Miao; Liguo Zhang; Shuhan Zhang

REVIEW 5 major objections 6 minor 47 references

CAD-Coder:Text-Guided CAD Files Code Generation

T0 review · 5 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read CAD-Coder's central claim is that natural-language instructions can be turned into runnable Python scripts that generate editable, annotated CAD files, with a reported 40% pass@1 on its own test set.

desk verdict Useful dataset and a plausible fine-tuned LLM for Dxf code generation, but the evaluation only proves template inversion, not robust text-guided CAD. read the letter →

arxiv 2505.08686 v1 pith:VWTIHEJL submitted 2025-05-13 cs.GR cs.CVcs.LG

Changqi He , Shuhan Zhang , Liguo Zhang , Jiajun Miao This is my paper · ORCID

classification cs.GRcs.CVcs.LG

keywords CADgenerationnaturallanguagetocodeDXFfilesezdxfgeometricannotationsLoRAfine-tuningtext-guideddesign

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

CAD-Coder aims to make CAD drafting as easy as typing a sentence: a user describes a shape, and the model outputs runnable Python code that, when executed, produces a Dxf file with editable geometry and dimension annotations. The paper's claim is that this is the first interactive system to generate annotated CAD files straight from natural language, because prior text-guided methods output meshes, point clouds, or custom command sequences that engineers cannot directly open or edit. To support the claim, the authors build a synthetic dataset of 29,130 Dxf files with matching script code and natural-language prompts, generated by randomly filling in parameters of hand-written parent-code templates. On a 485-prompt test set drawn from the same synthetic distribution, they report pass@1 of 0.40, graphic accuracy of 0.68, and annotation accuracy of 0.77, beating the generic LLMs they compare against. If the approach generalizes beyond its template distribution, it would give engineers a fast, editable, cross-platform route from text to CAD.

What carries the argument

The load-bearing object is the CFSC dataset together with its parent-code randomization procedure. For each shape, the authors hand-write a parametric script template; a randomization algorithm assigns legal values to the parameters, yielding many concrete script-code/Dxf pairs, and the script structure is standardized so that every sample has the same three-part layout: library imports, a construction function, and a main function with dimension parameters. The templates are also annotated with comments, which the paper shows helps the model disambiguate similar code fragments. Training uses the DeepSeek-R1-Distill-Llama-8B model fine-tuned with LoRA, so the argument rests on the model inverting the template generator rather than on a new architectural mechanism.

What would settle it

Take the trained model and test it on one hundred prompts written by humans describing the same shapes in their own words, plus fifty prompts requesting shapes that never appear in the parent-code library. If pass@1 falls to near zero on the out-of-library shapes or drops below the generic-LLM baseline on the paraphrased prompts, the robustness claim fails; if it holds, the claim is supported.

Watch

Extended reading notes

Core claim

On its own terms, the paper establishes a pipeline: natural language prompt to standardized Python/ezdxf script to executable Dxf file that preserves geometric annotations. The central discovery claimed is that a compact, instruction-tuned language model can learn this mapping well enough to outperform much larger generic LLMs on the authors' benchmark, and that the Dxf output format solves the editability and annotation gaps left by earlier CAD generators. The paper also reports that annotated generation is harder than unannotated generation, that comment-injected training code improves generation, and that LoRA tuning beats full fine-tuning on this dataset.

Load-bearing premise

The training and test prompts both come from the same hand-written parent-code templates, so the reported scores measure how well the model reverses that template generator, not how well it understands arbitrary user language or shape classes outside the template library.

Editorial extensions

If this is right

Users could go from a typed description to an editable, dimensioned Dxf file without manual drafting, and open the result in mainstream CAD platforms.
Engineers could request annotated parts, with radius, angle, tolerance, chamfer, or surface-roughness dimensions, directly from text, reducing re-drafting for manufacturing.
Because the output is executable code, CAD-Coder could be embedded in interactive loops where the user inspects the generated Dxf and asks for changes, though the paper only demonstrates one-shot generation.
The ablation suggests that adding explanatory comments to training code is a cheap way to improve code generation, which may transfer to other program-synthesis tasks.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The reported metrics are relative to the same synthetic template distribution used for training, so the headline numbers should not be read as generalization to arbitrary user prompts; a human-written prompt benchmark would be the direct test.
The parent-code randomization recipe could be reused for other output formats or CAD kernels, and a natural extension is to test whether the model can compose multiple template shapes in one prompt, which the current dataset does not appear to exercise.
The contrast between annotation-free and annotated generation suggests that the bottleneck is not geometry but the extra linguistic and geometric bookkeeping of dimensions; future work might separate these skills rather than train them jointly.
Since the output is standard code, the same model could potentially be integrated into agentic CAD workflows that iterate on user feedback, but editability of the resulting dimensions is not directly measured by the paper's metrics.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: the genuinely useful part is the CFSC dataset and the demonstration that LoRA-fine-tuning an 8B LLM on templated ezdxf code produces runnable code for annotated Dxf files. The pipeline is sound. But the evaluation does not support the headline claim of text-guided interactive CAD generation, because both training and test prompts come from the same parent-code templates. The reported numbers are likely close to ceiling for template inversion.

What's good: using Dxf as a universal, editable output format is a legitimate practical choice. Building 29k script+Dxf pairs with annotations is real work; if released, the dataset would be useful for benchmarking. The code generation itself works — the qualitative figures show shapes that match prompts, and the ablations (comments, LoRA vs full fine-tune) are informative. The cross-platform demo is a nice touch.

Soft spots, in order: (1) The test set is randomly sampled from the same synthetic distribution as training, with no deduplication reported, so pass@1 of 0.40 is not evidence of generalization to human phrasing. A single hold-out template family or a paraphrased prompt set would have been easy to add and is necessary. (2) No comparison against Text2CAD, CAD-LLM, LLM4CAD, or vision-language CAD generation; the baselines are generic LLMs that were never prompted with a code template, which flatters CAD-Coder. The "first" claim is also unsupported given those works exist. (3) ACC-G and ACC-A are defined with "correct" left to a human judge, with no judging protocol, so 0.68/0.77 are not independently checkable. (4) Minor: the metric formulas have typos (ACC-P sums inconsistently over N_c and N_p), and the ablation showing annotation hurts all metrics is honest but undercuts the claim of "uniquely providing annotations" as an unqualified win.

Net: the engineering is credible, the dataset could be a contribution, but the paper as written overclaims. A revision with an out-of-distribution test, proper baselines, and a released dataset could turn this into a useful paper. I'd send it to a serious referee — the dataset and system deserve scrutiny — but I wouldn't accept it without substantial changes.

Referee Report

5 major / 6 minor

Summary. The paper proposes CAD-Coder, a framework that fine-tunes DeepSeek-R1-Distill-Llama-8B with LoRA on a newly constructed CFSC dataset of 29,130 Python/ezdxf script codes paired with Dxf files and natural-language descriptions, so that a user's text prompt can be converted into runnable Python code that produces an editable, annotated Dxf file. The authors report pass@1 of 0.40, ACC-G of 0.68, and ACC-A of 0.77 on a randomly selected 485-prompt test set, and they compare against four generic LLMs on these metrics. The paper also demonstrates cross-platform compatibility of the generated Dxf files and includes ablation studies on annotation strategy, fine-tuning method, and base models.

Significance. If the claims were fully supported, CAD-Coder would be a practically useful contribution: it would be an interactive text-to-CAD system whose output is not a fixed mesh or command sequence but a universal, editable Dxf file with geometric annotations, which is absent from most earlier text-guided CAD work. The CFSC dataset, if released, would also be a resource for the community. The paper's strengths include the focus on editability and annotations, the construction of a large paired dataset from parent-code templates, and the demonstration that the fine-tuned model outperforms several generic LLMs on the authors' own metrics. However, the evaluation as presented does not establish the central claim of robust text-guided generalization, because the test prompts are generated by the same template process as the training data and the most relevant text-to-CAD baselines are not compared. The reported metric values are therefore not yet convincing evidence for the paper's headline capabilities.

major comments (5)

[Sec. 3.2 and Sec. 4.3] The evaluation is performed on prompts drawn from the same template-based generator used to create the training set. In Figure A, the natural-language prompt is literally the filename produced by the parent code, e.g., 'please draw a rectangle for me, the width of the rectangle is {width}, the height is {height} and the origin is {(x0,y0)}'. Section 4.3 states that the 485 test prompts were randomly selected from this same dataset. Consequently, high pass@k and ACC scores may reflect the model's ability to invert the template generator and fill in parameter values, rather than its ability to understand arbitrary user text, paraphrases, or shape classes not present in the training templates. The authors should evaluate on a held-out set of human-written prompts or on prompts describing shape classes and configurations not seen during training, and report the performance separately for such out-of-distribution inputs.
[Table 1 and Sec. 2] The related-work section cites Text2CAD, CAD-LLM, and LLM4CAD as the closest text-to-CAD methods, but Table 1 compares CAD-Coder only against generic LLMs (Qwen2.5-Coder-14b, ChatGPT-4, Deepseek-V3, Llama3.3-70b). Without comparison to the state-of-the-art text-to-CAD systems, the abstract's claim of showing 'superior interactive capabilities' and the introduction's claim of being 'the first interactive model capable of generating annotated CAD files from natural language descriptions' are not established. The authors should either include these baselines in the quantitative comparison or clearly explain why they cannot be directly compared, and should temper the novelty claims accordingly.
[Sec. 4.1, Eqs. (8) and (9)] ACC-G and ACC-A are not operationalized. Equation (8) defines ACC-G as the indicator that 'the graph is correct' and Eq. (9) as 'the annotation is correct', but no concrete decision procedure is given: is correctness determined by an automated geometric comparison, by human raters, by rendering and visual inspection, or by some unit test? Without a specific protocol, the reported ACC-G=0.68 and ACC-A=0.77 are not reproducible or independently verifiable. The authors need to specify the exact evaluation pipeline, including any thresholds, comparison functions, and inter-annotator agreement if humans are involved.
[Tables 1, 2, and 3] The reported pass@1 for the main CAD-Coder model is inconsistent across tables. Table 1 lists pass@1=0.40 for CAD-Coder; Table 2 lists pass@1=0.33 for 'CAD-Coder with annotation'; and Table 3 lists pass@1=0.33 for 'CAD-Coder with LoRA' while Table 1's CAD-Coder is also described as using LoRA in Sec. 3.3. If these numbers correspond to different test sets, training configurations, or evaluation conditions, the paper must state this explicitly and present a single consolidated set of results for the final model; otherwise the headline accuracy is contradictory.
[Sec. 4.3 and Tables 1, 2, 3, A, B] The metric APR (Average Parsing Rate) is used repeatedly in the tables and discussed in Sec. 4.3, but it is never defined in Sec. 4.1 or anywhere in the paper. Also, Sec. 4.3 refers to a 'substantial lead in ACC-L', but no metric named ACC-L is defined; this appears to be a typo for ACC-A but must be corrected. All metrics, including APR and any ACC-L, need precise definitions and formulas.

minor comments (6)

[Eq. (6)] The notation in the ACC-F formula is unclear: 'f_i and f_hat_i is the set of functions' mixes singular and plural, and the indicator compares sets while the text says 'function names are the same'. Please clarify whether the comparison is over function names or full function signatures.
[Eq. (7)] Equation (7) contains typographical errors: the summation limits use 'e' and 'Ne' without definition, and the index 'p' is used inconsistently. Please revise the formula and define all symbols.
[Eq. (8)] There is a typo: 'Ithe graph is comect(xi)' should be 'I[the graph is correct(x_i)]' or similar; also, the subscript/superscript formatting is inconsistent.
[Fig. 6 and Sec. 4.2] The qualitative comparison with VQ-CAD in Figure 6 is of limited value because VQ-CAD is not a text-guided method; the comparison is apples-to-oranges unless the authors clarify that this is only a visual sanity check of geometric quality, not a comparison of text-following ability.
[Sec. 3.2 and Supplemental F] In the parent-code example in Figure A, the file names and prompts are identical to the natural-language descriptions; the paper should explicitly acknowledge that the dataset's language is template-generated and discuss the implications for language diversity and realism.
[Sec. 5] The sentence 'For anonymous reason, this dataset will be released upon acceptance of the paper' is grammatically awkward and should be rewritten; more importantly, the authors should state a clear release plan for code and dataset to support reproducibility.

Circularity Check

1 steps flagged · score 6.0 of 10

The headline pass@1/ACC-G/ACC-A numbers are measured on prompts sampled from the same parent-template generator used to create the training pairs, so the quantitative 'prediction' largely reduces to inverting the CFSC template generator.

fitted input called prediction [Section 3.2 (CFSC Dataset, Figure A) and Section 4.3 (Model Comparison, Table 1)]
"py_file_name = os.path.join(py_output_dir,f"please draw a rectangle for me ,the width of the rectangle is{width},the height is{height}and the origin is {(x0,y0)}.py") ... width = {width}#Rectangle width {width}mm ... The experiments randomly selected 485 prompts, including 212 prompts for 3D models, 115 prompts for 2D sketches without annotations, and 158 prompts for 2D sketches with annotations. The results are shown in Table1."

In Figure A, the natural-language prompt and the ground-truth Python answer are produced by the same parent-code template from the same random variables: the prompt is literally an f-string formed from {width}, {height}, and {(x0,y0)}, while the answer code hard-codes those same values into a fixed code skeleton. Section 4.3 then evaluates the fine-tuned model on 485 prompts 'randomly selected' from the same CFSC dataset that was generated this way. Therefore the reported pass@1, ACC-G, and ACC-A measure how well the model fills template slots and reproduces the fixed code skeleton, not whether it understands arbitrary natural-language CAD instructions or generalizes to unseen shapes and phrasings.

full rationale

The paper has no analytic derivation chain; it is an empirical fine-tuning paper, so most strict circularity concerns do not apply. However, the headline quantitative claims are evaluated on a self-referential benchmark: the CFSC dataset is constructed by hand-authored parent-code templates whose random parameters generate both the prompt (as a file-name f-string) and the ground-truth code. Section 4.3 samples the 485 test prompts from this same synthetic dataset, so the high pass@1/ACC-G/ACC-A values in Table 1 largely reflect template inversion rather than robust text-to-CAD generalization. The paper does not report a train/test split or deduplication for these prompts, and Table 1 omits the most relevant text-to-CAD baselines (Text2CAD, CAD-LLM, LLM4CAD); those are external-validity gaps, not circularity. The qualitative cross-platform demonstrations (Figure 12) provide partial independent evidence that the generated Dxf files are real and editable, preventing a higher score. Overall, one load-bearing evaluation step reduces, by construction, to inverting the template generator, warranting a partial-circularity score of 6.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The central claim depends on a synthetic data-generation pipeline whose templates, sampling ranges, and legality constraints are hand-authored. The model is an empirical system with no new physical entities. The main burden is that evaluation data is produced by the same generator as training data, so the scores partly reflect the authors' own design choices.

free parameters (5)

learning_rate = 0.0002
Fine-tuning hyperparameter reported in supplementary section A.
batch_size = 4
Fine-tuning hyperparameter reported in supplementary section A.
num_epochs = 2
Fine-tuning duration reported in supplementary section A.
sequence_length = 1048
Token sequence length cap reported in supplementary section A.
template dimension sampling ranges = e.g., rectangle width and height in [10,100]
Hand-chosen bounds in parent code (Figure A); these ranges define the data distribution used for both training and evaluation.

assumptions (5)

standard math Transformer self-attention and LoRA low-rank updates are valid for this sequence-to-sequence code generation task.
The method relies on established deep learning results (equations 5 and 12).
domain assumption Dxf is a universal, editable CAD exchange format openable by mainstream tools such as AutoCAD, SolidWorks, and Onshape.
Invoked in Section 3.1 to justify the output format.
domain assumption The ezdxf Python library produces valid, human-editable Dxf files for the shapes and annotations used in the dataset.
The entire dataset and evaluation assume the library works as documented (Section 3.2).
ad hoc to paper Natural language descriptions generated from file names are representative of real user prompts.
Training and test pairs are built this way (Figure A), a hand-designed proxy for text input.
ad hoc to paper The manually encoded shape legality constraints are sufficient to generate valid CAD geometry.
Randomization must satisfy constraints such as hexagon nut diameter ratios (supplementary E); these are authored, not derived.

how reviews work

0 comments

Cite this review

Pith. "Pith review of CAD-Coder:Text-Guided CAD Files Code Generation." pith.science (2026). https://pith.science/paper/VWTIHEJL

@misc{pith2026250508686,
  author       = {Pith},
  title        = {Pith review of: CAD-Coder:Text-Guided CAD Files Code Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VWTIHEJL}},
  note         = {Machine review of arXiv:2505.08686}
}

read the original abstract

Computer-aided design (CAD) is a way to digitally create 2D drawings and 3D models of real-world products. Traditional CAD typically relies on hand-drawing by experts or modifications of existing library files, which doesn't allow for rapid personalization. With the emergence of generative artificial intelligence, convenient and efficient personalized CAD generation has become possible. However, existing generative methods typically produce outputs that lack interactive editability and geometric annotations, limiting their practical applications in manufacturing. To enable interactive generative CAD, we propose CAD-Coder, a framework that transforms natural language instructions into CAD script codes, which can be executed in Python environments to generate human-editable CAD files (.Dxf). To facilitate the generation of editable CAD sketches with annotation information, we construct a comprehensive dataset comprising 29,130 Dxf files with their corresponding script codes, where each sketch preserves both editability and geometric annotations. We evaluate CAD-Coder on various 2D/3D CAD generation tasks against existing methods, demonstrating superior interactive capabilities while uniquely providing editable sketches with geometric annotations.

Figures

Figures reproduced from arXiv: 2505.08686 by the authors.

**Figure 1.** Comparison of CAD-Coder with current works. Comparing with other CAD generation methods, CAD-Coder uses a different form of dataset and produces more easily editable and annotated CAD models. to CAD generation has garnered widespread attention. Early research primarily focused on reconstructing CAD models from 3D point clouds[12, 14, 27, 45], or generating CAD models based on CAD command sequences[28, 38, 40]. Howe… view at source ↗

**Figure 2.** Pipeline of the CAD-Coder. By randomly assigning values to the free parameters in the parent code, a series of script codes along with their corresponding Dxf files are generated, forming the CFSC Dataset. The dataset contains both 3D models and 2D sketches, especially contains annotated data. The codes in dataset are matched with their corresponding natural language descriptions, from which relevant question-answer… view at source ↗

**Figure 3.** Quantities of Different Primitive Types. LA stands for linear annotation, AA is angle annotation, and RA is radius annotation. Specifically, for a given shape, we first develop a framework script code P that incorporates all the necessary constraint relationships for the shape. However, instead of providing actual dimensional information, P references a set of parametric variables v1, v2, ..., vn to represent the… view at source ↗

Figures from the paper (5 more)

**Figure 5.** Figure 5: Handling of similar script code segments. Comments are added to script code segments that are prone to confusion, making it easier for the model to differentiate between these data. in script codes for certain shapes. For example, the script codes for concentric circl…

**Figure 8.** Figure 8: Annotation capability assessment. The bar chart includes three evaluation metrics: ACC-A (the probability of successful annotation), Annotation Type Error/Annotated (the percentage of correct annotation types in the annotation) and Annotation Data Error/Annotated (…

**Figure 9.** Figure 9: More complex sketch generation. The actual engineering parts containing various primitives and annotations are shown in this figure their corresponding code. After training, CAD-Coder was endowed with the ability to express 3D representations, as shown in [PITH_FULL_…

**Figure 10.** Figure 10: Generated 3D models illustration. CAD-Coder has a strong ability to generate 3D engineering parts including flanges, bearings, screws, nuts, gears, etc. strates that our approach effectively translates natural language into geometric shapes, while the substantial lea…

**Figure 12.** Figure 12: Cross-platform capability illustration. This figure displays the generated Dxf file being opened in different platforms/software, arranged from left to right as follows: AutoCAD[2], Onshape[6], CAXA[3], CATIA[4], SolidWorks[7], and UG[8]. 4.5. Ablation Study In this …

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

47 extracted references · 32 canonical work pages

[1]

Autolisp.https://help.autodesk.com/view/ OARX/2023/ENU/?guid=GUID- 265AADB3- FB89- 4D34-AA9D-6ADF70FF7D4B, . 2, 3

work page 2023
[2]

autodesk

Autocad.https : / / www . autodesk . com . cn / products / autocad / overview ? term = 1 - YEAR & tab=subscription, . 2, 3, 7, 8

work page
[3]

Caxa.https://www.caxa.com/cad/index.html. 2, 8

work page
[4]

Catia.https : / / www . 3ds . com / zh - hans / products/catia/all-products. 2, 8

work page
[5]

Freecad.https://www.freecad.org. 2, 3

work page
[6]

Onshape.https://www.onshape.com/en/. 2, 8

work page
[7]

Solidworks.https://www.solidworks.com/zh- hans/lp/proven- solution- 3d- design- and- product-development. 2, 7, 8

work page
[8]

Ug.https://plm.sw.siemens.com/en-US/nx/ cad-online/. 2, 8

work page

Show all 47 references

[9]

readthedocs

ezdxf.https : / / ezdxf . readthedocs . io / en / stable/index.html. 2
[10]

Phi-3 tech- nical report: A highly capable language model locally on your phone, 2024

Marah Abdin, Jyoti Aneja, Hany Awadalla, et al. Phi-3 tech- nical report: A highly capable language model locally on your phone, 2024. 1

2024
[11]

Gpt-4 technical report.arXiv preprint arXiv:2303.08774,

Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ah- mad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report.arXiv preprint arXiv:2303.08774,

arXiv
[12]

Learning representations and generative models for 3d point clouds

Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Learning representations and generative models for 3d point clouds. InInternational conference on machine learning, pages 40–49. PMLR, 2018. 1

2018
[13]

Gen- erating cad code with vision-language models for 3d designs

Kamel Alrashedy, Pradyumna Tambwekar, Zulfiqar Zaidi, Megan Langwasser, Wei Xu, and Matthew Gombolay. Gen- erating cad code with vision-language models for 3d designs. arXiv preprint arXiv:2410.05340, 2024. 1

2024 arXiv
[14]

Learning gradient fields for shape generation

Ruojin Cai, Guandao Yang, Hadar Averbuch-Elor, Zekun Hao, Serge Belongie, Noah Snavely, and Bharath Hariharan. Learning gradient fields for shape generation. InComputer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part III 16, pages...

2020
[15]

Evaluating Large Language Models Trained on Code.arXiv e-prints, art

Mark Chen, Jerry Tworek, Heewoo Jun, et al. Evaluating Large Language Models Trained on Code.arXiv e-prints, art. arXiv:2107.03374, 2021. 7, 8, 12

2021 arXiv
[16]

Evaluating large language models trained on code, 2021

Mark Chen, Jerry Tworek, Heewoo Jun, et al. Evaluating large language models trained on code, 2021. 1

2021
[17]

Pvdeconv: Point-voxel deconvolution for autoencoding cad construction in 3d

Kseniya Cherenkova, Djamila Aouada, and Gleb Gusev. Pvdeconv: Point-voxel deconvolution for autoencoding cad construction in 3d. In2020 IEEE International Conference on Image Processing (ICIP), pages 2741–2745. IEEE, 2020. 3

2020
[18]

The llama 3 herd of models.arXiv preprint arXiv:2407.21783,

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Ab- hishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models.arXiv preprint arXiv:2407.21783,

arXiv
[19]

Cadops-net: Jointly learning cad operation types and steps from boundary-representations

Elona Dupont, Kseniya Cherenkova, Anis Kacem, Sk Aziz Ali, Ilya Arzhannikov, Gleb Gusev, and Djamila Aouada. Cadops-net: Jointly learning cad operation types and steps from boundary-representations. In2022 International Con- ference on 3D Vision (3DV), pages 114–123. IEEE, 2022. 3

2022
[20]

Computer-aided design as language.Ad- vances in Neural Information Processing Systems, 34:5885– 5897, 2021

Yaroslav Ganin, Sergey Bartunov, Yujia Li, Ethan Keller, and Stefano Saliceti. Computer-aided design as language.Ad- vances in Neural Information Processing Systems, 34:5885– 5897, 2021. 2, 3

2021
[21]

Automatic recognition of interacting machining features based on minimal condition subgraph.Computer-Aided Design, 30(9):727–739, 1998

Shuming Gao and Jami J Shah. Automatic recognition of interacting machining features based on minimal condition subgraph.Computer-Aided Design, 30(9):727–739, 1998. 2

1998
[22]

Text2cad: Generating sequential cad designs from beginner- to-expert level text prompts.Advances in Neural Information Processing Systems, 37:7552–7579, 2025

Mohammad Sadil Khan, Sankalp Sinha, Talha Uddin, Di- dier Stricker, Sk Aziz Ali, and Muhammad Zeshan Afzal. Text2cad: Generating sequential cad designs from beginner- to-expert level text prompts.Advances in Neural Information Processing Systems, 37:7552–7579, 2025. 1, 2, 3

2025
[23]

Abc: A big cad model dataset for geometric deep learning

Sebastian Koch, Albert Matveev, Zhongshi Jiang, Francis Williams, Alexey Artemov, Evgeny Burnaev, Marc Alexa, Denis Zorin, and Daniele Panozzo. Abc: A big cad model dataset for geometric deep learning. InProceedings of the IEEE/CVF conference on computer vision and pattern rec...

2019
[24]

Llm4cad: Multimodal large language models for three-dimensional computer-aided design generation.Journal of Computing and Information Science in Engineering, 25(2), 2025

Xingang Li, Yuewan Sun, and Zhenghui Sha. Llm4cad: Multimodal large language models for three-dimensional computer-aided design generation.Journal of Computing and Information Science in Engineering, 25(2), 2025. 1, 2

2025
[25]

Deepseek-v3 technical report

Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437, 2024. 4, 7

2024 arXiv
[26]

Draw step by step: Reconstructing cad construction sequences from point clouds via multimodal diffusion

Weijian Ma, Shuaiqi Chen, Yunzhong Lou, Xueyang Li, and Xiangdong Zhou. Draw step by step: Reconstructing cad construction sequences from point clouds via multimodal diffusion. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 27154– 27...

2024
[27]

Structurenet: Hierarchi- cal graph networks for 3d shape generation.arXiv preprint arXiv:1908.00575, 2019

Kaichun Mo, Paul Guerrero, Li Yi, Hao Su, Peter Wonka, Niloy Mitra, and Leonidas J Guibas. Structurenet: Hierarchi- cal graph networks for 3d shape generation.arXiv preprint arXiv:1908.00575, 2019. 1

1908 arXiv
[28]

Sketchgen: Generating constrained cad sketches.Advances in Neural Information Processing Systems, 34:5077–5088, 2021

Wamiq Para, Shariq Bhat, Paul Guerrero, Tom Kelly, Niloy Mitra, Leonidas J Guibas, and Peter Wonka. Sketchgen: Generating constrained cad sketches.Advances in Neural Information Processing Systems, 34:5077–5088, 2021. 1, 2

2021
[29]

Cad-based inte- grated tolerancing system.International journal of produc- tion research, 36(10):2891–2910, 1998

B Ramani, SH Cheraghi, and JM Twomey. Cad-based inte- grated tolerancing system.International journal of produc- tion research, 36(10):2891–2910, 1998. 2

1998
[30]

Code llama: Open foun- dation models for code.arXiv preprint arXiv:2308.12950,

Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. Code llama: Open foun- dation models for code.arXiv preprint arXiv:2308.12950,

arXiv
[31]

Sketchgraphs: A large-scale dataset for modeling rela- tional geometry in computer-aided design.arXiv preprint arXiv:2007.08506, 2020

Ari Seff, Yaniv Ovadia, Wenda Zhou, and Ryan P Adams. Sketchgraphs: A large-scale dataset for modeling rela- tional geometry in computer-aided design.arXiv preprint arXiv:2007.08506, 2020. 3

2007 arXiv
[32]

Vitruvion: A generative model of parametric cad sketches

Ari Seff, Wenda Zhou, Nick Richardson, and Ryan P Adams. Vitruvion: A generative model of parametric cad sketches. arXiv preprint arXiv:2109.14124, 2021. 3

2021 arXiv
[33]

John Wiley & Sons, 1995

Jami J Shah and Martti M ¨antyl¨a.Parametric and feature- based CAD/CAM: concepts, techniques, and applications. John Wiley & Sons, 1995. 2

1995
[34]

Analysis of dxf file with an application to 3d graphic display

Wen Shang, Jun Zhong, and Qin Yan. Analysis of dxf file with an application to 3d graphic display. In2012 IEEE International Conference on Information and Automation, pages 611–615. IEEE, 2012. 2, 3

2012
[35]

Llama: Open and efficient foundation language models

Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timoth´ee Lacroix, Baptiste Rozi`ere, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023. 1

2023 arXiv
[36]

Llama 2: Open foundation and fine-tuned chat models, 2023

Hugo Touvron, Louis Martin, Kevin Stone, et al. Llama 2: Open foundation and fine-tuned chat models, 2023. 1

2023
[37]

Attention is all you need.Advances in neural information processing systems, 30, 2017

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszko- reit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need.Advances in neural information processing systems, 30, 2017. 2

2017
[38]

Vq-cad: Computer-aided design model generation with vector quantized diffusion.Computer Aided Geometric Design, 111:102327, 2024

Hanxiao Wang, Mingyang Zhao, Yiqun Wang, Weize Quan, and Dong-Ming Yan. Vq-cad: Computer-aided design model generation with vector quantized diffusion.Computer Aided Geometric Design, 111:102327, 2024. 1, 5

2024
[39]

Fusion 360 gallery: A dataset and environ- ment for programmatic cad construction from human design sequences.ACM Transactions on Graphics (TOG), 40(4): 1–24, 2021

Karl DD Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G Lambourne, Armando Solar-Lezama, and Wo- jciech Matusik. Fusion 360 gallery: A dataset and environ- ment for programmatic cad construction from human design sequences.ACM Transactions on Graphics (TOG), 40(4): ...

2021
[40]

Deepcad: A deep generative network for computer-aided design models

Rundi Wu, Chang Xiao, and Changxi Zheng. Deepcad: A deep generative network for computer-aided design models. InProceedings of the IEEE/CVF International Conference on Computer Vision, pages 6772–6782, 2021. 1, 2

2021
[41]

Cad-llm: Large language model for cad generation

Sifan Wu, Amir Khasahmadi, Mor Katz, Pradeep Kumar Ja- yaraman, Yewen Pu, Karl Willis, and Bang Liu. Cad-llm: Large language model for cad generation. InProceedings of the neural information processing systems conference. neurIPS, 2023. 1

2023
[42]

Skexgen: Autoregressive generation of cad con- struction sequences with disentangled codebooks.arXiv preprint arXiv:2207.04632, 2022

Xiang Xu, Karl DD Willis, Joseph G Lambourne, Chin- Yi Cheng, Pradeep Kumar Jayaraman, and Yasutaka Fu- rukawa. Skexgen: Autoregressive generation of cad con- struction sequences with disentangled codebooks.arXiv preprint arXiv:2207.04632, 2022. 2

2022 arXiv
[43]

Brepgen: A b-rep generative diffusion model with structured latent geometry.ACM Transactions on Graphics (TOG), 43 (4):1–14, 2024

Xiang Xu, Joseph Lambourne, Pradeep Jayaraman, Zhengqing Wang, Karl Willis, and Yasutaka Furukawa. Brepgen: A b-rep generative diffusion model with structured latent geometry.ACM Transactions on Graphics (TOG), 43 (4):1–14, 2024. 2

2024
[44]

An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al. Qwen2. 5 technical report.arXiv preprint arXiv:2412.15115, 2024. 7

2024 arXiv
[45]

Pointflow: 3d point cloud generation with continuous normalizing flows

Guandao Yang, Xun Huang, Zekun Hao, Ming-Yu Liu, Serge Belongie, and Bharath Hariharan. Pointflow: 3d point cloud generation with continuous normalizing flows. InProceed- ings of the IEEE/CVF international conference on computer vision, pages 4541–4550, 2019. 1

2019
[46]

Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x, 2024

Qinkai Zheng, Xiao Xia, Xu Zou, Yuxiao Dong, Shan Wang, Yufei Xue, Zihan Wang, Lei Shen, Andi Wang, Yang Li, Teng Su, Zhilin Yang, and Jie Tang. Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x, 2024. 1

2024
[47]

mm"), ).render() dim_v = msp.add_linear_dim( base=(p0[0] - 5, (height / 2) + p0[1]), p1=p0, p2=(p0[0], height + p0[1]), dimstyle='Standard', angle=90, text=str(str(height)+

Qingnan Zhou and Alec Jacobson. Thingi10k: A dataset of 10,000 3d-printing models, 2016. 3 Supplemental Materials The content of this supplementary material involves: A. Experimental Setup and Costs in Sec. A. B. Details of LoRA Fine-Tuning in Sec. B. C. Evaluation Metrics in ...

2016

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.

[1] [1]

Autolisp.https://help.autodesk.com/view/ OARX/2023/ENU/?guid=GUID- 265AADB3- FB89- 4D34-AA9D-6ADF70FF7D4B, . 2, 3

work page 2023

[2] [2]

autodesk

Autocad.https : / / www . autodesk . com . cn / products / autocad / overview ? term = 1 - YEAR & tab=subscription, . 2, 3, 7, 8

work page

[3] [3]

Caxa.https://www.caxa.com/cad/index.html. 2, 8

work page

[4] [4]

Catia.https : / / www . 3ds . com / zh - hans / products/catia/all-products. 2, 8

work page

[5] [5]

Freecad.https://www.freecad.org. 2, 3

work page

[6] [6]

Onshape.https://www.onshape.com/en/. 2, 8

work page

[7] [7]

Solidworks.https://www.solidworks.com/zh- hans/lp/proven- solution- 3d- design- and- product-development. 2, 7, 8

work page

[8] [8]

Ug.https://plm.sw.siemens.com/en-US/nx/ cad-online/. 2, 8

work page