GeomCAD

A procedural benchmark of executable CAD programs paired with triangle meshes, spanning four generative operations — extrude, revolve, sweep, and loft — at roughly one million samples per operation. Every numerical literal in every program is an integer in [0, 1000], 1,001 levels, which makes exact parameter-level comparison (Parameter Exact Match) well defined rather than approximate. Extrude alone never uses 0 and so occupies [1, 1000].

Loading

from datasets import load_dataset

ds = load_dataset("FanQY/GeomCAD", "extrude", split="train")
print(ds[0]["program"])

Each configuration is one CAD operation. Pass streaming=True to iterate without materialising a split locally.

Schema

Column	Type	Description
id	string	Sample identifier, unique within an operation
operation	string	extrude / revolve / sweep / loft
split	string	train / validation / test
program	string	Executable CadQuery program; all numeric literals are integers in [0, 1000], extrude [1, 1000]
mesh_vertices	binary	float32 array of shape (V, 3), C-order
mesh_faces	binary	int32 array of shape (F, 3), C-order
num_vertices	int32	V
num_faces	int32	F

Reconstructing the mesh

import numpy as np, trimesh

v = np.frombuffer(row["mesh_vertices"], dtype=np.float32).reshape(-1, 3)
f = np.frombuffer(row["mesh_faces"],    dtype=np.int32).reshape(-1, 3)
mesh = trimesh.Trimesh(vertices=v, faces=f, process=False)

Meshes are stored as an indexed mesh rather than as STL triangle soup. STL repeats each vertex about 5.6 times on average and stores a per-facet normal that is recoverable from the vertices; removing that redundancy shrinks the corpus roughly 5.7x. Deduplication compares exact float32 bit patterns — no vertex welding, no tolerance — so v[f] reconstructs the original triangle array byte for byte, and STL coordinates are float32 to begin with, so nothing is rounded.

Sampling a point cloud

The reference pipeline samples 8,192 points uniformly over the surface and reduces them to 256 by farthest point sampling:

points, _ = trimesh.sample.sample_surface(mesh, 8192)   # then FPS to 256

Meshes rather than precomputed point clouds are distributed deliberately: resampling the surface each epoch is a meaningful augmentation, and freezing a single 256-point draw would remove it. The mesh is also the more compact carrier — an 8,192-point float32 cloud is 98 KB per sample, larger than most of the meshes.

Note that trimesh.sample.sample_surface respects the global numpy seed only on some versions; newer releases construct their own default_rng. Set the seed explicitly if you need runs to be reproducible across environments.

Executing a program

import cadquery as cq

namespace = {}
exec(row["program"], {"cq": cq}, namespace)
solid = namespace["r"]
cq.exporters.export(solid, "out.step")      # STEP / BREP / IGES / STL / glTF / DXF / SVG

Programs execute through CadQuery's OCCT backend with no external dependencies, so every sample can also be exported to industrial B-Rep formats.

Integer parameters

Numeric literals are min–max normalised per script and rewritten as integers in [0, 1000], so every parameter a model must predict is drawn from one 1,001-level grid. The extent of the resulting solid is a consequence of the operation applied and is not itself constrained to that range; revolving a profile about an axis, for instance, carries it to the far side and spans about twice the profile radius by construction. Physical dimensions reported elsewhere (for example in figures comparing against float-parameter baselines) are the result of applying the per-script inverse map, and are therefore real-valued even though the program literals are not.

Splits

Operation	Train	Validation	Test	Total
extrude	998,815	1,500	1,500	1,001,815
revolve	998,965	1,035	1,500	1,001,500
sweep	998,796	1,071	1,500	1,001,367
loft	998,945	1,055	1,500	1,001,500
total	3,995,521	4,661	6,000	4,006,182

Training and validation come from each operation's procedural pool; the test split is generated independently through the same pipeline. Overlap at the level of sample indices is exactly zero. At the stricter level of program text, 15 training rows reproduce a test program (revolve 1, sweep 14) and one reproduces a validation program; they are listed in REPRODUCIBILITY.md and removed by the audit shipped with the corpus. Validation is 1,500 for extrude and smaller elsewhere because those held-out sets were carved from multi-operation training mixtures and only the rows belonging to each operation are kept here.

Mesh complexity varies sharply by operation, which matters when reading per-operation results:

Operation	Faces median	Faces mean	Faces p95
extrude	492	529	1,438
revolve	992	3,054	10,926
sweep	384	5,008	24,742
loft	326	1,037	3,728

Loft programs carry a median of 2 profile sections (mean 2.59, max 5) and about twice the curve primitives of the other operations, so recovering a loft means recovering both the number of profiles and their ordering.

Layout

data/<operation>/<split>-NNNNN-of-NNNNN.parquet
manifest.json      per-shard row counts
statistics.json    per-operation split sizes

Shards target roughly 300 MB so that an interrupted transfer re-does little work.