Automated CAD Modeling Sequence Generation from Text Descriptions via Transformer-Based Large Language Models
Authors: JianXing Liao, Junyan Xu, Yatao Sun, Maowen Tang, Sicheng He, Jingxian Liao, Shui Yu, Yun Li, Xiaohong Guan
Accepted at: acl25

Automated CAD Modeling Sequence Generation from Text Descriptions via Transformer-Based Large Language Models

Jianxing Liao1*, Junyan Xu1*, Yatao Sun1, Maowen Tang1, Sicheng He1, Jingxian Liao1, Shui Yu††, Yun Li††, Xiaohong Guan2
1Shenzhen Institute for Advanced Study,
University of Electronic Science and Technology of China,
Shenzhen, 518000, China
2i4AI Ltd, London WCIN3AX, United Kingdom
†Shui.Yu@i4AI.org, Yun.Li@ieee.org

Abstract

Designing complex computer-aided design (CAD) models is often time-consuming due to challenges such as computational inefficiency and the difficulty of generating precise models. We propose a novel language-guided framework for industrial design automation to address these issues, integrating large language models (LLMs) with computer-automated design (CAutoD). Through this framework, CAD models are automatically generated from parameters and appearance descriptions, supporting the automation of design tasks during the detailed CAD design phase. Our approach introduces three key innovations: (1) a semi-automated data annotation pipeline that leverages LLMs and vision-language large models (VLLMs) to generate high-quality parameters and appearance descriptions; (2) a Transformer-based CAD generator (TCADGen) that predicts modeling sequences via dual-channel feature aggregation; (3) an enhanced CAD modeling generation model, called CADLLM, that is designed to refine the generated sequences by incorporating the confidence scores from TCADGen. Experimental results demonstrate that the proposed approach outperforms traditional methods in both accuracy and efficiency, providing a powerful tool for automating industrial workflows and generating complex CAD models from textual prompts. The code is available at https://jianxliao.github.io/cadllm-page/

1 Introduction

Computer-aided design (CAD) is important in industrial design and additive manufacturing. It is a key tool from the early stages of design to prototype production (Marchesi et al., 2021; Rapp et al., 2021). Computer-Automated Design (CAutoD) represents an evolution of the traditional CAD by integrating automation and machine learning algorithms to assist in the design process (Li, 2022). With the fast growth of AI, especially large language models (LLMs), combining CAD and AI is becoming a major factor in improving design speed and creativity (Guo et al., 2022; Dai and Hong, 2024). This development speeds up the design process and increases the possible uses of CAD systems, making them more intelligent and personalized. In recent years, more research focuses on combining AI with CAD (Xu et al., 2024a; Wu et al., 2024). Methods such as generating parametric CAD models from the textual description and improving automated design tools with AI are proposed (Yavartanoo et al., 2024). These studies show that AI in CAD can speed up design and make CAD tools more flexible and smart. The integration of AI is pushing CAD towards CAutoD, representing a shift from the traditional, computer-aided design to computer-automated design processes.

Most current research on combining LLMs with CAD focuses on the data synthesis ability of these models, such as generating design information by processing large datasets. However, design data synthesized by LLMs often lacks sufficient accuracy (Fan et al., 2025; Wu et al., 2021). Without parameter review, converting this data into high-quality, editable CAD models is difficult, especially in industrial design, where precision is critical. While current research emphasizes the ability of LLMs to understand complex problems, their application in complex CAD tasks still faces several challenges (Plaat et al., 2024). First, LLMs are computationally expensive and inefficient (Luo et al., 2023). Second, it is difficult for designers to guide these LLMs to generate reasonable CAD models using simple language or visual descriptions, limiting their practical use in CAD design. Despite these challenges, LLMs still have significant potential in CAD design and warrant further research. One promising solution is to combine
finely tuned small generative models (with fewer parameters) with large models (with massive parameters) (Xu et al., 2023). The small generative models can provide more accurate guidance for specific tasks, compensating for the limitations of the large models in detailed reasoning and thus improving overall accuracy (Chen and Varoquaux, 2024). This approach can enhance the design synthesis capabilities of large models and reduce the uncertainties that often arise in the reasoning process (Fang et al., 2024). Using small models as auxiliary modules in CAD design can improve the accuracy and efficiency of design, offering a more reliable solution for complex tasks.

In this paper, we propose a novel framework, as shown in Fig. 1, for generating high-quality CAD modeling sequences, where LLMs generate CAD operation commands and the corresponding parameters to facilitate CAD modeling. Specifically, we focus on the detailed design phase, where precise parameter and appearance descriptions are transformed into CAD models without human intervention. Through this automation, our work represents a significant step toward fully automating the CAD design process, enhancing both speed and accuracy in industrial applications, and supporting the vision of CAutoD. Our approach has three key innovations:

• We propose a semi-automated annotation pipeline with LLMs and VLLMs, enabling high-quality CAD description generation through automated validation and verification.

• We present TCADGen, a Transformer-based dual-channel architecture for transforming descriptive annotations into CAD commands, achieving improved sequence accuracy.

• We introduce a CAD-specific LLM enhancement framework, demonstrating its effectiveness in refining command types and parameter values for industrial applications.

2 Related Works

Extending the traditional CAD, CAutoD has witnessed significant advancements in recent years across various industries, including ship design, architectural design, and mechanical engineering (Ang et al., 2016; Bye et al., 2017). These advancements are largely driven by progress in dataset (Wu et al., 2021; Yavartanoo et al., 2024; Fan et al., 2025), sequence generation (Yavartanoo et al., 2024), and large language models (Rapp et al., 2021). ModelNet is the first large dataset of 3D CAD mesh models (Vishwanath et al., 2009). However, it does not include modeling process data. The Fusion 360 Gallery dataset later adds modeling history and assembly data (Willis et al., 2021). The Mechanical Components Benchmark then provides complete modeling histories for mechanical parts (Kim et al., 2020). These datasets focus on geometric features but lack natural language descriptions of CAD models. Deep learning creates new ways to approach CAD modeling. DeepCAD uses a Transformer model to generate CAD sequences (Wu et al., 2021). It breaks down CAD modeling into sketches and extrusion steps. However, it generates sketches before extrusion parameters, often creating disconnected sequences. It also supports only basic modeling operations. Text2CAD proposes a different approach that generates CAD sequences from text description and visual features (Yavartanoo et al., 2024). However, they do not consider that large models excel in generative and reasoning abilities to assist in design.

LLMs lead to new CAD modeling methods. BlenderLLM uses LLMs to generate CAD sequences through self-improvement (Du et al., 2024). It creates the BlendNet dataset and CAD-Bench for evaluation. However, its sequences lack geometric constraints, which affect model accuracy. Query2CAD uses LLMs to generate CAD commands and improves designs through iterations (Badagabettu et al., 2024). However, it often misses steps when handling complex tasks. CAD-CodeVerify combines vision and language models to generate and improve CAD code (Alrashedy et al., 2024). However, the multiple rounds of visual checking and code fixing needed make it slow to use. The AutoForma framework (Liao et al., 2024) , which leverages a large language model-based multi-agent system for the automated generation of CAD models. However, the method is costly and suffers from low generation efficiency.

3 Methodology

3.1 Problem Definition

Given a CAD model’s appearance description text \( T_{\text{appear}} \in \mathcal{V}_{\text{appear}} \) and its corresponding parameter modeling description text \( T_{\text{param}} \in \mathcal{V}_{\text{param}} \), where \( \mathcal{V}_{\text{appear}} \) and \( \mathcal{V}_{\text{param}} \) represent the vocabulary for appearance descriptions and parameter descrip-
Figure 1: The overall framework of automated CAD modeling from text descriptions, leveraging Transformer-based sequence generation and LLM-driven refinement. The innovations proposed in our work are highlighted in (a), (b), and (c).

tions respectively. Our goal is to generate a complete CAD Command Sequence (CCS)\footnote{An introduction to CCS can be found in Appendix A.1}. \( \mathbf{M} = \{(c_1, \mathbf{p}_1), (c_2, \mathbf{p}_2), ..., (c_N, \mathbf{p}_N)\} \), where \( c_i \in \mathcal{C} \) represents the type of the i-th modeling command, \( \mathbf{p}_i \in \mathbb{R}^d \) represents the corresponding parameter vector in d-dimensional vector space, and \( \mathcal{C} \) is the predefined set of CAD commands. This task can be divided into two stages:

**TCADGen Sequence Generation:** We define the TCADGen sequence generation problem as a mapping from appearance and parameter descriptions to CAD command sequences and their confidence scores: \( f_{\text{TCADGen}}(T_{\text{appear}}, T_{\text{param}}) = (\mathbf{M}, \mathbf{S}) \), where \( T_{\text{appear}} \) is the appearance description text, \( T_{\text{param}} \) is the parameter description text, \( \mathbf{M} \) is the predicted CAD Command Sequence (CCS), \( \mathbf{S} = s_1, s_2, ..., s_N \) represents the confidence scores for each command and its parameters, \( s_i = (s_i^{\text{cmd}}, s_i^{\text{args}}) \) represents the confidence scores for command type and parameters respectively, \( N \) is the total number of commands in the sequence, \( s_i^{\text{cmd}} \) represents the confidence score for the i-th command type, and \( s_i^{\text{args}} \) represents the confidence score for the parameters of the i-th command.

**CADLLM CCS enhancement:** We formulate the CADLLM CCS enhancement stage as: \( f_{\text{CADLLM}}(T_{\text{appear}}, T_{\text{param}}, \mathbf{M}, \mathbf{S}) = \mathbf{M}^* \), where \( \mathbf{M}^* \) is the final optimized modeling sequence. \( f_{\text{CADLLM}} \) represents the industrial design domain large model CADLLM. The optimization objective is formulated as follows:

\[
\begin{align}
& \max_{\mathbf{M}^*} \quad p(\mathbf{M}^*|T_{\text{appear}}, T_{\text{param}}) \\
& \text{s.t.} \quad \forall (c_i, \mathbf{p}_i) \in \mathbf{M}^*, c_i \in \mathcal{C}, \mathbf{p}_i \in \mathbb{R}^d,
\end{align}
\]
Figure 2: LLM-Based Semi-Automated Annotation for CAD Datasets Process. This pipeline primarily generates appearance and parameter descriptions for CAD datasets, focusing on the Description Generation and Description Quality Inspection stages.

where \( \mathbf{M}^* \) is constrained to be a valid CAD modeling sequence, \( c_i \) represents the \( i \)-th command type, \( \mathbf{p}_i \) represents the parameters for the \( i \)-th command, \( \mathcal{C} \) is the set of all valid CAD commands, \( d \) is the dimension of the parameter space, and \( p(\mathbf{M}|T_{\text{appear}}, T_{\text{param}}) \) represents the probability of generating sequence \( \mathbf{M}^* \) given the input descriptions.

The proposed framework aims to generate high-quality CAD modeling sequences through this two-stage process, where TCADGen generates the initial modeling sequences and the corresponding confidence assessment, followed by the optimization and improvement of the sequences in CADLLM.

3.2 Proposed Method

3.2.1 LLM-Based Semi-Automated Annotation for CAD Datasets

To efficiently create high-quality annotations for large CAD datasets, we propose a semi-automated annotation pipeline based on LLMs, utilizing multiple LLMs in a coordinated workflow. Annotating the appearance of CAD models requires human-machine collaboration, while parameter description annotation can be fully automated. Each annotation pipeline includes a description generation stage and a description quality control stage. The process is described in Fig. 2.

(i). Semi-Automated Appearance Description

Generation

To address the challenge of efficiently labeling large-scale CAD datasets, we leverage LLMs to automate parameter descriptions and assist in appearance annotation. For the description generation stage, we first sample multiple views of the CAD model and use a VLLM to generate an appearance description based on these views. Simultaneously, point cloud data from the CAD model is processed by a PointLLM (Xu et al., 2024b) to generate descriptions based on the point cloud. The models answer key questions regarding the 3D model's appearance features, material composition, specific details, and function.

For the description quality inspection stage, we use LLM to check the consistency between the point cloud and multi-view descriptions and point out conflicts (e.g., one calling it a cylinder, another a cube). If the point cloud and multi-view descriptions align well, they are merged into a comprehensive appearance description; otherwise, manual annotation is required (our experiments showed an automatic pass rate of 98.4%, with only a few samples needing human intervention). The final appearance description comes from combining both the automated and manual annotations.

(ii). Automated Parameter Description Generation

The parameter description is primarily generated
based on the CCS. For the description generation stage, annotated CCS parameter data is input into the LLM along with a predefined prompt template. The prompt also specifies that descriptions must be "fluent and instructive paragraphs" detailing each step of the CAD modeling process and the corresponding parameters.

For the description quality inspection stage, we validate the accuracy of the generated CCS parameter description by reverse verification. It is deemed correct if the model can reconstruct the ground truth CCS from the generated description. The reliability of the description is measured by the longest common subsequence (LCS) ratio between the generated CCS and the ground truth CCS. The LCS metric effectively captures structural similarities between sequences while allowing for minor variations, making it well-suited for evaluating CAD modeling descriptions. To quantify the similarity between the generated description and the ground truth, we use the LCS_ratio:

\[
\text{LCS}_{\text{ratio}} = \frac{\operatorname{len}(\text{LCS}(g, r))}{\operatorname{len}(g)},
\]

where \( g \) denotes the ground truth CCS and \( r \) represents the generated CCS. Descriptions with an LCS_ratio above 0.9 are accepted, while those with an LCS ratio below 0.9 are considered low reliability and enter a reflection optimization process.

Reflection Optimization Process: For low-reliability descriptions, we follow a reflection optimization process:

1. Analyze potential issues in the description generation stage based on ground truth CCS.
2. Generate a new CCS parameter description based on the model’s reflection feedback from Step 1.
3. Recheck the newly generated description.

This process repeats until the description reaches the reliability threshold (i.e., \( \text{LCS}_{\text{ratio}} \geq 0.9 \)) or the maximum retry limit (twice). Note that this process is fully automated, requiring no human intervention for parameter description annotation.

3.2.2 TCADGen
We propose a novel CAD model generation framework called TCADGen, which innovatively adopts a dual-channel Transformer architecture to achieve an effective fusion of parameter modeling knowledge and visual appearance features, as shown in Fig. 3.

(i). Dual-Channel Feature Aggregator To fully preserve both parametric features and appearance features of the model, we propose a dual-channel feature aggregator that simultaneously embeds parameter descriptions and appearance descriptions. Parameter descriptions contain both basic geometric operations and specific parameter designs, while appearance descriptions include model appearance analysis. Based on DeBerta-Large-v3 (Tran et al., 2024), we first encode and project the input text through BERT and linear transformation:

\[
\mathbf{h}_p = BERT(T_{param}) \mathbf{W}_p + \mathbf{b}_p,
\]
\[
\mathbf{h}_a = BERT(T_{appear}) \mathbf{W}_a + \mathbf{b}_a,
\]

where \( T_{param} \) and \( T_{appear} \) are the input parameter and appearance description texts respectively, \( d_p \) and \( d_a \) are the dimensions of parameter and appearance features, \( d \) is the dimension of the shared semantic space, \( \mathbf{W}_p \in \mathbb{R}^{d_p \times d} \) and \( \mathbf{W}_a \in \mathbb{R}^{d_a \times d} \) are projection matrices that map BERT embeddings into a shared \( d \)-dimensional semantic space, and \( \mathbf{b}_p, \mathbf{b}_a \) represent bias vectors.

Inspired by capsule networks (Patrick et al., 2022), we design an adaptive feature fusion mechanism based on dynamic routing to fully utilize the normalized feature representations:

\[
\mathbf{s}_j = \sum_i \operatorname{softmax}(\mathbf{W}_r [\hat{\mathbf{h}}_p^i; \hat{\mathbf{h}}_a^i]) \hat{\mathbf{h}}_p^i \mathbf{W}_{ij},
\]

where \( \hat{\mathbf{h}}_p \) and \( \hat{\mathbf{h}}_a \) denote the normalized representations of \( \mathbf{h}_p \) and \( \mathbf{h}_a \) respectively, \( \mathbf{W}_r \) is a learnable routing weight matrix, \( i \) and \( j \) correspond to the subscripts of the feature tokens, \( [;\cdot] \) represents feature concatenation, and \( \mathbf{W}_{ij} \) is the feature transformation matrix between tokens \( i \) and \( j \).

The final fused features are obtained through a weighted combination:

\[
\mathbf{z} = \sum_j \alpha_j \mathbf{s}_j,
\]

where \( \alpha_j \) represents adaptive weight coefficients calculated through the attention mechanism and \( \mathbf{z} \) is the final fused feature vector.

(ii). CAD Command Sequence Decoder
We then decode the fused feature vector \( \mathbf{z} \) into a standardized CAD modeling sequence. We first
use a multi-head attention mechanism to capture global dependencies:

\[
\mathbf{H}^l = \text{MultiHead}(\mathbf{W}_Q^l \cdot \text{PE}(\cdot), \mathbf{W}_K^l : \mathbf{z}, \mathbf{W}_V^l : \mathbf{z}),
\]

where \( \mathbf{H}^l \) is the output of the \( l \)-th attention layer, \( \mathbf{W}_Q^l, \mathbf{W}_K^l, \) and \( \mathbf{W}_V^l \) are learnable query, key, and value projection matrices respectively, and \( \text{PE}(\cdot) \) represents positional encoding. To better capture the sequential modeling patterns, we further incorporate bidirectional LSTM (Greff et al., 2016) into our architecture:

\[
\text{out}_t = [LSTM(\overrightarrow{\mathbf{h}}_t); LSTM(\overleftarrow{\mathbf{h}}_t)],
\]

where \( \text{out}_t \) is the output at time step \( t \), \( \overrightarrow{\mathbf{h}}_t \) and \( \overleftarrow{\mathbf{h}}_t \) denote the forward and backward hidden states respectively, and \( [\cdot; \cdot] \) represents concatenation.

For efficient sequence generation, we design the model to predict the entire CAD modeling sequence in parallel:

\[
p(\widehat{\mathbf{M}}|\mathbf{z}, \Theta) = \prod_{i=1}^{N_c} p(t_i, \hat{p}_i|\mathbf{z}, \Theta),
\]

where \( \widehat{\mathbf{M}} \) represents the predicted CAD modeling sequence, \( \Theta \) denotes the model parameters, \( N_c \) is the number of CAD commands in the sequence, \( t_i \) represents the command type at position \( i \), and \( \hat{p}_i \) represents the predicted parameters for the command at position \( i \).

3.2.3 LLM-Enhanced CAD Command Sequence Generation

The results predicted by TCADGen can assist LLM in generating more accurate CCS. In this paper, we propose an enhanced CCS generation process based on large language models, referred to as CADLLM. This process combines the CCS generated by TCADGen, prediction confidence information, and user-provided description, enabling the precise generation of CCS through a fine-tuned large language model.

During the training phase, the fine-tuned model is trained on 1,000 samples (the choice of dataset size is explained in the experimental section, RQ3) that are consistent with the distribution of the dataset. The task is designed such that the output of TCADGen (predicted CCS and its confidence) serves as the query for supervised fine-tuning (SFT) to generate the correct CCS as the response. By learning the mapping between CCS and confidence, CADLLM corrects the errors generated by TCADGen and produces more accurate CCS.

During the inference phase, CADLLM acts as the inference model. It takes as input the user’s parameters, appearance description, CCS generated by TCADGen based on user requirements, and the confidence information and outputs the enhanced CCS data.

4 Experiments

In our experiments, we address three research questions to evaluate the effectiveness of the proposed methodologies. For a detailed description of the dataset and parameters, please refer to Appendix A.2 and A.3.

RQ1: How effective is the proposed LLM-based semi-automated annotation framework in improving the quality of annotations for CAD datasets?

We have proposed a human-machine semi-automated CAD dataset annotation process that utilizes large models for annotation and verification to ensure quality. For the parameter description generation task, both the description generation and describe quality inspection stages utilize the gemma-2-27b-it (Google, 2024) model (the reasons for model selection and parameter description generation evaluation are provided in Appendix A.6). The reflection optimization process uses the gemma-2-27b-it model. For the appearance description generation task, the VLLM used for the description generation stage is the Llama-3.2-11B-Vision-Instruct (Meta, 2024) model, while the point cloud model uses PointLLM (Xu et al., 2024b). The description quality inspection stage also utilizes the gemma-2-27b-it model.

The experimental results demonstrate that this framework significantly improves annotation quality over the Text2CAD baseline (Khan, 2025) across most evaluation metrics. The experimental results are presented in Table 1, with the TCADGen (Text2CAD-dataset) row displaying the corresponding results. For overall performance, command line accuracy improves from 0.804 to 0.890, an increase of about 8.6 percentage points. The framework shows enhanced performance on commands such as Arc, Circle, and Extrude. Notably, the AUC-F1 score for Circle operations increases from 0.731 to 0.771, reflecting improved annotation capability for circular geometric elements. However, performance on complex operations, such as Ex-
Figure 3: Transformer-based CAD Generator (TCADGen).

<table>
  <tr>
    <th rowspan="2">Models</th>
    <th colspan="3">Avg Command</th>
    <th colspan="8">Each Command</th>
  </tr>
  <tr>
    <th>ACC</th>
    <th>F1</th>
    <th>AUC</th>
    <th>AUC</th>
    <th>F1</th>
    <th>AUC</th>
    <th>F1</th>
    <th>AUC</th>
    <th>F1</th>
    <th>AUC</th>
    <th>F1</th>
  </tr>
  <tr>
    <td>DeepCAD</td>
    <td>0.571</td>
    <td>0.606</td>
    <td>0.747</td>
    <td>0.648</td>
    <td>0.797</td>
    <td>0.540</td>
    <td>0.588</td>
    <td>0.587</td>
    <td>0.551</td>
    <td>0.616</td>
    <td>0.615</td>
  </tr>
  <tr>
    <td>Text2CAD</td>
    <td>0.840</td>
    <td>0.722</td>
    <td>0.819</td>
    <td>0.763</td>
    <td>0.904</td>
    <td>0.584</td>
    <td>0.601</td>
    <td>0.751</td>
    <td>0.701</td>
    <td>0.772</td>
    <td>0.705</td>
  </tr>
  <tr>
    <td>BERT fine-tuned w/o</td>
    <td>0.807</td>
    <td>0.731</td>
    <td>0.828</td>
    <td>0.760</td>
    <td>0.937</td>
    <td>0.637</td>
    <td>0.690</td>
    <td>0.757</td>
    <td>0.690</td>
    <td>0.711</td>
    <td>0.622</td>
  </tr>
  <tr>
    <td>Dual-channel w/o</td>
    <td>0.847</td>
    <td>0.769</td>
    <td>0.850</td>
    <td>0.791</td>
    <td>0.945</td>
    <td>0.668</td>
    <td>0.523</td>
    <td>0.802</td>
    <td>0.762</td>
    <td>0.746</td>
    <td>0.684</td>
  </tr>
  <tr>
    <td>TCADGen(Text2CAD-dataset)</td>
    <td>0.804</td>
    <td>0.731</td>
    <td>0.822</td>
    <td>0.760</td>
    <td>0.920</td>
    <td>0.613</td>
    <td>0.590</td>
    <td>0.780</td>
    <td>0.731</td>
    <td>0.795</td>
    <td>0.767</td>
  </tr>
  <tr>
    <td><b>TCADGen</b></td>
    <td>0.890</td>
    <td>0.771</td>
    <td>0.854</td>
    <td>0.808</td>
    <td>0.950</td>
    <td>0.682</td>
    <td>0.642</td>
    <td>0.837</td>
    <td>0.771</td>
    <td>0.781</td>
    <td>0.746</td>
  </tr>
  <tr>
    <td><b>TCADGen+CADLLM (Ours)</b></td>
    <td><b>0.966</b></td>
    <td><b>0.947</b></td>
    <td><b>0.962</b></td>
    <td><b>0.957</b></td>
    <td><b>0.979</b></td>
    <td><b>0.925</b></td>
    <td><b>0.924</b></td>
    <td><b>0.959</b></td>
    <td><b>0.960</b></td>
    <td><b>0.942</b></td>
    <td><b>0.946</b></td>
  </tr>
</table>

Table 1: Comparison of different models and datasets for CAD command prediction. The Average Command section shows the overall performance metrics, while the Per Command section shows detailed AUC and F1 scores for a specific command type. Bold numbers indicate the best performance.

trude, shows a slight decrease from 0.767 to 0.746, suggesting areas for further improvement.

![Distribution of LCS_ratio scores before and after the Reflection Optimization Process.](page_104_1042_495_312.png)

Figure 4: Distribution of LCS_ratio scores before and after the Reflection Optimization Process.

Additionally, we assess the reflection optimization process for enhancing CCS parameter descriptions with low quality (LCS_ratio < 0.9). This process, which includes error analysis, reflective feedback, and re-evaluation, shows a significant increase in confidence scores (\( t = -137.76, p < 0.001 \)), confirming its effectiveness. Histogram and Kernel Density Estimate (KDE) analyses (see Fig. 4) reveal that after optimization, LCS_ratio scores cluster near 1.0, indicating improved reliability and consistency.

RQ2: How well does TCADGen perform in translating the human modeling language into standard CAD command sequences?

As shown in Table 1, the experimental results demonstrate that TCADGen significantly outperforms existing methods in generating CAD modeling sequences. Compared to the DeepCAD baseline, TCADGen achieves a 31.8 percentage point improvement in average command accuracy and surpasses DeepCAD in overall performance metrics, with an \( F1 \) score of 0.771 and AUC of 0.854. Additionally, in comparison to Text2CAD, TCADGen shows a 5 percentage point improvement in average command accuracy and demon-

![The impact of data size on CADLLM performance. As the data size increases from 0 to 1000 samples.](page_768_1042_495_312.png)

Figure 5: The impact of data size on CADLLM performance. As the data size increases from 0 to 1000 samples.
<table>
  <tr>
    <th>Input</th>
    <th>Model</th>
    <th>Acc.</th>
    <th>Avg LCS<sub>ratio</sub></th>
  </tr>
  <tr>
    <td rowspan="3">Parameter Description and Appearance Description</td>
    <td>GPT-4o(prompt)</td>
    <td>0.617</td>
    <td>0.977</td>
  </tr>
  <tr>
    <td>Llama 3.2 3B(prompt)</td>
    <td>0.328</td>
    <td>0.688</td>
  </tr>
  <tr>
    <td>Llama 3.2 3B(SFT)</td>
    <td>0.621</td>
    <td>0.883</td>
  </tr>
  <tr>
    <td rowspan="5">Transformer-based Prediction of CCS and CCS Confidence</td>
    <td>GPT-4o(prompt) + TCADGen</td>
    <td>0.670</td>
    <td>0.947</td>
  </tr>
  <tr>
    <td>Claude-3.5(prompt) + TCADGen</td>
    <td>0.812</td>
    <td>0.963</td>
  </tr>
  <tr>
    <td>Llama 3.2 3B(prompt) + TCADGen</td>
    <td>0.328</td>
    <td>0.683</td>
  </tr>
  <tr>
    <td>CADLLM + DeepCAD</td>
    <td>0.677</td>
    <td>0.978</td>
  </tr>
  <tr>
    <td>CADLLM + Text2CAD</td>
    <td>0.710</td>
    <td>0.974</td>
  </tr>
  <tr>
    <td><b>CADLLM + TCADGen(ours)</b></td>
    <td><b>0.864</b></td>
    <td><b>0.983</b></td>
  </tr>
</table>

Table 2: Performance comparison of different methods for CAD command sequence generation. Our proposed CADLLM + TCADGen achieves the best performance in both accuracy and average LCS<sub>ratio</sub>.

<table>
  <tr>
    <th>Method</th>
    <th>Model</th>
    <th>CD<sub>↓</sub></th>
    <th>MMD<sub>↓</sub></th>
    <th>JSD<sub>↓</sub></th>
  </tr>
  <tr>
    <td rowspan="4">Transformer-based</td>
    <td>DeepCAD</td>
    <td>169.93</td>
    <td>31.91</td>
    <td>45.03</td>
  </tr>
  <tr>
    <td>Text2CAD</td>
    <td>142.83</td>
    <td>28.98</td>
    <td>40.23</td>
  </tr>
  <tr>
    <td>CAD Translator</td>
    <td>-</td>
    <td>2.94</td>
    <td>10.92</td>
  </tr>
  <tr>
    <td>TCADGen</td>
    <td>120.99</td>
    <td>21.36</td>
    <td>35.25</td>
  </tr>
  <tr>
    <td rowspan="4">LLM-based</td>
    <td>CADFusion</td>
    <td>45.67</td>
    <td>3.49</td>
    <td>17.11</td>
  </tr>
  <tr>
    <td>DeepCAD+CADLLM</td>
    <td>4.25 (↓165.68)</td>
    <td>3.13 (↓28.78)</td>
    <td>8.58 (↓36.45)</td>
  </tr>
  <tr>
    <td>Text2CAD+CADLLM</td>
    <td>4.31 (↓138.52)</td>
    <td>3.12 (↓25.86)</td>
    <td>8.42 (↓31.81)</td>
  </tr>
  <tr>
    <td>TCADGen+CADLLM(ours)</td>
    <td>3.12 (↓117.87)</td>
    <td>2.78 (↓18.58)</td>
    <td>8.38 (↓26.87)</td>
  </tr>
</table>

Table 3: Quantitative comparison of Chamfer Distance (CD), Minimum Matching Distance (MMD), and Jensen-Shannon Divergence (JSD) metrics, where lower values indicate better performance (↓).

strates better performance for complex modeling commands, such as Line (AUC from 0.648 to 0.808), Arc (AUC from 0.540 to 0.682), and Circle (AUC from 0.587 to 0.837). The ablation studies further validate this effectiveness, showing that removing CAD-specific BERT fine-tuning leads to a 4 percentage points drop in performance, while the dual-channel architecture significantly improves complex command generation, e.g., Extrude (\( F1 = 0.7457 \)), indicating better distribution alignment and semantic consistency with ground truth commands.

RQ3: How effective are LLM in correcting TCADGen-generated CAD command sequences?

We compare two methods of using LLMs to generate CCS: one that directly generates CCS using parameter and appearance descriptions and the other that combines transformer-based predictions with CCS confidence scores. Even with fine-tuning, the direct description method, such as Llama 3.2 3B with prompt or LoRA, performs worse than the Transformer-based approach. For example, Llama achieves 32.8% accuracy (LCS<sub>ratio</sub> 0.6881), while GPT-4o with predictions and confidence improves to 67.0% accuracy (LCS<sub>ratio</sub> 0.9477). The optimal method, CADLLM + TCADGen, achieves 86.4% accuracy and LCS<sub>ratio</sub> of 0.983, demonstrating that combining Transformer predictions with confidence scores is significantly more effective than direct generation from descriptions.

The evaluation results are presented in Table 3 for model generation quality. Among Transformer-based methods, TCADGen achieves the best performance, with a Chamfer Distance (CD) of 120.99, Minimum Matching Distance (MMD) of 21.36, and Jensen-Shannon Divergence (JSD) of 35.25. In comparison, CAD Translator (Li et al., 2024), which employs a one-stage framework, shows inferior performance, with a CD of 142.83. The introduction of CADLLM significantly enhances the performance of Transformer-based models. Specifically, TCADGen+CADLLM (ours) achieves a CD of 4.52 (↓116.47), MMD of 2.78 (↓18.17), and JSD of 8.38 (↓26.57). Meanwhile, CADFusion (Wang et al., 2025), which utilizes a two-stage training process with LLaMA-3-8b-Instruct, demonstrates lower accuracy, with a CD of 45.67. In contrast, our approach, which employs the smaller LLaMA-3.2-3b-Instruct model, outperforms both CADFusion and CAD Translator in all key metrics, further highlighting the effectiveness of CADLLM.

Our experimental results show that increasing the fine-tuning data size (from 0 to 1000 samples) leads to substantial performance improvements in CADLLM (Fig. 5, Table 10). Specifically, CCS accuracy improves from 16.0% to 86.4%, while LCS<sub>ratio</sub> increases from 0.622 to 0.983. The performance improves only slightly after 500 samples, showing that 1000 samples achieve the best model
performance and training cost balance.

5 Conclusion

This paper proposes a CAutoD framework that combines LLMs with domain-specific CAD parametrization to generate CAD models from user descriptions in the detailed design phase. We have demonstrated that, owing to the key innovations such as a semi-automated data annotation pipeline, TCAD-Gen, and LLM-assisted enhancement, the framework has significantly outperformed the existing methods in CAD modeling sequence generation accuracy and efficiency, making it a valuable tool for generating precise CAD models from textual prompts. Future work will focus on scaling the framework and exploring its applications in broader industrial design scenarios.

Limitations

Our framework demonstrates promising results in generating CAD modeling sequences, but several challenges remain. The semi-automatic data annotation process is resource-intensive, requiring a large number of LLM calls and manual verification for quality control. While automation reduces human effort, inconsistencies between multi-view descriptions and point cloud representations still require intervention, limiting scalability for large datasets.

The imbalance in command distributions affects model robustness, as certain operations, such as "Line," appear significantly more often than others like "Arc." This bias in training data leads to better performance on frequent commands while limiting generalization to complex 3D geometries that require underrepresented operations.

While the framework effectively generates and optimizes CAD sequences, it does not explicitly incorporate geometric constraints or structural reasoning, resulting in syntactically correct sequences that may not always align with practical design requirements. Future work could explore integrating geometric priors and constraint-aware learning to improve the reliability and applicability of automated CAD modeling.

Our framework focuses on the detailed design process during the CAD design phase and does not provide adequate support for the conceptual design phase, where parameter descriptions may be incomplete or vague.

Acknowledgements

This work is supported by the National Natural Science Foundation of China (Grant No. 52405253), by the Ministry of Science and Technology of China (Grant No. H20240917), and by the Sichuan Province Science and Technology Innovation Seedling Project (Grant No. MZGC20240134).
References

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

Joo Hock Ang, Cindy Goh, and Yun Li. 2016. Smart design for ships in a smart product through-life and industry 4.0 environment. In 2016 IEEE congress on evolutionary computation (CEC), pages 5301–5308. IEEE.

Akshay Badagabetu, Sai Sravan Yarlagadda, and Amir Barati Farimani. 2024. Query2cad: Generating cad models using natural language queries. arXiv preprint arXiv:2406.00144.

Robin Trulsen Bye, Ottar Osen, Webjørn Rekdalsbakken, Birger Skogeng Pedersen, and Ibrahim Hameed. 2017. An intelligent winch prototyping tool. In Proceedings of the 31st European Conference on Modelling and Simulation (ECMS’17). ECMS European Council for Modelling and Simulation.

Lihu Chen and Gaël Varoquaux. 2024. What is the role of small models in the llm era: A survey. arXiv preprint arXiv:2409.06857.

Xiaoqun Dai and Yan Hong. 2024. Fabric mechanical parameters for 3d cloth simulation in apparel cad: a systematic review. Computer-Aided Design, 167:103638.

Yuhao Du, Shunian Chen, Wenbo Zan, Peizhao Li, Mingxuan Wang, Dingjie Song, Bo Li, Yan Hu, and Benyou Wang. 2024. Blenderllm: Training large language models for computer-aided design with self-improvement. arXiv preprint arXiv:2412.14203.

Rubin Fan, Fazhi He, Yuxin Liu, Yupeng Song, Linkun Fan, and Xiaohu Yan. 2025. A parametric and feature-based cad dataset to support human-computer interaction for advanced 3d shape learning. Integrated Computer-Aided Engineering, 32(1):75–96.

Jiang Fang, Zhicheng Zhang, Jiyan Sun, Jiadong Fu, Haonan He, Yinlong Liu, and Wei Ma. 2024. Improve model robustness in less time than it takes to drink a cup of coffee with plug-and-play plugins. In Proceedings of the Asian Conference on Computer Vision, pages 1520–1531.

Google. 2024. Gemma 2 27b. Accessed: February 5, 2025.

Klaus Greff, Rupesh K Srivastava, Jan Koutník, Bas R Steunebrink, and Jürgen Schmidhuber. 2016. Lstm: A search space odyssey. IEEE transactions on neural networks and learning systems, 28(10):2222–2232.

Haoxiang Guo, Shilin Liu, Hao Pan, Yang Liu, Xin Tong, and Baining Guo. 2022. Complexgen: Cad reconstruction by b-rep chain complex generation. ACM Transactions on Graphics (TOG), 41(4):1–18.

Sadil Khan. 2025. text2cad-dataset. Accessed: 2025-02-16.

Sangpil Kim, Hyung-gun Chi, Xiao Hu, Qixing Huang, and Karthik Ramani. 2020. A large-scale annotated mechanical components benchmark for classification and retrieval tasks with deep neural networks. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XVIII 16, pages 175–191. Springer.

Sebastian Koch, Albert Matveev, Zhongshi Jiang, Francis Williams, Alexey Artemov, Evgeny Burnaev, Marc Alexa, Denis Zorn, and Daniele Panozzo. 2019. Abc: A big cad model dataset for geometric deep learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 9601–9611.

Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica. 2023. Efficient memory management for large language model serving with pagedattention. In Proceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles.

Xueyang Li, Yu Song, Yunzhong Lou, and Xiangdong Zhou. 2024. Cad translator: An effective drive for text to 3d parametric computer-aided design generative modeling. In Proceedings of the 32nd ACM International Conference on Multimedia, pages 8461–8470.

Yun Li. 2022. What should “industry 4.0” differ from previous industrial revolutions? In 2022 27th International Conference on Automation and Computing (ICAC), pages 1–1. IEEE.

JianXing Liao, JunYan Xu, SiCheng He, ZeKe Chen, Shui Yu, and Yun Li. 2024. Autoforma: A large language model-based multi-agent for computer-automated design. In 2024 IEEE International Conference on Systems, Man, and Cybernetics (SMC), pages 1284–1289. IEEE.

Linhao Luo, Yuan-Fang Li, Gholamreza Haffari, and Shirui Pan. 2023. Reasoning on graphs: Faithful and interpretable large language model reasoning. arXiv preprint arXiv:2310.01061.

Giulio Marchesi, Alvise Camurri Piloni, Vanessa Nicolin, Gianluca Turco, and Roberto Di Lenarda. 2021. Chairside cad/cam materials: current trends of clinical uses. Biology, 10(11):1170.

Meta. 2024. Llama 3.2 11b vision instruct. Accessed: February 5, 2025.

Mensah Kwabena Patrick, Adebayo Felix Adekoya, Ayidzoe Abra Mighty, and Baagyire Y Edward. 2022. Capsule networks—a survey. Journal of King Saud University-computer and information sciences, 34(1):1295–1310.
Aske Plaat, Annie Wong, Suzan Verberne, Joost Broekens, Niki van Stein, and Thomas Back. 2024. Reasoning with large language models, a survey. arXiv preprint arXiv:2407.11511.

Martin Rapp, Hussam Amrouch, Yibo Lin, Bei Yu, David Z Pan, Marilyn Wolf, and Jörg Henkel. 2021. Mlcad: A survey of research in machine learning for cad keynote paper. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 41(10):3162–3181.

Hanh Thi Hong Tran, Nishan Chatterjee, Senja Pollak, and Antoine Doucet. 2024. Deberta beats behemoth: A comparative analysis of fine-tuning, prompting, and peft approaches on legallensner. In Proceedings of the Natural Legal Language Processing Workshop 2024, pages 371–380.

Kashi Venkatesh Vishwanath, Diwaker Gupta, Amin Vahdat, and Ken Yocum. 2009. Modelnet: Towards a datacenter emulation environment. In 2009 IEEE Ninth International Conference on Peer-to-Peer Computing, pages 81–82. IEEE.

Ruiyu Wang, Yu Yuan, Shizhao Sun, and Jiang Bian. 2025. Text-to-cad generation through infusing visual feedback in large language models. arXiv preprint arXiv:2501.19054.

Karl DD Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G Lambbourne, Armando Solar-Lezama, and Wojciech Matusik. 2021. Fusion 360 gallery: A dataset and environment for programmatic cad construction from human design sequences. ACM Transactions on Graphics (TOG), 40(4):1–24.

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

Sifan Wu, Amir Hosein Khasahmadi, Mor Katz, Pradeep Kumar Jayaraman, Yewen Pu, Karl Willis, and Bang Liu. 2024. Cadvlm: Bridging language and vision in the generation of parametric cad sketches. In European Conference on Computer Vision, pages 368–384. Springer.

Canwen Xu, Yichong Xu, Shuohang Wang, Yang Liu, Chenguang Zhu, and Julian McAuley. 2023. Small models are valuable plug-ins for large language models. arXiv preprint arXiv:2305.08848.

Jingwei Xu, Chenyu Wang, Zibo Zhao, Wen Liu, Yi Ma, and Shenghua Gao. 2024a. Cad-mllm: Unifying multimodality-conditioned cad generation with mllm. arXiv preprint arXiv:2411.04954.

Runsen Xu, Xiaolong Wang, Tai Wang, Yilun Chen, Jiangmiao Pang, and Dahua Lin. 2024b. Pointllm: Empowering large language models to understand point clouds. In ECCV.

Mohsen Yavartanoo, Sangmin Hong, Reyhaneh Nezhatavar, and Kyoung Mu Lee. 2024. Text2cad: Text to 3d cad generation via technical drawings. arXiv preprint arXiv:2411.06206.

Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, Zheyuan Luo, Zhangchi Feng, and Yongqiang Ma. 2024. Llamafactory: Unified efficient fine-tuning of 100+ language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations), Bangkok, Thailand. Association for Computational Linguistics.
A Appendix

A.1 CAD Command Sequence
In the CAD modeling task proposed in this paper, we adopt a command sequence representation based on sketch-extrusion, and the generated sequence is referred to as the CAD Command Sequence (CCS). The CCS example is shown in Fig. 6, and the detailed CCS parameters are presented in Table 4.

The sequence consists of two-dimensional sketch commands and three-dimensional extrusion commands. Specifically, the two-dimensional sketch section begins with the tag <SOL>, representing the start of a closed contour. Each contour can be constructed using three basic curve commands:

• The Line command determines the direction and length of the straight line by specifying the endpoint coordinates \((x, y)\);

• The Arc command requires the endpoint coordinates \((x, y)\), sweep angle \(\alpha\), and direction flag \(f\) to define the shape and direction of the arc;

• The Circle command creates a complete circular contour by specifying the center coordinates \((x, y)\) and radius \(r\).

Once the two-dimensional sketch is completed, the Extrude command \(E\) transforms it into a three-dimensional solid. This command includes several key parameters:

• The spatial orientation of the sketch plane is determined by the Euler angles \((\theta, \phi, \gamma)\);

• The translation vector \((p_x, p_y, p_z)\) specifies the position of the origin of the sketch plane;

• The scaling factor \(s\) controls the size of the contour;

• The bidirectional extrusion distances \((e_1, e_2)\) determine the thickness of the solid;

• The Boolean operation type \(b\) is used to specify the interaction with existing geometry, which can be a new entity, union, subtraction, or intersection operation;

• The extrusion type \(u\) specifies the extrusion method, including unidirectional, symmetric, or bidirectional extrusion.

The CAD sequence can be modeled by creating two-dimensional sketches and repeatedly applying extrusion commands.

A.2 Dataset
The DeepCAD dataset (Wu et al., 2021), derived from the ABC dataset (Koch et al., 2019), is a large-scale collection of 178,000 parametric CAD models designed for CAD model generation and reconstruction. Unlike other datasets, such as Fusion 360 (Willis et al., 2021) with only 8,000 instances, DeepCAD includes sketch-extrusion sequences, enabling models to learn procedural modeling behaviors rather than static geometry. Its extensive cross-industry coverage ensures strong generalization to external datasets, reducing concerns about overfitting. For this study, DeepCAD was preprocessed to ensure consistency, remove incomplete instances, and improve training efficiency. The corresponding STL file was generated for each sample based on the original model information provided in the dataset’s JSON files. Simultaneously, the CCS descriptions were extracted from the JSON files. The generated STL files were then sampled from nine different viewpoints to produce multi-view images. Additionally, point sampling was performed files, generating point cloud files containing 8,000 points. The subsequent training and validation phases included only those samples for which the STL files, multi-view images, and point cloud files were successfully generated. The final dataset used in this experiment consisted of 155,503 training samples and 5,647 test samples.

A.3 Parameter Setting
We use two main parts in our system: a TCADGen model and a fine-tuned LLM(CADLLM).

For TCADGen, we build a simple Transformer decoder. It has 4 layers and 8 attention heads in each layer. The model’s base size is \(d_{model} = 256\), and it can handle sequences up to 300 tokens. The argument size is 256, and the feedforward layers are 512 units wide. We use a dropout of 0.1 throughout the model to avoid overfitting. We trained the model using a single A6000 GPU for 24 hours. The inference of 5,647 data samples takes 240 seconds.

For the LLM part, Our system uses two main parts and fine-tune it using LoRA, leveraging the LlamaFactory framework (Zheng et al., 2024) for fine-tuning. We set the basic batch size to 1 and use gradient accumulation for 8 steps. This gives
Figure 6: Illustration of the CAD Command Sequence (CCS) representation. The process shows two sketch-extrusion operations: (1) creating a base by sketching a rectangle using Line commands with specified coordinates, followed by an extrusion operation to form a 3D block; (2) adding a circular hole by sketching a circle and applying a cut extrusion operation.

us an effective batch size of 8. We use a learning rate of \(1e^{-4}\) with cosine decay and 10% warmup steps. We train the model for 3 epochs with BF16 precision. This helps us save memory and train faster. The model can take inputs up to 4096 tokens long. We check the model’s performance every 500 step using 20% of our data as a validation set. We save the model version that performs best. We trained and performed inference using a single A6000 GPU. The training duration was 2 hours. For inference, we utilized the vllm framework (Kwon et al., 2023) with a concurrency of 2. Inference of 5,647 test samples took 1.5 hours

A.4 Application of the Framework for Motorcycle Frame Model Generation

In this work, we propose a framework aimed at detailed CAD design, where both the parameters and the full specifications of the model are predefined. The framework generates individual components of the motorcycle frame, which are then manually assembled to produce the final CAD model. Specifically, the proposed framework facilitates the rapid generation of parts that conform to the specified requirements, based on textual descriptions of both appearance and parameters. The generated models are presented in Fig. 7.

A.5 Examples of annotation processes

A.5.1 Parameter Description Labeling Process

Figure 8 shows the Parameter Description Labeling Process. Table 5 shows the parameter descriptions generated by the annotation process proposed in this paper, where LCS\(_{\text{ratio}}\) refers to the comparison between the CCS generated by the large language model in the description quality control stage and the ground truth. When the LCS\(_{\text{ratio}}\) of a description (e.g., No.00159955) is greater than 0.9, it indicates that the parameter description is successfully synthesized and can be adopted. If the LCS\(_{\text{ratio}}\) is below 0.9 (e.g., No.00262583), the description enters the subsequent reflection and optimization process.

Reflection Optimization Process The original CCS and the optimized descriptions are shown in Table 6. The reflection optimization process is detailed in Table 7, where, shows the original CCS and optimized descriptions after two rounds of optimization, the description of the generated parameters achieves an LCS\(_{\text{ratio}}\) of 1.

A.5.2 Appearance Description Annotation

The examples of appearance description generation are shown in Table 8. For each data sample, in the description generation stage, both multi-view descriptions (generated by the VLLM) and point cloud descriptions (generated by the point-cloud-
Figure 7: The motorcycle frame design process: Parts generated using our framework are manually assembled to create the final frame. The figure shows the individual components and their integration into the complete design.

based large language model) are produced simultaneously. The two descriptions are verified using a large language model in the description quality control stage. For example, in sample No. 00247561, the multi-view and point cloud descriptions were inconsistent, and the model’s output was flagged as False. This sample was then sent for manual annotation. In contrast, for sample No. 00041425, the multi-view and point cloud descriptions were consistent, and the model’s output was True, allowing for generating a unified description based on both representations.

A.5.3 LLMCAD Enhancement

Figure 9 shows the final CCS generated by the CADLLM based on the TCADGen CCS output and confidence output. The red and green areas highlight the modified sections, which correspond to the parts where the confidence prediction was lower. This demonstrates that the CAD LLM task involves generating a new, correct CCS based on the existing parameter descriptions, considering the confidence levels and the TCADGen output. In this example, the CCS output from the CAD LLM exactly matches the ground truth.

A.6 The Ability of LLMs to Generate Parameter Descriptions

To assess the ability of LLMs in generating CAD modeling descriptions, we introduce a two-phase evaluation framework consisting of forward generation and backward validation. We evaluate a test set of 1000 samples that reflect the natural distribution of our dataset. LLMs generate CCS descriptions based on given prompts in the forward generation phase. The backward validation phase employs different LLMs to verify these generated descriptions.

We define four evaluation criteria based on LCS_{ratio}:

1. Exact matches: LCS_{ratio} = 1
2. High-quality matches: LCS_{ratio} \geq 0.98
3. Acceptable matches: LCS_{ratio} \geq 0.9
4. Mean LCS_{ratio} across all test samples

The proportions for each criterion are computed as follows:

\[
\text{Proportion}_{\text{criterion}} = \frac{\text{count}(LCS_{ratio} \geq \text{criterion})}{N},
\]

where \( N \) is the total number of samples, and \( LCS_{ratio}^{(i)} \) is the LCS_{ratio} for the \( i \)-th sample. The average LCS_{ratio} is calculated as:

\[
\text{Average LCS}_{ratio} = \frac{1}{N} \sum_{i=1}^{N} LCS_{ratio}^{(i)},
\]
Figure 8: Parameter Description Annotation Process Flow.

Figure 9: Final CCS generated by CAD LLM using TCADGen CCS output and confidence, with red and green areas indicating modified sections.
We present the raw evaluation data in Table 11. Table 12 summarizes the results for the Best Reverse Validation Model, where the model with the highest proportion of LCS Greater than 0.9 for each forward generation model is selected as the Best Reverse Validation Model. The results show strong performance from both closed-source and open-source models. In forward generation, Gemini-1.5-Pro and GPT-4o achieve LCSratio values above 93.9%. Among open-source models, Meta-Llama-3.1-70B-Instruct-Turbo and Meta-Llama-3.1-405B-Instruct-Turbo perform well. Notably, Gemini-2-27B-IT shows competitive results despite its smaller size. For backward validation, we define the Best Reverse Model as the one that most frequently achieves LCSratio > 0.9. Gemini-2-27B-IT is the most reliable model for this validation task, demonstrating its effectiveness in accurately verifying CCS descriptions.

A.7 Prompts Used in Experiments
Table 13 presents all the prompt templates used in this experiment.
<table>
  <tr>
    <th>Command</th>
    <th>Parameter</th>
    <th>Value Range</th>
    <th>Description</th>
  </tr>
  <tr>
    <td>&lt;SOL&gt;</td>
    <td>\( \emptyset \)</td>
    <td>-</td>
    <td>Contour Start Marker</td>
  </tr>
  <tr>
    <td rowspan="2">Line</td>
    <td>x</td>
    <td>[0, 255]</td>
    <td>End point x coordinate of the line segment</td>
  </tr>
  <tr>
    <td>y</td>
    <td>[0, 255]</td>
    <td>End point y coordinate of the line segment</td>
  </tr>
  <tr>
    <td rowspan="4">Arc</td>
    <td>x</td>
    <td>[0, 255]</td>
    <td>End point x coordinate of the arc</td>
  </tr>
  <tr>
    <td>y</td>
    <td>[0, 255]</td>
    <td>End point y coordinate of the arc</td>
  </tr>
  <tr>
    <td>\( \alpha \)</td>
    <td>[0, 255]</td>
    <td>Sweep angle of the arc</td>
  </tr>
  <tr>
    <td>f</td>
    <td>\{0, 1\}</td>
    <td>Counterclockwise direction flag</td>
  </tr>
  <tr>
    <td rowspan="3">Circle</td>
    <td>x</td>
    <td>[0, 255]</td>
    <td>Center x coordinate of the circle</td>
  </tr>
  <tr>
    <td>y</td>
    <td>[0, 255]</td>
    <td>Center y coordinate of the circle</td>
  </tr>
  <tr>
    <td>r</td>
    <td>[0, 255]</td>
    <td>Radius of the circle</td>
  </tr>
  <tr>
    <td rowspan="10">Extrude</td>
    <td>\( \theta \)</td>
    <td>[0, 255]</td>
    <td>Rotation angle around the x-axis of the sketch plane</td>
  </tr>
  <tr>
    <td>\( \phi \)</td>
    <td>[0, 255]</td>
    <td>Rotation angle around the y-axis of the sketch plane</td>
  </tr>
  <tr>
    <td>\( \gamma \)</td>
    <td>[0, 255]</td>
    <td>Rotation angle around the z-axis of the sketch plane</td>
  </tr>
  <tr>
    <td>\( p_x \)</td>
    <td>[0, 255]</td>
    <td>x-coordinate of the sketch plane origin</td>
  </tr>
  <tr>
    <td>\( p_y \)</td>
    <td>[0, 255]</td>
    <td>y-coordinate of the sketch plane origin</td>
  </tr>
  <tr>
    <td>\( p_z \)</td>
    <td>[0, 255]</td>
    <td>z-coordinate of the sketch plane origin</td>
  </tr>
  <tr>
    <td>s</td>
    <td>[0, 255]</td>
    <td>Scaling factor for the sketch contour</td>
  </tr>
  <tr>
    <td>e_1</td>
    <td>[0, 255]</td>
    <td>Positive direction extrusion distance</td>
  </tr>
  <tr>
    <td>e_2</td>
    <td>[0, 255]</td>
    <td>Negative direction extrusion distance</td>
  </tr>
  <tr>
    <td>b</td>
    <td>\{7, 8, 9, 10\}</td>
    <td>Boolean operation type:<br>7: NewBodyFeatureOperation<br>8: JoinFeatureOperation<br>9: CutFeatureOperation<br>10: IntersectFeatureOperation</td>
  </tr>
  <tr>
    <td>u</td>
    <td>\{1, 2, 3\}</td>
    <td>Extrusion type:<br>1: OneSideFeatureExtentType<br>2: SymmetricFeatureExtentType<br>3: TwoSidesFeatureExtentType</td>
  </tr>
  <tr>
    <td>&lt;EOS&gt;</td>
    <td>\( \emptyset \)</td>
    <td>-</td>
    <td>Sequence End Marker</td>
  </tr>
</table>

Table 4: CAD Command Sequence (CCS) Parameters.
The sequence begins with creating two concentric circles to define the initial 2D closed curve. The first circle is centered at coordinates (176, 128) with a radius of 47, and the second circle, also centered at the same point, has a smaller radius of 40. This closed curve is then extruded with the extrusion parameters \( \theta=128, \varphi=128, \) and \( \gamma=128 \), indicating the orientation of the sketch plane. The sketch plane’s origin is set at (70, 128, 128), and a scale factor of 115 is applied to adjust the profile size. The extrusion distances are set to e1=142 and e2=128, specifying how far the shape extends in the extrusion direction. The operation type for the extrusion is "NewBodyFeatureOperation," meaning a new body is created as a result. The extrusion direction is one-sided, indicated by the Parameter u=OneSideFeatureExtentType, ensuring the shape is extruded in one direction.

Next, a new 2D closed curve is created with a combination of lines and arcs. Starting from the point (140, 128), a line is drawn to (195, 128), followed by an arc that sweeps counter-clockwise from (195, 128) to (195, 223) with a sweep angle \( \alpha=128 \). A series of lines are then drawn to complete the curve, and two circles are added at the coordinates (128, 140) and (128, 211), each with a radius of 6. These circles are also extruded using the parameters \( \theta=128, \varphi=128, \) and \( \gamma=128 \), with the origin set at (46, 70, 128) and a scale factor of 115. The extrusion distances are e1=142 and e2=128, with a "JoinFeatureOperation" applied to merge this new feature with the existing body. The extrusion is performed in a one-sided direction, ensuring the shape extends only in one direction...

The modeling process begins with the creation of two circles, both centered at (176, 128) with a radius of 48. The first circle is extruded into a 3D feature with an extrusion direction defined by the parameters \( \theta=128, \varphi=128, \) and \( \gamma=128 \), and the origin placed at (56, 170, 128). The extrusion uses a scale factor of 12 and extends by 176 units in the first phase and 128 units in the second, creating a new body i, extendingion. The second circle is then extruded using similar parameters, but the origin shifts to (188, 86, 128), and a "JoinFeatureOperation" is applied to merge the extrusion with the existing feature.

Next, a more complex 2D closed curve is created using arcs and lines. The curve is defined with specific arc directions and sweep angles, forming a polygon that closes at the starting point. A circle with a radius of 4 is defined at (132, 128) and extruded using the same extrusion parameters, extending the shape into 3D...

<table>
  <tr>
    <th>Original CCS</th>
    <th>Generated Parameter Description</th>
    <th>LCS<sub>ratio</sub></th>
  </tr>
  <tr>
    <td>&lt;SOL&gt;<br>&lt;Arc&gt; x=144, y=112, α=64, f=1<br>&lt;Line&gt; x=207, y=112<br>&lt;Arc&gt; x=223, y=128, α=64, f=1<br>&lt;Line&gt; x=207, y=204<br>&lt;Arc&gt; x=207, y=220, α=64, f=1<br>&lt;Line&gt; x=144, y=220<br>&lt;Arc&gt; x=128, y=204, α=64, f=1<br>&lt;Line&gt; x=128, y=128<br>&lt;SOL&gt;<br>&lt;Arc&gt; x=144, y=114, α=64, f=1<br>&lt;Line&gt; x=207, y=114<br>&lt;Arc&gt; x=223, y=128, α=64, f=1<br>&lt;Line&gt; x=220, y=190<br>&lt;Arc&gt; x=207, y=204, α=64, f=1<br>&lt;Line&gt; x=144, y=204<br>&lt;Arc&gt; x=128, y=204, α=64, f=1<br>&lt;Line&gt; x=131, y=128<br>&lt;Extrude&gt; θ=192, φ=64, γ=192, px=105, py=121, pz=40, s=46, e1=148, e2=128, b=NewBodyFeatureOperation, u=OneSideFeatureExtentType</td>
    <td>First, draw an arc with an end-point at x=144, y=112, a sweep angle of 64 degrees, and a counter-clockwise direction. Then, draw a line to x=207, y=112, followed by an arc to x=223, y=128 with a sweep angle of 64 degrees and a counter-clockwise direction. Next, draw a line to x=223, y=204, an arc to x=207, y=220 with a sweep angle of 64 degrees and a counter-clockwise direction, a line to x=144, y=220, an arc to x=128, y=204 with a sweep angle of 64 degrees and a counter-clockwise direction. Finally, draw a line to x=128, y=128.<br>Repeat the same sequence starting with an arc with an end-point at x=144, y=114, a sweep angle of 64 degrees, and a counter-clockwise direction. Then, extrude the 2D sketch by 148 units in the direction specified by θ=192, φ=64, γ=192, originating at px=105, py=121, pz=40, and extruding the profile by a factor of 46. The extrusion will extend for a distance of 128 units in the direction given by u=OneSideFeatureExtentType and will be treated as a NewBodyFeatureOperation.</td>
    <td>0.675</td>
  </tr>
</table>

Table 5: Examples of parameter description generation.

<table>
  <tr>
    <th>ID</th>
    <th>Generated Parameter Description</th>
    <th>LCS<sub>ratio</sub></th>
    <th>Model Visualization</th>
  </tr>
  <tr>
    <td>00159955</td>
    <td>The sequence begins with creating two concentric circles to define the initial 2D closed curve. The first circle is centered at coordinates (176, 128) with a radius of 47, and the second circle, also centered at the same point, has a smaller radius of 40. This closed curve is then extruded with the extrusion parameters \( \theta=128, \varphi=128, \) and \( \gamma=128 \), indicating the orientation of the sketch plane. The sketch plane’s origin is set at (70, 128, 128), and a scale factor of 115 is applied to adjust the profile size. The extrusion distances are set to e1=142 and e2=128, specifying how far the shape extends in the extrusion direction. The operation type for the extrusion is "NewBodyFeatureOperation," meaning a new body is created as a result. The extrusion direction is one-sided, indicated by the Parameter u=OneSideFeatureExtentType, ensuring the shape is extruded in one direction.<br><br>Next, a new 2D closed curve is created with a combination of lines and arcs. Starting from the point (140, 128), a line is drawn to (195, 128), followed by an arc that sweeps counter-clockwise from (195, 128) to (195, 223) with a sweep angle \( \alpha=128 \). A series of lines are then drawn to complete the curve, and two circles are added at the coordinates (128, 140) and (128, 211), each with a radius of 6. These circles are also extruded using the parameters \( \theta=128, \varphi=128, \) and \( \gamma=128 \), with the origin set at (46, 70, 128) and a scale factor of 115. The extrusion distances are e1=142 and e2=128, with a "JoinFeatureOperation" applied to merge this new feature with the existing body. The extrusion is performed in a one-sided direction, ensuring the shape extends only in one direction...</td>
    <td>0.99</td>
    <td></td>
  </tr>
  <tr>
    <td>00262583</td>
    <td>The modeling process begins with the creation of two circles, both centered at (176, 128) with a radius of 48. The first circle is extruded into a 3D feature with an extrusion direction defined by the parameters \( \theta=128, \varphi=128, \) and \( \gamma=128 \), and the origin placed at (56, 170, 128). The extrusion uses a scale factor of 12 and extends by 176 units in the first phase and 128 units in the second, creating a new body i, extendingion. The second circle is then extruded using similar parameters, but the origin shifts to (188, 86, 128), and a "JoinFeatureOperation" is applied to merge the extrusion with the existing feature.<br><br>Next, a more complex 2D closed curve is created using arcs and lines. The curve is defined with specific arc directions and sweep angles, forming a polygon that closes at the starting point. A circle with a radius of 4 is defined at (132, 128) and extruded using the same extrusion parameters, extending the shape into 3D...</td>
    <td>0.74</td>
    <td></td>
  </tr>
</table>

Table 6: The original CCS and the first generated descriptions.
<table>
  <tr>
    <th>Round</th>
    <th>Reflection Output</th>
    <th>Optimization Output</th>
    <th>LCS<sub>ratio</sub></th>
  </tr>
  <tr>
    <td>1</td>
    <td><b>Generated vs. Real CCS Differences:</b><br>1. Arc End Points: Generated CCS ends at \( x = 223, y = 130 \); real CCS at \( x = 220, y = 128 \).<br>2. Line End Points: Generated CCS ends at \( x = 207, y = 114 \); real CCS at \( x = 207, y = 112 \).<br>3. Extra Commands: Real CCS includes a line to \( x = 220, y = 190 \); generated CCS specifies \( x = 223, y = 204 \).<br>4. Arc Orientation: Generated CCS ends an arc at \( x = 207, y = 222 \); real CCS at \( x = 207, y = 204 \).<br>5. Missing Variables: Generated CCS omits \( e_2 \) (128 in real CCS).<br><br><b>Problems in Parametric Description:</b><br>1. Ambiguous Arcs: Incomplete parameters cause endpoint inconsistencies.<br>2. Unclear Pathing: Lacks instructions for connecting arcs and lines or closing loops.<br>3. Rotational Inconsistencies: Arc rotation directions are unclear.<br>4. Missing Line Dimensions: No explicit dimensions for connecting lines.<br>5. Undefined Parameters: \( e_2 \) is missing from the description.<br><br><b>Improvement Suggestions:</b><br>1. Define arcs explicitly with endpoints, radii, and centers.<br>2. Clarify pathing, including connection rules and loop closures.<br>3. Specify arc rotation directions clearly.<br>4. Specify line dimensions clearly.<br>5. Define all variables, including \( e_2 \).<br>6. Add visual references to support the description.</td>
    <td>First, draw an arc with an end-point at \( x = 144, y = 112 \), a sweep angle of 64 degrees, and a counter-clockwise direction. Then, draw a line to \( x = 207, y = 112 \), followed by an arc to \( x = 220, y = 128 \) with a sweep angle of 64 degrees and a counter-clockwise direction. Next, draw a line to \( x = 220, y = 190 \), an arc to \( x = 207, y = 204 \) with a sweep angle of 64 degrees and a counter-clockwise direction, a line to \( x = 144, y = 204 \), and an arc to \( x = 131, y = 190 \) with a sweep angle of 64 degrees and a counter-clockwise direction. Finally, draw a line to \( x = 131, y = 128 \).<br>Repeat the same sequence starting with an arc with an end-point at \( x = 144, y = 114 \), a sweep angle of 64 degrees, and a counter-clockwise direction. Then, draw a line to \( x = 207, y = 114 \), followed by an arc to \( x = 220, y = 128 \) with a sweep angle of 64 degrees and a counter-clockwise direction. Next, draw a line to \( x = 220, y = 190 \), an arc to \( x = 207, y = 204 \) with a sweep angle of 64 degrees and a counter-clockwise direction, a line to \( x = 144, y = 204 \), and an arc to \( x = 131, y = 190 \) with a sweep angle of 64 degrees and a counter-clockwise direction. Finally, draw a line to \( x = 131, y = 128 \).<br>Then, extrude the 2D sketch by 148 units in the direction specified by \( \theta = 192, \phi = 64, \gamma = 192 \), originating at \( px = 105, py = 121, pz = 40 \), and scaling the profile by a factor of 46. The extrusion will extend for a distance of 128 units in the direction given by u=OneSideFeatureExtentType and will be treated as a NewBodyFeatureOperation.</td>
    <td>0.737</td>
  </tr>
  <tr>
    <td>2</td>
    <td><b>Generated vs. Real CCS Differences:</b><br>1. Arc Direction: Generated CCS uses \( f = -1 \) (clockwise), real CCS uses \( f = 1 \) (counter-clockwise).<br>2. Arc Endpoint Discrepancy: Generated CCS ends at \( x = 220, y = 128 \), real CCS at \( x = 223, y = 128 \).<br>3. Line Mismatch: Generated CCS connects to \( x = 220, y = 190 \), real CCS to \( x = 223, y = 204 \).<br>4. Arc Endpoint Discrepancy: Later arcs end at \( x = 207, y = 220 \), instead of \( x = 207, y = 204 \).<br>5. Fewer Commands: Generated CCS omits lines and arcs.<br>6. Extrusion Parameters: Generated CCS uses \( e_1 = 0 \) and omits \( e_2 \); real CCS uses \( e_1 = 148 \) and \( e_2 = 128 \).<br><br><b>Problems in CAD Parametric Description:</b><br>1. Unclear Arc Directions: \( f \) not explicitly defined.<br>2. Ambiguous Arc Coordinates: Lack of precise endpoint relationships.<br>3. Endpoint Proximity Issues: Close arc endpoints cause confusion.<br>4. Incomplete Extrusion Definitions: \( e_1 \) and \( e_2 \) inadequately described.<br><br><b>Suggestions for Improvement:</b><br>1. Define arc directions explicitly.<br>2. Derive arc endpoints explicitly from previous commands.<br>3. Implement validation checks for consistency.<br>4. Provide clear extrusion parameter definitions.<br>5. Ensure sequential coherence in parametric commands.</td>
    <td>First, draw an arc with an end-point at \( x = 144, y = 112 \), a sweep angle of 64 degrees, and a counter-clockwise direction (\( f = 1 \)). Then, draw a line to \( x = 207, y = 112 \). Next, draw an arc to \( x = 220, y = 128 \) with a sweep angle of 64 degrees and a counter-clockwise direction (\( f = 1 \)). Draw a line to \( x = 223, y = 204 \). Then, draw an arc to \( x = 207, y = 220 \) with a sweep angle of 64 degrees and a counter-clockwise direction (\( f = 1 \)). After that, draw a line to \( x = 144, y = 220 \). Then, draw an arc to \( x = 131, y = 204 \) with a sweep angle of 64 degrees and a counter-clockwise direction (\( f = 1 \)). Finally, draw a line to \( x = 128, y = 128 \).<br>Repeat the same sequence starting with an arc with an end-point at \( x = 144, y = 114 \), a sweep angle of 64 degrees, and a counter-clockwise direction (\( f = 1 \)). Then, draw a line to \( x = 207, y = 114 \). Next, draw an arc to \( x = 220, y = 128 \) with a sweep angle of 64 degrees and a counter-clockwise direction (\( f = 1 \)). After that, draw a line to \( x = 220, y = 190 \). Then, draw an arc to \( x = 207, y = 204 \) with a sweep angle of 64 degrees and a counter-clockwise direction (\( f = 1 \)). Draw a line to \( x = 144, y = 204 \). Next, draw an arc to \( x = 131, y = 190 \) with a sweep angle of 64 degrees and a counter-clockwise direction (\( f = 1 \)). Finally, draw a line to \( x = 131, y = 128 \).<br>Then, extrude the 2D sketch by 148 units in the direction specified by \( \theta = 192, \phi = 64, \gamma = 192 \), originating at \( px = 105, py = 121, pz = 40 \), and scaling the profile by a factor of 46. The extrusion will extend for a distance of 128 units in the direction given by u=OneSideFeatureExtentType and will be treated as a NewBodyFeatureOperation with parameters \( e_1 = 148 \) and \( e_2 = 128 \).</td>
    <td>1.000</td>
  </tr>
</table>

Table 7: Multiple-round Reflection and Optimization Results for CCS Generation.
<table>
  <tr>
    <th>Model Visualization</th>
    <th>Point Cloud Description</th>
    <th>Multi-View Description</th>
    <th>L.LM Determination</th>
    <th>Comprehensive Description</th>
  </tr>
  <tr>
    <td rowspan="2">
      <img src="page_186_120_143_143.png" alt="Model visualization 1"></td>
    <td>The point cloud represents a 3D model of an engine, exhibiting intricate details. It includes components such as cylinders, connectors, and automotive parts, though the specific engine type is not identified. The model is likely intended for educational or demonstration purposes in mechanics or engineering.</td>
    <td>The object is cube-shaped with a ladder on its top surface. It consists of a large cube, four smaller L-shaped protrusions on one side, and a ladder structure. The geometric form is simple, with clearly defined edges and shapes, which could be a building block or part of a larger assembly.</td>
    <td>FALSE (Manually Annotated)</td>
    <td>This 3D object has a cubic form with a ladder attached to its upper surface. It consists of a main cube, four smaller L-shaped protrusions, and a ladder-like structure.</td>
  </tr>
  <tr>
    <td>The 3D point cloud represents a square box with a closed and smooth surface, suggesting it could be a container or storage object. Its shape implies various uses, such as storing small items or being a building block. The lack of overall context makes its practical use unclear, but it may be intended for architectural modeling, digital art, or advanced mathematical modeling.</td>
    <td>The 3D model appears as a cube with a cylindrical protrusion on one side, featuring a curved top and a flat bottom. The model has a cube base, a cylindrical body, and a curved top. The smooth surface and tapering cylindrical body suggest the model could serve as a container or vessel.</td>
    <td>TRUE (Large Model Annotation)</td>
    <td>The 3D model has a square box (cube) as the base. One side of the cube has a cylindrical protrusion with a curved top and flat bottom. The cylindrical body tapers subtly towards the curved top.</td>
  </tr>
</table>

Table 8: Point Cloud and Multi-View Descriptions with Model Determinations and Comprehensive Analysis.

<table>
  <tr>
    <th rowspan="2">Models</th>
    <th colspan="5">Generated Results</th>
  </tr>
  <tr>
    <th>00001213</th>
    <th>00004252</th>
    <th>00005341</th>
    <th>00012350</th>
    <th>00016271</th>
  </tr>
  <tr>
    <td>DeepCAD</td>
    <td><img src="page_186_670_143_143.png" alt="DeepCAD result 1"></td>
    <td><img src="page_339_670_143_143.png" alt="DeepCAD result 2"></td>
    <td><img src="page_492_670_143_143.png" alt="DeepCAD result 3"></td>
    <td><img src="page_645_670_143_143.png" alt="DeepCAD result 4"></td>
    <td><img src="page_798_670_143_143.png" alt="DeepCAD result 5"></td>
  </tr>
  <tr>
    <td>Text2CAD</td>
    <td><img src="page_186_813_143_143.png" alt="Text2CAD result 1"></td>
    <td><img src="page_339_813_143_143.png" alt="Text2CAD result 2"></td>
    <td><img src="page_492_813_143_143.png" alt="Text2CAD result 3"></td>
    <td><img src="page_645_813_143_143.png" alt="Text2CAD result 4"></td>
    <td><img src="page_798_813_143_143.png" alt="Text2CAD result 5"></td>
  </tr>
  <tr>
    <td>TCADGen+CADLLM</td>
    <td><img src="page_186_956_143_143.png" alt="TCADGen+CADLLM result 1"></td>
    <td><img src="page_339_956_143_143.png" alt="TCADGen+CADLLM result 2"></td>
    <td><img src="page_492_956_143_143.png" alt="TCADGen+CADLLM result 3"></td>
    <td><img src="page_645_956_143_143.png" alt="TCADGen+CADLLM result 4"></td>
    <td><img src="page_798_956_143_143.png" alt="TCADGen+CADLLM result 5"></td>
  </tr>
  <tr>
    <td>Ground Truth</td>
    <td><img src="page_186_1100_143_143.png" alt="Ground Truth result 1"></td>
    <td><img src="page_339_1100_143_143.png" alt="Ground Truth result 2"></td>
    <td><img src="page_492_1100_143_143.png" alt="Ground Truth result 3"></td>
    <td><img src="page_645_1100_143_143.png" alt="Ground Truth result 4"></td>
    <td><img src="page_798_1100_143_143.png" alt="Ground Truth result 5"></td>
  </tr>
</table>

Table 9: CAD model effects generated by different methods.

<table>
  <tr>
    <th rowspan="2">Data Size</th>
    <th colspan="3">Command Prediction</th>
    <th colspan="5">Command-Type Performance</th>
    <th colspan="2">CCS</th>
  </tr>
  <tr>
    <th>ACC</th>
    <th>F1</th>
    <th>AUC</th>
    <th>ACC</th>
    <th>Line</th>
    <th>Arc</th>
    <th>Circle</th>
    <th>Extrude</th>
    <th>Accuracy</th>
    <th>Avg LCS<sub>ratio</sub></th>
  </tr>
  <tr>
    <td>0</td>
    <td>0.532</td>
    <td>0.769</td>
    <td>0.851</td>
    <td>0.566</td>
    <td>0.939</td>
    <td>0.564</td>
    <td>0.756</td>
    <td>0.675</td>
    <td>0.160</td>
    <td>0.622</td>
  </tr>
  <tr>
    <td>100</td>
    <td>0.849</td>
    <td>0.818</td>
    <td>0.871</td>
    <td>0.924</td>
    <td>0.928</td>
    <td>0.678</td>
    <td>0.814</td>
    <td>0.788</td>
    <td>0.567</td>
    <td>0.912</td>
  </tr>
  <tr>
    <td>500</td>
    <td>0.932</td>
    <td>0.907</td>
    <td>0.934</td>
    <td>0.970</td>
    <td>0.931</td>
    <td>0.855</td>
    <td>0.907</td>
    <td>0.900</td>
    <td>0.789</td>
    <td>0.972</td>
  </tr>
  <tr>
    <td>1000</td>
    <td><b>0.966</b></td>
    <td><b>0.947</b></td>
    <td><b>0.962</b></td>
    <td><b>0.983</b></td>
    <td><b>0.979</b></td>
    <td><b>0.924</b></td>
    <td><b>0.960</b></td>
    <td><b>0.946</b></td>
    <td><b>0.864</b></td>
    <td><b>0.983</b></td>
  </tr>
</table>

Table 10: Performance analysis across different training data sizes.
<table>
  <tr>
    <th>Forward Generation Models</th>
    <th>Similarity</th>
    <th>GPT-4o-mini</th>
    <th>Gemini-1.5-Flash</th>
    <th>Google_Gemma-2-27b-it</th>
    <th>Google_Gemma-2-9B-it</th>
    <th>Meta-Llama-3.1-70B</th>
    <th>Meta-Llama-3.1-405B</th>
    <th>Qwen2.5-72B</th>
  </tr>
  <tr>
    <td>claude-3.5-haiku-20241022</td>
    <td>1</td>
    <td>0.24</td>
    <td>0.16</td>
    <td>0.36</td>
    <td>0.08</td>
    <td>0.24</td>
    <td>0.24</td>
    <td>0.24</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.44</td>
    <td>0.36</td>
    <td>0.52</td>
    <td>0.36</td>
    <td>0.52</td>
    <td>0.56</td>
    <td>0.52</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.68</td>
    <td>0.44</td>
    <td>0.56</td>
    <td>0.44</td>
    <td>0.64</td>
    <td>0.76</td>
    <td>0.68</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.905</td>
    <td>0.866</td>
    <td>0.932</td>
    <td>0.829</td>
    <td>0.927</td>
    <td>0.938</td>
    <td>0.929</td>
  </tr>
  <tr>
    <td>claude-3.5-sonnet-20241022</td>
    <td>1</td>
    <td>0.24</td>
    <td>0.24</td>
    <td>0.32</td>
    <td>0.12</td>
    <td>0.32</td>
    <td>0.24</td>
    <td>0.24</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.52</td>
    <td>0.76</td>
    <td>0.84</td>
    <td>0.48</td>
    <td>0.68</td>
    <td>0.80</td>
    <td>0.80</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.76</td>
    <td>0.84</td>
    <td>0.88</td>
    <td>0.80</td>
    <td>0.80</td>
    <td>0.84</td>
    <td>0.88</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.896</td>
    <td>0.939</td>
    <td>0.942</td>
    <td>0.841</td>
    <td>0.937</td>
    <td>0.932</td>
    <td>0.943</td>
  </tr>
  <tr>
    <td>ERNIE-4.0-8K-Latest</td>
    <td>1</td>
    <td>0.385</td>
    <td>0.346</td>
    <td>0.346</td>
    <td>0.038</td>
    <td>0.346</td>
    <td>0.385</td>
    <td>0.346</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.577</td>
    <td>0.615</td>
    <td>0.538</td>
    <td>0.346</td>
    <td>0.577</td>
    <td>0.615</td>
    <td>0.615</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.866</td>
    <td>0.866</td>
    <td>0.731</td>
    <td>0.346</td>
    <td>0.866</td>
    <td>0.866</td>
    <td>0.866</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.9</td>
    <td>0.918</td>
    <td>0.915</td>
    <td>0.877</td>
    <td>0.929</td>
    <td>0.935</td>
    <td>0.933</td>
  </tr>
  <tr>
    <td>ERNIE-Speed-8K</td>
    <td>1</td>
    <td>0.141</td>
    <td>0.141</td>
    <td>0.051</td>
    <td>0.0</td>
    <td>0.141</td>
    <td>0.15</td>
    <td>0.141</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.224</td>
    <td>0.229</td>
    <td>0.103</td>
    <td>0.206</td>
    <td>0.235</td>
    <td>0.245</td>
    <td>0.235</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.415</td>
    <td>0.424</td>
    <td>0.462</td>
    <td>0.412</td>
    <td>0.412</td>
    <td>0.449</td>
    <td>0.418</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.661</td>
    <td>0.669</td>
    <td>0.672</td>
    <td>0.632</td>
    <td>0.67</td>
    <td>0.684</td>
    <td>0.669</td>
  </tr>
  <tr>
    <td>gemini-1.5-flash</td>
    <td>1</td>
    <td>0.373</td>
    <td>0.363</td>
    <td>0.41</td>
    <td>0.13</td>
    <td>0.397</td>
    <td>0.404</td>
    <td>0.417</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.573</td>
    <td>0.633</td>
    <td>0.517</td>
    <td>0.533</td>
    <td>0.627</td>
    <td>0.686</td>
    <td>0.65</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.817</td>
    <td>0.807</td>
    <td>0.883</td>
    <td>0.763</td>
    <td>0.843</td>
    <td>0.839</td>
    <td>0.853</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.929</td>
    <td>0.937</td>
    <td>0.935</td>
    <td>0.905</td>
    <td>0.939</td>
    <td>0.945</td>
    <td>0.944</td>
  </tr>
  <tr>
    <td>gemini-1.5-pro</td>
    <td>1</td>
    <td>0.333</td>
    <td>0.45</td>
    <td>0.487</td>
    <td>0.067</td>
    <td>0.453</td>
    <td>0.429</td>
    <td>0.4</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.546</td>
    <td>0.783</td>
    <td>0.381</td>
    <td>0.471</td>
    <td>0.711</td>
    <td>0.687</td>
    <td>0.687</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.867</td>
    <td>0.883</td>
    <td>0.947</td>
    <td>0.829</td>
    <td>0.887</td>
    <td>0.87</td>
    <td>0.92</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.942</td>
    <td>0.956</td>
    <td>0.973</td>
    <td>0.928</td>
    <td>0.955</td>
    <td>0.953</td>
    <td>0.964</td>
  </tr>
  <tr>
    <td>gemma-2-27b-it</td>
    <td>1</td>
    <td>0.217</td>
    <td>0.19</td>
    <td>0.253</td>
    <td>0.027</td>
    <td>0.27</td>
    <td>0.282</td>
    <td>0.2</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.463</td>
    <td>0.463</td>
    <td>0.587</td>
    <td>0.485</td>
    <td>0.533</td>
    <td>0.543</td>
    <td>0.45</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.787</td>
    <td>0.787</td>
    <td>0.877</td>
    <td>0.78</td>
    <td>0.82</td>
    <td>0.861</td>
    <td>0.823</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.912</td>
    <td>0.923</td>
    <td>0.947</td>
    <td>0.9</td>
    <td>0.929</td>
    <td>0.948</td>
    <td>0.932</td>
  </tr>
  <tr>
    <td>gemma-2-9b-it</td>
    <td>1</td>
    <td>0.397</td>
    <td>0.387</td>
    <td>0.407</td>
    <td>0.053</td>
    <td>0.4</td>
    <td>0.41</td>
    <td>0.415</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.645</td>
    <td>0.667</td>
    <td>0.672</td>
    <td>0.567</td>
    <td>0.607</td>
    <td>0.648</td>
    <td>0.656</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.78</td>
    <td>0.8</td>
    <td>0.797</td>
    <td>0.773</td>
    <td>0.787</td>
    <td>0.793</td>
    <td>0.809</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.902</td>
    <td>0.91</td>
    <td>0.914</td>
    <td>0.898</td>
    <td>0.908</td>
    <td>0.911</td>
    <td>0.909</td>
  </tr>
  <tr>
    <td>gpt-4o</td>
    <td>1</td>
    <td>0.247</td>
    <td>0.241</td>
    <td>0.247</td>
    <td>0.047</td>
    <td>0.247</td>
    <td>0.247</td>
    <td>0.247</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.736</td>
    <td>0.773</td>
    <td>0.773</td>
    <td>0.589</td>
    <td>0.783</td>
    <td>0.795</td>
    <td>0.757</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.87</td>
    <td>0.916</td>
    <td>0.9</td>
    <td>0.86</td>
    <td>0.9</td>
    <td>0.93</td>
    <td>0.899</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.951</td>
    <td>0.964</td>
    <td>0.962</td>
    <td>0.939</td>
    <td>0.963</td>
    <td>0.971</td>
    <td>0.957</td>
  </tr>
  <tr>
    <td>gpt-4o-mini</td>
    <td>1</td>
    <td>0.624</td>
    <td>0.624</td>
    <td>0.624</td>
    <td>0.124</td>
    <td>0.624</td>
    <td>0.624</td>
    <td>0.677</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.677</td>
    <td>0.697</td>
    <td>0.71</td>
    <td>0.667</td>
    <td>0.723</td>
    <td>0.756</td>
    <td>0.707</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.813</td>
    <td>0.837</td>
    <td>0.857</td>
    <td>0.82</td>
    <td>0.867</td>
    <td>0.87</td>
    <td>0.86</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.933</td>
    <td>0.946</td>
    <td>0.949</td>
    <td>0.924</td>
    <td>0.944</td>
    <td>0.944</td>
    <td>0.946</td>
  </tr>
  <tr>
    <td>Llama-3.1-405B-Instruct</td>
    <td>1</td>
    <td>0.52</td>
    <td>0.496</td>
    <td>0.555</td>
    <td>0.066</td>
    <td>0.566</td>
    <td>0.517</td>
    <td>0.565</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.662</td>
    <td>0.766</td>
    <td>0.856</td>
    <td>0.322</td>
    <td>0.827</td>
    <td>0.779</td>
    <td>0.809</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.856</td>
    <td>0.874</td>
    <td>0.939</td>
    <td>0.802</td>
    <td>0.928</td>
    <td>0.858</td>
    <td>0.921</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.913</td>
    <td>0.967</td>
    <td>0.929</td>
    <td>0.921</td>
    <td>0.966</td>
    <td>0.959</td>
    <td>0.971</td>
  </tr>
  <tr>
    <td>Llama-3.1-70B-Instruct</td>
    <td>1</td>
    <td>0.534</td>
    <td>0.605</td>
    <td>0.611</td>
    <td>0.071</td>
    <td>0.639</td>
    <td>0.605</td>
    <td>0.642</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.726</td>
    <td>0.838</td>
    <td>0.841</td>
    <td>0.541</td>
    <td>0.845</td>
    <td>0.855</td>
    <td>0.831</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.943</td>
    <td>0.946</td>
    <td>0.946</td>
    <td>0.912</td>
    <td>0.924</td>
    <td>0.936</td>
    <td>0.936</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.951</td>
    <td>0.979</td>
    <td>0.981</td>
    <td>0.972</td>
    <td>0.969</td>
    <td>0.978</td>
    <td>0.978</td>
  </tr>
  <tr>
    <td>Qwen2.5-72B-Instruct-Turbo</td>
    <td>1</td>
    <td>0.25</td>
    <td>0.31</td>
    <td>0.323</td>
    <td>0.017</td>
    <td>0.363</td>
    <td>0.283</td>
    <td>0.283</td>
  </tr>
  <tr>
    <td></td>
    <td>0.98</td>
    <td>0.45</td>
    <td>0.59</td>
    <td>0.613</td>
    <td>0.33</td>
    <td>0.637</td>
    <td>0.595</td>
    <td>0.573</td>
  </tr>
  <tr>
    <td></td>
    <td>0.9</td>
    <td>0.78</td>
    <td>0.823</td>
    <td>0.817</td>
    <td>0.687</td>
    <td>0.85</td>
    <td>0.848</td>
    <td>0.81</td>
  </tr>
  <tr>
    <td></td>
    <td>Average</td>
    <td>0.822</td>
    <td>0.856</td>
    <td>0.858</td>
    <td>0.847</td>
    <td>0.846</td>
    <td>0.846</td>
    <td>0.835</td>
  </tr>
</table>

Table 11: Proportions of results generated by the forward generation model with LCS_ratio values of 1, 0.98, and 0.9, as well as the average LCS_ratio for the backward validation model, which verifies the generated CCS descriptions.

<table>
  <tr>
    <th>Forward Model</th>
    <th>Best Reverse Model</th>
    <th>Proportion of LCS Greater than 0.9</th>
  </tr>
  <tr>
    <td>gemini-1.5-pro</td>
    <td>gemma-2-27b-it</td>
    <td>0.947</td>
  </tr>
  <tr>
    <td>Llama-3.1-70B-Instruct-Turbo</td>
    <td>gemma-2-27b-it</td>
    <td>0.946</td>
  </tr>
  <tr>
    <td>Llama-3.1-405B-Instruct-Turbo</td>
    <td>gemma-2-27b-it</td>
    <td>0.939</td>
  </tr>
  <tr>
    <td>gpt-4o</td>
    <td>Llama-3.1-405B-Instruct</td>
    <td>0.930</td>
  </tr>
  <tr>
    <td>ERNIE-3.5-8K</td>
    <td>gemini-1.5-flash</td>
    <td>0.906</td>
  </tr>
  <tr>
    <td>gemini-1.5-flash</td>
    <td>gemma-2-27b-it</td>
    <td>0.883</td>
  </tr>
  <tr>
    <td>claude-3.5-sonnet-20241022</td>
    <td>gemma-2-27b-it</td>
    <td>0.880</td>
  </tr>
  <tr>
    <td>gemma-2-27b-it</td>
    <td>gemma-2-27b-it</td>
    <td>0.877</td>
  </tr>
  <tr>
    <td>gpt-4o-mini</td>
    <td>Llama-3.1-405B-Instruct</td>
    <td>0.870</td>
  </tr>
  <tr>
    <td>Qwen2.5-72B-Instruct-Turbo</td>
    <td>Llama-3.1-70B-Instruct</td>
    <td>0.850</td>
  </tr>
  <tr>
    <td>ERNIE-4.0-8K-Latest</td>
    <td>gemini-1.5-flash</td>
    <td>0.846</td>
  </tr>
  <tr>
    <td>claude-3.5-haiku-20241022</td>
    <td>Llama-3.1-70B-Instruct</td>
    <td>0.840</td>
  </tr>
  <tr>
    <td>ERNIE-4.0-Turbo-8K</td>
    <td>gemma-2-27b-it</td>
    <td>0.827</td>
  </tr>
  <tr>
    <td>gemma-2-9b-it</td>
    <td>gemini-1.5-flash</td>
    <td>0.800</td>
  </tr>
  <tr>
    <td>ERNIE-Speed-8K</td>
    <td>gemma-2-27b-it</td>
    <td>0.462</td>
  </tr>
</table>

Table 12: Proportion of LCS Greater than 0.9 for Different Forward and Reverse Models in the Two-Phase Evaluation Framework.
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Multi-view analysis</td>
    <td>You are an experienced CAD engineer tasked with providing natural language descriptions of design objects based on images. Your goal is to create clear, specific descriptions for junior designers to understand and model, focusing on shape features, structural elements, and spatial relationships.<br>You will be given an image. Your task is to analyze this description and generate four concise sentences that describe:

1. What the 3D model looks like

2. What it is composed of

3. Its appearance

4. What it can do or its purpose

Follow these guidelines when generating your description:

• Focus on the most important and distinctive features of the object

• Use clear and specific language to describe shapes, structures, and spatial relationships

• Avoid using phrases like “this multi-view image shows” or “distinct views” or explaining the image itself

• Do not include any explanations or additional commentary

• Do not describe the color, metallic sheen, or use words like “blue”, “shadow”, “transparent”, “metal”, “plastic”, “image”, “black”, “grey”, “CAD model”, “abstract”, “orange”, “purple”, “golden”, “smooth”, or “green”

Present your four sentences in the following format:

• Sentence describing what the 3D model looks like

• Sentence describing what it is composed of

• Sentence describing its appearance

• Sentence describing what it can do or its purpose

Ensure that each sentence is concise, clear, and adheres to the abovementioned guidelines.</td>
  </tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Point cloud analysis</td>
    <td>You will be analyzing a 3D point cloud to describe its geometric structure. Your task is to generate four precise sentences, each focusing on a different aspect of the object represented by the point cloud:

      1. Overall Shape

      2. Components

      3. Structural Details

      4. Function

    For each aspect, follow these specific guidelines:

    • <b>Overall Shape:</b> Describe the basic geometric form and approximate dimensions. Focus on the general shape and proportions.

    • <b>Components:</b> List the main structural elements and their spatial relationships. Identify distinct parts and how they connect or relate to each other.

    • <b>Structural Details:</b> Describe key geometric features, patterns, and surface characteristics. Focus on form rather than color or texture.

    • <b>Function:</b> State the most likely practical purpose based purely on the form and structure. Make an educated guess about the object’s intended use.

    Important guidelines:

    • Be specific and detailed in your descriptions.

    • Avoid any mention of colors, materials, or textures that cannot be definitively determined from point cloud data alone.

    • Focus solely on geometry, form, and function.

    • Use precise language and, where appropriate, include approximate measurements or proportions.

    Keep descriptions focused on geometry, form, and function. Avoid any references to color, material, or texture that cannot be definitively determined from point cloud data alone. Write your analysis in four separate sentences, one for each aspect. Do not label or number the sentences. Ensure that each sentence flows naturally into the next.</td>
  </tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Appearance description generation and verification</td>
    <td>You are a parameter in analyzing and describing 3D models based on point cloud data and multiple perspective descriptions. Your task is to analyze the compatibility between two descriptions and provide a synthesized description when they share fundamental geometric characteristics.<br>You will be given two input descriptions:

      <ul>
        <li>{POINT_CLOUD_DESCRIPTION}</li>
        <li>{MULTIPLE_PERSPECTIVES_DESCRIPTION}</li>
      </ul>

    Analyze these descriptions according to the following criteria:

    <b>1. Core Analysis Approach:</b>
    <ul>
      <li>Extract basic geometric forms (shapes, volumes, structures)</li>
      <li>Look for ANY potential geometric compatibility</li>
      <li>Focus on finding similarities rather than differences</li>
      <li>Consider different ways of describing the same geometric concept</li>
      <li>Default to finding compatibility unless clearly contradictory</li>
    </ul>

    <b>2. Ignore Non-Essential Elements:</b>
    <ul>
      <li>Color and material properties</li>
      <li>Surface textures and finishes</li>
      <li>Intended purpose or function</li>
      <li>Aesthetic qualities</li>
      <li>Subjective interpretations</li>
    </ul>
  </td>
</tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Parameter description generation</td>
    <td>You are a parameter in CAD command descriptions. Your task is to describe a provided CAD command sequence based on specific requirements. Follow these instructions carefully:
First, familiarize yourself with these key terms and commands:

<ul>
<li><b>(SOL):</b> Denotes the start of a 2D closed curve. All commands prior to the Extrude command belong to this 2D curve.</li>
<li><b>L (Line):</b> x, y—Coordinates of the line’s end-point, defining direction and length in the plane.</li>
<li><b>A (Arc):</b> x, y—Coordinates of the arc’s end-point; \( \alpha \)—Sweep angle, indicating arc curvature; f—Counter-clockwise flag, specifying arc direction.</li>
<li><b>R (Circle):</b> x, y—Center coordinates of the circle; r—Radius, specifying circle size.</li>
<li><b>E (Extrude):</b> \( \theta, \phi, \gamma \)—Orientation of the sketch plane, defining its rotation and direction; px, py, pz—Origin of the sketch plane in 3D space; s—Scale factor, adjusting profile size; e1, e2—Extrude distances; b—Boolean operation type; u—Extrude direction.</li>
</ul>

Now, describe this CAD command sequence following these guidelines:

1. Only output command descriptions—no additional content or explanations.

2. Include each command, its parameters, and reflect the order of execution in your description.

3. Describe how the Extrude command and its parameters transform the 2D curve into a 3D model.

4. For the Extrude command, fully output the parameters b and u without changing them. Parameter b can be “NewBodyFeatureOperation”, “JoinFeatureOperation”, “CutFeatureOperation”, or “IntersectFeatureOperation”. Parameter u can be “OneSideFeatureExtentType”, “SymmetricFeatureExtentType”, or “TwoSides-FThe parameterentType”.

5. Do not change any parameter values in your description.

6. Form a single, cohesive paragraph of CAD modeling guidance. Describe the sequence in natural language, including every parameter without omission.

Here is the CAD command sequence you need to describe:

<ul>
<li>{CAD_COMMAND_SEQUENCE}</li>
</ul>

Your output should be a flowing, descriptive paragraph that guides the reader through the CAD modeling process, detailing each step and parameter in the order they appear in the command sequence. Do not use bullet points or numbered lists. Ensure your description is comprehensive, covering all aspects of the provided sequence.</td>
</tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Parameter description verification</td>
    <td>You are tasked with converting a CAD command description into a precise CAD operation sequence. Follow these instructions carefully:

<b>1. Read the description carefully</b> and identify the CAD operations mentioned. These may include creating lines, arcs, circles, and performing extrude operations.

<b>2. Convert each identified operation into the corresponding CAD command format</b> as follows:
<ul>
<li>To start a new sketch:
  – <SOL>
</li>
<li>For a line:
  – <Line>: x=<xValue>, y=<yValue>
</li>
<li>For an arc:
  – <Arc>: x=<xValue>, y=<yValue>, \( \alpha =<alphaValue> \), f=<fValue>
</li>
<li>For a circle:
  – <Circle>: x=<xValue>, y=<yValue>, r=<radiusValue>
</li>
<li>For an extrude operation:
  – <Extrude>: \( \theta =<thetaValue> \), \( \varphi =<phiValue> \), \( \gamma =<gammaValue> \), px=<pxValue>, py=<pyValue>, pz=<pzValue>, s=<sValue>, e1=<e1Value>, e2=<e2Value>, b=<extrudeOperation>, u=<extentType>
</li>
</ul>

<b>3. Arrange the converted operations in the sequence they appear in the description.</b> Start each new sketch with <SOL>.

4. After converting all operations, end the CAD operation sequence with:
<ul>
<li><EOS></li>
</ul>

5. Ensure that you only output the CAD operation sequence without any additional explanations or comments.

6. If any information is missing or unclear in the description, use reasonable default values or omit the parameter.

7. Remember:
<ul>
<li>There should be only one <SOL> tag per sketch.</li>
<li><EOS> marks the end of the entire CAD operation sequence.</li>
<li>Do not include any text or explanations outside of the specified command formats.</li>
</ul>

8. You will be given a CAD command description in the following format:
<ul>
<li>{CAD_COMMAND_DESCRIPTION}</li>
</ul>

Output the resulting CAD operation sequence exactly as specified, with no additional commentary.</td>
  </tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Reflection on parameter description issues</td>
    <td>You are a CAD parametric description analysis parameter. Your task is to analyze the differences between a generated CAD Command Sequence (CCS) and a real CCS, identify problems in the CAD parametric description, and provide suggestions for improvement.

1. CAD parametric description:

<ul>
<li>{CAD_DESCRIPTION}</li>
</ul>

2. Generated CCS based on the CAD description:

<ul>
<li>{GENERATED_CCS}</li>
</ul>

<b>1. Differences between generated and real CCS:</b>

<ul>
<li>Missing commands in the generated CCS: [List any specific commands present in the real CCS but missing in the generated one.]</li>
<li>Extra commands in the generated CCS: [List any commands that appear in the generated CCS but are not in the real CCS.]</li>
<li>Differences in command parameters or order: [List and describe any differences in parameters or the order of commands.]</li>
</ul>

<b>2. Problems in the CAD parametric description:</b>

<ul>
<li>Missing information: [Discuss any information that is not clearly stated in the CAD parametric description, which may have led to missing or t commands.]</li>
<li>Incorrect specifications: [Identify any specifications that are inaccurate or potentially lead to errors in the generated CCS.]</li>
<li>inaccurate specifications [Highlight any parts of the CAD description that are ambiguous and could be interpreted in multiple ways.</li>
</ul>

<b>3. Improvement suggestions:</b>

<ul>
<li>Clarify any ambiguous descriptions by providing more specific and detailed parameters.</li>
<li>Ensure that all necessary information for each command is provided to avoid missing commands or incomplete sequences.</li>
<li>Double-check the order of commands in the CAD description to match the expected sequence for correct execution.</li>
<li>Review the parameter specifications to ensure they are accurate and precise, avoiding potential discrepancies.</li>
</ul>
</td>
</tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>Parameter Description Regeneration</td>
    <td>You are a CAD parametric description modification parameter. Your task is to analyze and modify a given CAD parametric description to make it more accurate, complete, and unambiguous based on a real CCS sequence and a provided opinion. Follow these steps:

1. <b>Review the provided CAD parametric description:</b>
   • {CAD_DESCRIPTION}

2. <b>Examine the real CCS sequence:</b>
   • {REAL_CCS}

3. <b>Consider the provided opinion:</b>
   • {OPINION}

4. <b>Familiarize yourself with these key terms and commands in the CCS:</b>
   • <SOL>: Start of a 2D closed curve
   • L (Line): \( x, y \) - Coordinates of the line’s end-point
   • A (Arc): \( x, y \) - Coordinates of the arc’s end-point; \( \alpha \) - Sweep angle; \( f \) - Counter-clockwise flag
   • R (Circle): \( x, y \) - Center coordinates; \( r \) - Radius
   • E (Extrude): \( \theta, \phi, \gamma \) - Orientation of the sketch plane; \( p_x, p_y, p_z \) - Origin of the sketch plane; \( s \) - Scale factor; \( e_1, e_2 \) - Extrude distances; \( b \) - Boolean operation type; \( u \) - Extrude direction

5. <b>Pay special attention to the Extrude command parameters:</b>
   • Parameter \( b \): "NewBodyFeatureOperation", "JoinFeatureOperation", "CutFeatureOperation", or "IntersectFeatureOperation"
   • Parameter \( u \): "OneSideFeatureExtentType", "SymmetricFeatureExtentType", or "TwoSidesFeatureExtentType"

6. <b>Analyze the differences between the CAD description and the real CCS.</b>

7. <b>Based on your analysis, modify the CAD parametric description to address any issues found.</b>

8. <b>Output CAD parametric description ONLY!!!</b></td>
  </tr>
</table>
<table>
  <tr>
    <th>Process Name</th>
    <th>Prompt</th>
  </tr>
  <tr>
    <td>LLMCAD Enhanced CCS</td>
    <td>You are a CAD sequence generation parameter. Your task is to generate a correct CAD Command Sequence (CCS) based on a CAD description, existing CCS, and confidence levels. Follow these instructions carefully:<br>
    Now, consider the following CAD description: {CAD_DESCRIPTION}<br>
    Here is the existing CCS and its associated confidence levels: {EXISTING_CCS} {CONFIDENCE}<br>
    Analyze the confidence levels provided. Pay special attention to parameters with confidence levels below 0.98, as these should be the focus of your modifications. Based on the CAD description and the confidence levels, generate a new CCS. Modify the existing CCS to align with the description, focusing on adjusting parameters with low confidence levels. Ensure that the new CCS accurately represents the described CAD operations.<br>
    Output the new CCS without any explanations or additional comments.</td>
  </tr>
</table>

Reviewer paper summaries: This paper proposes a novel framework for automated CAD modeling, integrating a semi-automated data generation pipeline and a CAD command sequence generation model based on textual descriptions. The proposed approach aims to streamline industrial design workflows by converting natural language instructions into editable CAD models. Experimental results demonstrate strong performance across various CAD operations.
Summary of strengths: The semi-automated pipeline shows promise in scaling the creation of CAD-text datasets, and its annotation and error correction mechanisms appear useful.

The paper is well-written and structured clearly.

The proposed methods achieve strong performance and outperform all baseline models.
Summary of weaknesses: 1.Baseline comparisons are conducted exclusively on the authors’ new dataset, raising risks of cherry-picking. Validation on established benchmarks (e.g., Text2CAD) would strengthen claims. A discussion on the generalizability of the proposed framework to external datasets would strengthen the paper.

2.The performance gains appear heavily reliant on LLM fine-tuning (CADLLM). The paper does not explore end-to-end training of TCADGen and CADLLM, which might improve coherence and reduce error propagation.
Comments, suggestions and typos: Failure cases (e.g., inconsistent extrude parameters or misaligned sketches) are not discussed, limiting insight into the framework’s practical limitations. The authors should include some examples of failure cases before and after fine-tuning the LLM to highlight its error correction capabilities.
Overall assessment scores: 4
Metareview score: 4
Metareview: This paper presents a new system that uses large language models to automatically generate CAD modeling sequences from natural language descriptions. The framework combines a semi-automated data annotation pipeline, a Transformer-based generator (TCADGen), and a refinement model (CADLLM). Together, they help convert appearance and parameter descriptions into structured CAD commands with improved accuracy and efficiency. The approach is especially focused on the detailed design phase in industrial workflows and shows strong performance on multiple benchmarks.
Summary of reasons to publish: 1. The paper introduces a well-designed and novel framework that blends LLMs, VLLMs, and transformer-based models to automate a traditionally manual and complex task.
2. The dual-channel approach to fusing appearance and parameter descriptions is well-motivated and technically sound.
3. The results show significant improvements over existing CAD modeling methods in terms of command prediction accuracy and sequence reliability.
4. The authors provide detailed evaluation and ablation studies that back up their claims.
5. The annotation pipeline can be highly useful to the community, especially given the difficulty of generating labeled CAD data.