1 Introduction↩︎

Parametric CAD models derive their enduring engineering value from a defining capability: when a designer changes a dimension, modifies a sketch constraint, or appends a later feature, the native CAD system resolves the edit through explicit constraints and updates the model by replaying the construction history [1]–[3]. This parameter editing behavior hinges on the explicit dimensional and geometric constraints that encode design intent, namely the relations that must remain satisfied regardless of dimensional variations [4], [5].

Recent generative CAD research has produced remarkable advances in synthesizing modeling sequences or CAD code from text, point clouds, images, and engineering drawings [6]–[16]. Methods range from autoregressive sequence prediction to structured sequence generation and executable code generation [17]–[19]. However, with few exceptions, these methods target and evaluate static fidelity, including final shape similarity, sequence validity, command accuracy, and parameter accuracy [12], [20]. Explicit sketch constraints, the very mechanism that makes parametric CAD editable, are rarely part of the representation.

This representational gap becomes immediately apparent under even simple parameter adjustments, as illustrated in Figure [fig:histcad-overview]. A generated sequence may reconstruct plausible geometry, execute once, and even accept a parameter change, yet fail catastrophically to preserve required relations after that change. Missing sketch constraints cause profiles to drift, holes to lose concentricity, and edges to lose tangency or parallelism. We term the missing capability parameter editability with constraint preservation: the ability of a CAD sequence to accommodate local parameter changes while preserving the relevant dimensional and geometric constraints [1], [2], [4].

This limitation is deeply embedded in available data and benchmarks. DeepCAD provides large 3D construction sequences but omits explicit sketch constraints [21]. Text2CAD adds language supervision atop a similar format without explicit constraints [9]. SketchGraphs captures rich 2D relational geometry but lacks executable 3D feature sequences [22]. The Fusion 360 Gallery contributes authentic programs authored by designers, yet remains an order of magnitude smaller and largely restricted to sketch and extrude workflows [23]. Existing benchmarks inherit this bias toward static fidelity. The field therefore lacks a common substrate on which parameter editability with constraint preservation can be learned and evaluated at scale.

We introduce HistCAD to address this fundamental gap. HistCAD has three components. First, it provides a representation standard, an executable intermediate language for parametric CAD that is independent of CAD software and explicitly encodes sketch primitives, sketch constraints, feature operations, and boundary references. Second, it offers a dataset at scale, with 170,236 sequences spanning academic and professionally authored industrial models. Third, it defines a Constraint-Aware Editability Benchmark that measures whether generated sequences preserve design intent under parameter edits.

The representation standard separates the logical description of a parametric model from any particular CAD backend. It records sketches as flat sets of atomic geometric primitives, accompanied by explicit geometric and dimensional constraint graphs covering 19 constraint types. This flattening, described in Section 3.2 and proven in Appendix 7, eliminates redundant boundary serialization while preserving exact profile equivalence. Feature operations, including extrude, revolve, helix sweep, fillet, and chamfer, are parameterized without relying on identifiers specific to a kernel. For operations that depend on existing boundaries, HistCAD stores 3D reference points on target edges, allowing the execution backend to recover the corresponding B-Rep entity at runtime. This design avoids topology identifiers tied to a particular software package, learned pointers [24], and separate grounding modules [25], while maintaining full executability across CAD systems.

The dataset construction integrates complementary sources into this unified representation. The academic portion combines DeepCAD’s scale, SketchGraphs’ constraint richness, and the authenticity of Fusion 360 Gallery programs authored by designers. The industrial portion contributes professionally authored standard part models that substantially extend sequence length and operation coverage, as reported in Table 4. All sequences are aligned with native CAD files, STEP exports, rendered views, and text annotations grounded in the sequence.

The Constraint-Aware Editability Benchmark operationalizes the evaluation of design intent preservation. For each benchmark instance, a target dimensional edit that either modifies an existing dimension or adds a new one is specified together with a preservation set of constraints that should remain satisfied. The benchmark reports three metrics: Edit Reachability, or ER, measures whether the edited sequence reaches a valid CAD state; Conditional Preserved Constraint Satisfaction Rate, or cPCSR, measures constraint preservation among reachable cases; and Overall Editable Success, defined as ER \(\times\) cPCSR, gives the strict overall rate.

Our experiments yield four principal findings. First, the representation remains compact: HistCAD with full constraints averages 550.35 tokens on the shared intersection, compared with 590.62 for Text2CAD and 1,974.00 for DeepCAD. Second, native sequence ablation confirms that explicit constraints are not primarily needed to reach a valid state after an edit, but to keep preserved constraints satisfied after that state is reached; closure only sequences achieve 99.50% ER but only 55.53% cPCSR on HistCAD-DeepCAD data, with equal, angle, parallel, length, and perpendicular constraints proving most fragile. Third, supervised CAD generation from text with full HistCAD training achieves the strongest aggregate editability with constraint preservation, reaching 73.33% OES. Fourth, industrial data improves distribution coverage on the industrial test subset to 55.52% COV, compared with 52.21% for the baseline trained only on DeepCAD, but industrial sequences remain the hardest cases for edit and rebuild evaluation, with OES at 64.00%.

The main contributions of this paper are:

• A representation standard that serves as an intermediate language independent of CAD software for executable parametric CAD, explicitly encoding 19 constraint types and boundary references through 3D points.

• The HistCAD dataset, comprising 170,236 executable sequences that unify academic scale, constraint richness, authentic sources from human designers, and industrial complexity.

• A Constraint-Aware Editability Benchmark with three diagnostic metrics, ER, cPCSR, and OES, that distinguish edit reachability from constraint preservation, shifting evaluation from static shape recovery to design intent verification.

• Experimental evidence that explicit constraints are necessary and that industrial data improves generalization, with detailed diagnostic analysis of failure modes.

2 Related Work↩︎

This section reviews prior CAD datasets, representations, generative methods, and metrics through the lens of editable construction history: executable feature sequences, explicit sketch constraints, boundary references, and constraint preservation after parameter edits.

2.1 Parametric CAD Datasets and Representations↩︎

Parametric CAD modeling centers on a paradigm driven by construction history: designers construct 2D constrained sketches and build 3D geometry through sequential feature operations [1], [2]. The resulting construction history, when replayable with its original constraints, is what makes these models editable and reusable. Capturing this history in a form readable by LLMs is the central data challenge for generative CAD.

Existing datasets each capture fragments of this complete picture. DeepCAD [21] provides procedural sequences at scale with sketch and extrude operations but does not preserve explicit sketch constraints. Text2CAD [9] adds textual supervision but retains the same format without explicit constraints. SketchGraphs [22] offers rich 2D constraint annotations on static sketches but lacks the downstream 3D feature parameters needed for execution. The Fusion 360 Gallery [23] releases authentic Fusion designs authored by humans whose native files include sketch dimensions and constraints, while its reconstruction subset contains 8,625 designs expressed through sketch and extrude operations. WHUCAD [26] extends command coverage at large scale, and HPSketch [27] further studies parametric sketches with construction histories and advanced commands. The ABC dataset [28] provides massive B-Rep geometry but without parametric history.

Executable script representations offer another direction. CadQuery provides a parametric CAD API in Python, and recent methods such as CAD-Coder and Text-to-CadQuery target CadQuery scripts as generation outputs [18], [19], [29]. These scripts are executable and convenient for code models, but standard CadQuery targets do not preserve native sketch constraint graphs and remain tied to a specific software API rather than serving as an independent representation.

HistCAD is designed to bridge these fragments. It jointly provides executable 3D feature sequences, explicit sketch constraints, support for operations that reference boundaries, and software independence in one unified representation. Table 1 summarizes this comparison.

5pt

2.2 Generative Modeling for CAD↩︎

Generative CAD methods can first be organized by their conditioning signal and generation task. Autoregressive sequence models such as DeepCAD and SkexGen learn CAD command sequences directly [21], [30]. Variants conditioned on text extend this setting to generation with language supervision [9], while hierarchical and controllable methods, along with methods guided by feedback, introduce additional control over the generation process [14], [16], [31]. Other lines of work infer CAD sequences or programs from sketches, point clouds, images, or engineering drawings [6]–[8], [12], [13], [15], [20], [32]. More recent multimodal systems and systems based on LLMs combine several of these signals for CAD generation guided by text or images [10], [11], [33], [34].

A second axis concerns the output representation and how generated programs refer to existing geometry. CADmium uses compact CAD sequences in JSON rather than scripts at the API level [17]. Pointer-CAD extends generation of command sequences with learned pointers over B-Rep entities [24]. FutureCAD generates executable CadQuery programs whose primitive queries in natural language are resolved by a grounding module [25]. Direct B-Rep generation and B-Rep latent editing methods [35]–[39] instead operate on static boundary representations. HistCAD focuses on editable construction histories with explicit sketch constraints, and embeds boundary references as 3D points within the sequence itself, avoiding both learned pointers and external grounding models.

2.3 Evaluation in Generative CAD↩︎

Evaluation in generative CAD has largely inherited metrics from 3D reconstruction. Chamfer Distance [40], Minimum Matching Distance, Coverage, and Jensen–Shannon Divergence [41] measure shape fidelity and distribution matching. CAD evaluations add sequence validity or success rates, primitive or command accuracy, parameter accuracy, reconstruction distances, and text or visual consistency checks [9], [10], [14], [20], [21]. Together, these metrics test geometric agreement, single execution, or token correspondence, but they do not test whether a sequence preserves required constraints when a user changes a dimension.

Several works move closer to edit settings. SECAD-Net and eCAD-Net study recovery of editable parametric sequences from geometry [42], [43]. CADMorph frames editing as a plan, generate, and verify problem [44]. B-repLer investigates semantic editing in a latent B-Rep space [37]. However, these settings do not benchmark sketch constraint preservation after target parameter edits. HistCAD’s Constraint-Aware Editability Benchmark directly fills this gap with metrics that separate reachability from constraint preservation.

3 HistCAD: A Representation Standard for Parametric CAD↩︎

HistCAD defines an executable, flat representation with explicit constraints for parametric CAD sequences. This section presents the representation standard in Section 3.1, the flattening method in Section 3.2, dataset construction in Section 3.3, execution across CAD environments in Section 3.4, and the annotation module in Section 3.5.

3.1 Constraint-Aware Sequence Representation↩︎

The HistCAD representation standard is an intermediate language for parametric CAD: a serialization independent of CAD software and readable by LLMs that captures the complete editable structure of a model with construction history. It satisfies four design requirements:

• R1: Compactness for token generation. The representation must be concise enough for LLM and agent pipelines with limited context windows.

• R2: Executability in native CAD environments. The representation must be reconstructible as a native parametric model, not merely as static geometry, so that parameter edits and constraint resolution remain defined.

• R3: Explicit encoding of sketch constraints. All dimensional and geometric constraints must be explicitly represented.

• R4: Support for boundary operations. Industrial operations such as fillet and chamfer, which reference existing model edges, must be representable without topology identifiers tied to a CAD system.

3.1.0.1 Sketches and constraints.

A HistCAD sketch consists of a local plane, a set of geometric primitives, and a system of explicit geometric constraints. The sketch plane is parameterized by a translation vector and Euler angles. Geometric primitives are expressed in compact parametric form, covering lines, circles, arcs, ellipses, elliptical arcs, and NURBS curves. The empirical distribution across the full dataset is reported in Table 2. Unlike earlier sequence formats that explicitly serialize loops and sketch profiles, HistCAD stores sketch primitives as an unordered flat set, as shown in Figure 1. As shown in Section 3.2, this flattening removes duplicate boundaries while preserving the profiles consumed by downstream 3D operations.

HistCAD supports 19 constraint types listed in Table 3: coincident connectivity; horizontal, vertical, parallel, perpendicular, concentric, tangent, and normal alignment; length, distance, diameter, radius, angle, minor radius, and major radius specifications; fix and midpoint anchoring; and equal and mirror relations. These constraints are part of the executable representation itself. They define the relation graph that preserves required geometric and dimensional relations when a sequence undergoes local edits.

3.1.0.2 Feature operations.

For 3D modeling, HistCAD represents downstream feature operations in a compact, executable form. Extrusions are defined by direction and extent and consume reconstructed sketch profiles without explicit profile enumeration. Revolves are parameterized by axis position, orientation, and angular range. Helix sweeps are defined by axis, pitch, number of turns, and handedness.

Fillets and chamfers are handled through 3D reference points on target boundaries, and the execution backend recovers the corresponding B-Rep edges from the rebuilt model. This design avoids topology identifiers tied to a CAD system while keeping boundary references inside the executable representation. Boolean operation tags for new body, join, cut, and intersect specify how each feature result updates the current part geometry: creating a new body, adding material to existing geometry, removing material from it, or retaining only the intersection.

3.2 Flat Sketch Representation↩︎

Prior CAD sequence formats explicitly serialize faces, loops, and sketch profiles, which introduces redundant tokens because shared interior boundaries are repeated across neighboring faces. HistCAD replaces this nested sketch encoding with a flat set of atomic primitives. This flattening is exact: it removes redundant syntax while preserving the selected 2D region exactly, so the same sketch profiles remain available to subsequent 3D operations.

During preprocessing, all intersecting curves are decomposed into disjoint atomic subprimitives with shared endpoints. Let \(H = \{f_i\}_{i=1}^n\) denote a hierarchical sketch representation, where each face \(f_i\) is bounded by loops \(\partial f_i = \{L_{ij}\}_{j=1}^{m_i}\), and each loop \(L_{ij}\) is a set of atomic subprimitives. Let \(U = \bigcup_{i=1}^n f_i\) denote the selected sketch region, with geometric boundary \(\mathcal{P}_{\text{hier}} = \partial U\). HistCAD defines the flat boundary representation by taking the symmetric difference over the selected face boundaries: \[\mathcal{P}_{\text{flat}} = \Delta_{i=1}^n \left( \Delta_{L_{ij}\in\partial f_i} L_{ij} \right),\] where \(A \Delta B = (A \setminus B) \cup (B \setminus A)\). Equivalently, a subprimitive \(e\) is retained if and only if it appears on an odd number of selected face boundaries.

3.2.0.1 Boundary equivalence proposition

Assume a planar sketch arrangement in which each atomic subprimitive is incident to at most two faces, and no face boundary traverses the same subprimitive more than once. Then \(\mathcal{P}_{\text{flat}} = \mathcal{P}_{\text{hier}}\), where \(\mathcal{P}_{\text{hier}}=\partial U\) is the geometric boundary of the selected sketch region. The proof is given in Appendix 7.

Intuitively, shared interior boundaries appear twice and cancel under symmetric difference, whereas outer contours and hole boundaries appear once and are retained. Figure 1 illustrates this principle: a three-face sketch with duplicate arc boundaries in hierarchical form collapses to a compact flat set where each boundary primitive appears exactly once.

This flattening provides quantifiable benefits. On the shared 134,896-model intersection studied in Section 5.2, the flat representation achieves an average of 363.99 tokens without constraints and 550.35 with full constraints, which is substantially shorter than DeepCAD’s 1,974.00 and even shorter than Text2CAD’s 590.62. The constraints themselves add approximately 186 tokens on average, a modest overhead for the editability they enable.

3.3 Dataset Construction↩︎

No single existing source jointly provides the scale, explicit constraints, native executability, and industrial operation coverage required for editable CAD generation. HistCAD integrates complementary academic and industrial data into the unified representation standard.

3.3.0.1 HistCAD-Academic

The academic portion combines three sources. DeepCAD [21] provides 153,534 3D feature sequences at scale but lacks explicit sketch constraints. SketchGraphs [22] contributes rich 2D constraint annotations on shared sketch entities. Fusion 360 Gallery [23] contributes human-authored designs whose native files include dimensions and sketch constraints; 8,609 recoverable designs are converted into HistCAD sequences.

To align these sources, we match SketchGraphs entities to DeepCAD subprimitives, decompose intersections into atomic primitives, recover selected sketch boundaries through the symmetric difference construction, merge collinear fragments, transfer available original constraints, add auxiliary constraints when needed for execution, and prune redundant relations. This pipeline yields 153,534 aligned CAD sequences with explicit constraints. Adding 8,609 recovered sketch to extrusion sequences from Fusion 360 Gallery brings HistCAD-Academic to 162,143 executable CAD sequences.

3.3.0.2 HistCAD-Industrial

HistCAD-Industrial adds 8,093 professionally authored industrial standard part models. These models preserve complete native parametric sequences and are parsed into the same HistCAD format. Relative to the academic portion, this subset contributes longer sequences and extends operation coverage beyond sketch and extrude workflows. Specifically, 38.13% of industrial models contain at least one fillet or chamfer operation, 4.18% contain revolve operations, and 1.68% contain helical sweep operations, which are feature types absent from HistCAD-Academic. All industrial models are provided under research release agreements. In total, HistCAD contains 170,236 executable CAD sequences.

3.4 Execution in CAD Environments↩︎

Native executability is essential: if a generated sequence cannot be rebuilt inside a CAD system, later parameter edits and editability evaluation are no longer defined. HistCAD separates the representation from the execution backend. In the current release, execution is provided through adapters for the JiuShao POWER Platform API [45] and the Autodesk Fusion 360 API [46]. A backend reads the sequence in order and maps each step to native CAD operations: creating the sketch coordinate system, instantiating primitives, inserting explicit constraints, and calling feature constructors.

For fillet and chamfer operations, the backend recovers target edges from the rebuilt native B-Rep using the stored 3D reference points, finding the nearest edge within a tolerance threshold. The stored point serves as a selection cue at the geometry level: at execution time, the backend binds the operation to the edge incident to that cue rather than replaying an entity handle tied to a kernel. This design keeps the logical sequence independent of a particular kernel’s transient topology numbering. Adapters to SolidWorks and CATIA are planned.

3.5 Annotation Module for HistCAD↩︎

HistCAD provides text annotations derived from the executable sequences for CAD tasks conditioned on text. These annotations are derived from the parametric sequence rather than from rendered appearance, ensuring consistency with the executable model. Using deterministic geometric analysis, including loop nesting and relation extraction with OBBs, we recover sketch profiles and spatial relations between bodies within each model; details are given in Appendix 8. Given this structured metadata, we use Gemma-4-31B-it to generate three forms of text supervision: modeling process, geometric structure, and functional type. These annotations are auxiliary dataset fields used only in the CAD generation from text experiments described in Section 5.4.

4 Constraint-Aware Editability Benchmark↩︎

Existing CAD generation evaluations measure static shape fidelity or single execution. They do not test the operation that makes a parametric model reusable: changing a parameter after construction while keeping the relevant constraints valid. We introduce the Constraint-Aware Editability Benchmark to directly evaluate this capability.

4.1 Task Formulation↩︎

We formulate parameter editability with constraint preservation as a dynamic editing task. A benchmark instance is a tuple \[I = \langle \mathcal{M}_{src}, c_{\mathrm{target}}, \mathcal{E}, \mathcal{C}_{preserve} \rangle ,\] where \(\mathcal{M}_{src}\) is an executable source CAD sequence, \(c_{\mathrm{target}}\) is the dimensional constraint to be created or modified, \(\mathcal{E}\) specifies the concrete edit value and attachment site, and \(\mathcal{C}_{preserve}\) is the set of constraints that should remain satisfied after the edit. The source sequence defines a feasible edit; the evaluated sequence \(\mathcal{M}_{eval}\) receives the same edit, yielding \(\mathcal{M}_{eval}'\). The benchmark evaluates whether \(\mathcal{M}_{eval}'\) satisfies \(c_{\mathrm{target}}\) and every constraint in \(\mathcal{C}_{preserve}\).

We instantiate this for local dimensional edits. The target constraint \(c_{\mathrm{target}}\) covers length, radius, diameter, angle, and distance constraints. The edit \(\mathcal{E}\) belongs to one of two families: modifying an existing dimensional relation or inserting a new dimensional relation at a feasible attachment site. The preservation set \(\mathcal{C}_{preserve}\) contains the other supported constraints in the affected sketch.

4.2 Benchmark Construction↩︎

Benchmark instances are constructed from executable source sequences with feasible sites for constraint edits, validated to ensure the source remains solvable after the edit. For each accepted edit, the benchmark records the target constraint, edit value, attachment site, and preservation set. The preservation set is fixed by the benchmark instance, so different methods are scored against identical edit requests and identical constraints to preserve.

4.3 Evaluation Metrics↩︎

Let \(\mathcal{D}\) denote the evaluated cases in a benchmark split. Let \(\mathcal{R} \subseteq \mathcal{D}\) be the cases whose edited sequence satisfies \(c_{\mathrm{target}}\), passes sketch validation, and completes downstream rebuild. Among these reachable cases, let \(\mathcal{S} \subseteq \mathcal{R}\) be the cases for which every constraint in \(\mathcal{C}_{preserve}\) remains satisfied.

The benchmark reports three rates: \[\begin{align} \mathrm{ER} &= \frac{|\mathcal{R}|}{|\mathcal{D}|},\\ \mathrm{cPCSR} &= \frac{|\mathcal{S}|}{|\mathcal{R}|},\\ \mathrm{OES} &= \frac{|\mathcal{S}|}{|\mathcal{D}|} = \mathrm{ER} \times \mathrm{cPCSR}. \end{align}\]

Edit Reachability, or ER, measures whether the evaluated sequence reaches a valid CAD state after the edit. Conditional Preserved Constraint Satisfaction Rate, or cPCSR, measures constraint preservation among the reachable cases. Overall Editable Success, or OES, is the strict overall rate, requiring both edit reachability and preservation of all constraints in \(\mathcal{C}_{preserve}\).

Together, these metrics distinguish failures to reach a valid state from failures to preserve constraints within reachable states. Figure 2 illustrates the protocol and case partition.

5 Experiments and Evaluation↩︎

The experiments proceed in four parts. We first compare the compactness of DeepCAD, Text2CAD, and HistCAD representations. We then use native sequence ablations to examine how explicit constraints affect reachability and constraint preservation after edits. Next, we evaluate HistCAD as a target for CAD generation from text under different supervision settings. Finally, we measure how industrial data changes static generation quality, constraint prediction, and editability.

5.1 Evaluation Metrics↩︎

Unless otherwise stated, token statistics use the Gemma-4-31B-it tokenizer. For shape metrics, we report MCD for Median Chamfer Distance multiplied by \(10^{3}\), MMD for Minimum Matching Distance multiplied by \(10^{3}\), COV as Coverage in percent, and JSD for Jensen–Shannon Divergence multiplied by 100, following prior CAD work [10], [21], [41]. Each reference and predicted STL is sampled into 10,000 points, centered, and normalized by the maximum extent of its bounding box. MCD is computed on examples shared by all evaluated generators with available reference meshes. For the larger HistCAD-DeepCAD test subset, MMD, COV, and JSD are computed in three evaluations, each using 1,000 examples, and averaged. HistCAD-Fusion360 and HistCAD-Industrial are evaluated on all available examples with reference meshes.

For the overall text-to-CAD summaries, we compute each reported metric separately on HistCAD-DeepCAD, HistCAD-Fusion360, and HistCAD-Industrial, and report the uniform average of the three subset-level scores. For MCD, we first compute the median Chamfer Distance within each subset and then apply this subset-level averaging. Constraint F1 is computed from precision and recall over predicted constraint records; a true positive requires matching constraint type, referenced entities, and value or semantic metadata. ER, cPCSR, and OES are aggregated independently across subsets, with aggregate OES reported as a subset-level success average alongside separate ER and cPCSR averages.

5.2 Representation Compactness↩︎

We compare DeepCAD [21], Text2CAD [9], and HistCAD on their shared 134,896-model intersection. Table 5 shows that HistCAD with full constraints averages 550.35 tokens, shorter than Text2CAD at 590.62 tokens and far shorter than DeepCAD at 1,974.00 tokens. HistCAD without constraints achieves additional compression at 363.99 tokens. Figure 3 confirms this at the distribution level: DeepCAD exhibits a broad distribution with a heavy tail, while Text2CAD and HistCAD with constraints overlap strongly in the 200 to 700 token region. Table 4 shows that HistCAD-Industrial has substantially longer sequences than the academic subsets, with mean, median, and 95th-percentile token counts of 1,860.59, 707, and 6,323, respectively, confirming that HistCAD-Industrial expands the procedural complexity available for training and evaluation. Figure 4 provides representative samples from the three source subsets.

5.3 Native Sequence Constraint Ablation↩︎

We validate the benchmark by creating two variants of native source sequences: Full constraints, retaining all explicit constraints, and Closure only, retaining only coincidence constraints necessary for sketch closure. Figure 5 illustrates representative edit outcomes, Table 6 reports the overall ablation, and Table 7 shows the subset results.

The overall ablation provides the central validation result: the full constraint variant reaches 95.42% ER, 100.00% cPCSR, and 95.42% OES, whereas the closure only variant reaches a comparable 95.92% ER but drops to 67.51% cPCSR and 64.75% OES. The subset breakdown in Table 7 shows the same separation between edit reachability and constraint preservation. On HistCAD-DeepCAD data, closure only ER reaches 99.50%, exceeding the 98.25% ER of the full constraint variant, yet cPCSR drops to 55.53%, meaning nearly half of reachable edited states violate at least one preserved constraint. This demonstrates that constraints beyond closure are not primarily needed for reaching a valid state after an edit: because the closure only variant retains the coincidence constraints required for closed profiles, many edited sequences remain rebuildable, while the removed constraints are essential for preserving intended relations after that state is reached.

Table [tab:native-editability-intent] shows this pattern holds across both edit families. For closure only variants, adding a new dimension is harder than modifying an existing one primarily because cPCSR drops from 74.05% to 60.91%, not because ER changes substantially.

Table 8 provides diagnostics by constraint type. Equal constraints are most fragile under closure only conditions at 59.64%, followed by angle at 63.64%, parallel at 73.93%, length at 75.38%, and perpendicular at 76.38%. Coincident constraints remain fully preserved because they are explicitly retained for sketch closure. This diagnostic granularity demonstrates the benchmark’s ability not only to measure overall editability but to identify which specific aspects of design intent are most vulnerable to omission.

5.4 CAD Generation from Text↩︎

We train Qwen3-8B [47] generators for CAD generation from text using LoRA [48] under three training compositions: HistCAD-DeepCAD, HistCAD-Academic, which combines DeepCAD and Fusion 360, and full HistCAD. Each uses 90% of the data for training, 5% for validation, and 5% for testing. After filtering out sequences with 98,304 or more tokens, 153,518 DeepCAD, 8,609 Fusion 360, and 8,088 Industrial sequences are retained.

5.4.0.1 Overall shape metrics.

Table 9 reports aggregate MCD, MMD, COV, and JSD. Full HistCAD achieves the best MCD of 14.040, COV of 57.01%, and JSD of 0.98, while HistCAD-Academic achieves the best MMD of 3.300. The gains relative to the baseline trained only on DeepCAD are particularly pronounced for COV and JSD, indicating that industrial data broadens the training distribution in a way that improves global distribution matching.

3pt

5.4.0.2 Aggregate constraint prediction and editability.

Table 10 reports constraint prediction and editability. Full HistCAD achieves the highest F1 of 62.08%, ER of 83.67%, cPCSR of 87.36%, and OES of 73.33%, indicating that the full training corpus improves both constraint generation and behavior after edits. Adding Fusion 360 data alone improves aggregate F1 over the model trained only on DeepCAD, but it does not improve aggregate OES; the additional industrial data is needed to obtain the strongest overall editable success. The gap between aggregate OES at 73.33% and aggregate ER at 83.67% further shows that reaching a valid edited state is not sufficient: preserved constraint satisfaction remains a separate requirement captured by cPCSR and OES.

5.5 Effect of Industrial Data↩︎

Table 11 breaks down shape metrics by test subset. The results expose a substantial gap between existing academic data and professionally authored industrial models. This mismatch motivates the industrial-data experiment: a model that performs well on academic corpora may still fail to capture the procedural complexity and editability requirements of real design workflows. On the DeepCAD test subset, the generator trained only on DeepCAD maintains the best MCD of 1.742 and JSD of 0.35, reflecting distributional proximity to the academic source data. This advantage does not transfer to industrial models: on the industrial subset, full HistCAD leads all four metrics, with MCD improving from 14.236 to 10.979, MMD from 4.176 to 4.069, COV from 52.21% to 55.52%, and JSD from 1.86 to 1.02 relative to the baseline trained only on DeepCAD. On the Fusion 360 test subset, adding Fusion 360 data yields the strongest MMD of 3.601, but the industrial subset is where the full corpus gives the clearest distributional benefit.

Table 12 shows the same domain gap in constraint prediction and editability. Full HistCAD achieves the highest OES on all three subsets and gives the strongest industrial result, at 64.00% compared with 59.00% for the model trained only on DeepCAD, but the industrial subset remains the hardest case: its 64.00% OES is far below the Fusion 360 OES of 85.00%. The industrial failures are split between edit reachability, with ER at 78.00%, and preserved constraint satisfaction among reachable cases, with cPCSR at 82.05%, indicating that real industrial sequences stress both the ability to reach a valid edited state and the ability to preserve intended relations after that state is reached.

5.6 Direct LLM HistCAD Generation↩︎

Beyond supervised generation, we conduct a qualitative case study to examine whether HistCAD can serve as a direct output representation for general purpose LLMs. The prompt provides the HistCAD modeling sequence specification and a natural language description, asking GPT-5.5 to return JSON only, without additional training or prompt examples.

Figure 6 shows two base generations and two subsequent variants. GPT-5.5 generates executable sequences for a filleted flange and a chamfered hex nut; subsequent requirements add a raised neck variant and an internal helical thread cut, respectively. The generated JSON sequences listed in Appendix 9 and shown in Figure 7 are successfully rebuilt by the execution adapters described in Section 3.4, demonstrating that the schema’s explicit constraints and boundary references through 3D points can be generated by an LLM without examples. These qualitative results indicate that the HistCAD standard is sufficiently complete and structured to function as a direct target for LLM generation conditioned on a schema, a property that will facilitate future CAD synthesis and editing workflows with agents.

6 Conclusion and Future Work↩︎

We introduced HistCAD, a representation standard with explicit constraints, dataset, and benchmark for parametric CAD generation from sequences. The representation standard serves as an intermediate language independent of CAD software that explicitly encodes sketch constraints, feature operations, and boundary references through 3D points. The dataset unifies 170,236 academic and professionally authored industrial sequences with aligned artifacts. The Constraint-Aware Editability Benchmark, with its three diagnostic metrics ER, cPCSR, and OES, shifts evaluation from static shape recovery to design intent preservation under parameter edits.

Our experiments establish that explicit constraints are necessary for evaluating and generating editable CAD models. Native ablation confirms that static executability fundamentally differs from parametric editability: closure only sequences maintain high ER but lose intended constraint relations after editing. CAD generation from text experiments reveal that industrial data improves coverage and distribution matching and that the full HistCAD training corpus yields the strongest aggregate constraint prediction and editability. The industrial subset remains the hardest test case, with OES at 64.00%, indicating ample room for improvement. Direct LLM generation suggests that the HistCAD schema can serve as a direct executable target.

Several limitations motivate future work. First, the Constraint-Aware Editability Benchmark currently covers local dimensional edits; edits across multiple steps, modifications at the feature level, and feature reordering remain important extensions for capturing broader editing workflows. Second, the industrial data subset of 8,093 models is relatively small compared with the academic portion, which may limit training signal for complex operations; expanding industrial coverage is an ongoing effort. Third, the text annotations are generated by an LLM rather than authored by human designers, and their quality as supervision signals warrants further study.

Future work should broaden the benchmark to edits across multiple steps and feature modifications, expand coverage of long tail constraints and operations, and validate across additional CAD kernels. With richer diagnostic feedback, HistCAD can support iterative CAD agents that generate, execute, diagnose, and revise editable sequences, realizing the vision of generative CAD that preserves constraints and design intent.

Data and Code Availability↩︎

The academic portion of HistCAD and the associated scripts are publicly released in anonymized form. The release contains 162,143 modeling sequences, together with STEP models and text annotations. The code repository is available at https://anonymous.4open.science/r/HistCAD-68C2, and the dataset is available at https://anonymous-hf.up.railway.app/a/i1n9x5t85qu5.

7 Proof of Boundary Equivalence↩︎

This appendix provides the formal justification for the boundary construction used in Section 3.2.

7.0.0.1 Proof.

Fix an atomic subprimitive \(e\in\mathcal{E}\) and choose an interior point \(x\in e\). Because all intersections are split during decomposition, a sufficiently small open disk \(D_x\) centered at \(x\) intersects the sketch only along the trace of \(e\). Thus, \(e\) separates \(D_x\) into at most two open components, corresponding locally to the incident faces.

Let \(N(e)\) denote the number of selected faces incident to \(e\). By assumption, \(N(e)\in\{0,1,2\}\). Because no face boundary reuses \(e\), each incident face contributes exactly once to the loop family \(\{\partial f_i\}_{i=1}^{n}\). Therefore, \[\sum_{i=1}^{n}\sum_{j=1}^{m_i}\mathbf{1}[e\in L_{ij}] \;=\; N(e),\] and the parity condition for \(\mathcal{P}_{\mathrm{flat}}\) yields \[e\in\mathcal{P}_{\mathrm{flat}} \quad\Longleftrightarrow\quad N(e)=1.\]

We now evaluate membership in \(\mathcal{P}_{\mathrm{hier}}=\partial U\). If \(N(e)=0\), neither side of \(e\) belongs to the union \(U\), so a neighborhood of \(x\) is disjoint from \(U\), and hence \(e\not\subset\partial U\). If \(N(e)=2\), both sides of \(e\) belong to \(U\), so \(x\) lies in the interior of \(U\), and again \(e\not\subset\partial U\). If \(N(e)=1\), exactly one side of \(e\) belongs to \(U\) and the other to its complement. Every neighborhood of \(x\) therefore intersects both \(U\) and its complement, implying \(x\in\partial U\). Since \(x\) is an arbitrary interior point, \(e\subset\partial U\).

Consequently, \[e\in\mathcal{P}_{\mathrm{flat}} \quad\Longleftrightarrow\quad N(e)=1 \quad\Longleftrightarrow\quad e\subset\partial U \quad\Longleftrightarrow\quad e\in\mathcal{P}_{\mathrm{hier}}.\] Since this equivalence holds for all \(e\in\mathcal{E}\), we conclude \(\mathcal{P}_{\mathrm{flat}}=\mathcal{P}_{\mathrm{hier}}\). Shared interior boundaries therefore cancel, while outer contours and hole boundaries are preserved. \(\square\)

8 Annotation Algorithms↩︎

This appendix summarizes the deterministic procedures used to obtain the structured geometric metadata that supports the text annotations described in Section 3.5. The goal is to convert each executable CAD sequence into a compact description of its profile hierarchy and body layout within each model. Algorithm [alg:loop-extraction] first recovers closed sketch loops, organizes inner loops as holes of their containing outer profiles, and attaches an oriented bounding box to each body. Algorithm [alg:relation-extraction] then compares the resulting boxes to assign coarse relation types and relative position labels among bodies within the same model.

9 Direct LLM HistCAD Generation Sequences↩︎

Figure 7 shows the HistCAD JSON sequences used in the direct LLM case study in Section 5.6.

References↩︎