Technical Summary: FllumaOne

Problem Statement

Parametric Computer-Aided Design (CAD) models are defined not merely by their final geometry but by their construction history—the ordered sequence of sketches, features, parameters, and dependencies that enable editing, design reuse, and manufacturing analysis. While large-scale geometry repositories (e.g., ModelNet, ShapeNet) and construction-aware datasets (e.g., DeepCAD, Fusion 360 Gallery) have advanced shape learning and command-sequence generation, a practical gap remains. Existing resources often lack the combination of an inspectable construction record, replayable executable code, kernel-validated geometry, and aligned multimodal inputs without requiring commercial CAD licenses. Furthermore, many datasets treat construction history as a separate representation problem from final geometry, limiting the ability to train models that generate editable, valid, and parameterized designs.

Methodology

The authors introduce FllumaOne, a code-native multimodal CAD dataset designed to bridge this gap. The dataset is generated using Flluma, a Qt/C++ CAD system built on the OpenCASCADE kernel, which executes Python programs to construct models.

Generation Pipeline

1. Controlled Procedural Generation: A scheduler selects from a library of 53 parametric template families, assigning them to four complexity levels (L1–L4) to ensure a balanced distribution of primitive and complex histories.
2. Executable Code Synthesis: For each sample, a Python program is generated using a regularized Flluma API. This API enforces explicit operation names, typed arguments, stable argument orders, and direct variable binding for intermediate objects.
3. Kernel-in-the-Loop Validation: Generated programs are executed in a headless FllumaCLI environment. Candidates are rejected if they fail geometric validation (e.g., invalid Boolean results, degenerate faces, non-manifold geometry) or STEP export checks. Only samples producing valid OpenCASCADE B-Rep solids are accepted.
4. Deduplication: A canonical construction signature check prevents exact duplicates in the construction history before kernel execution.
5. Multimodal Alignment: Accepted samples are exported into a unified set of modalities:
   • Source: Executable program.py and a structured feature_tree.json.
   • Training Target: A compact training_ir.txt serialized from the feature tree.
   • Geometry: STEP files (AP214 schema) and surface point clouds (2,048 points with normals).
   • Visuals: Eight canonical views (six orthographic, two isometric) focusing on visible edges rather than photorealism.
   • Text: Deterministic descriptions derived from metadata and LLM-enriched prompts (using a local Qwen2.5-7B model) that preserve geometric facts while varying natural language.

Baseline Evaluation

The authors evaluate the dataset's utility for text-to-CAD generation using a Qwen2.5-Coder-1.5B model fine-tuned with LoRA on 80,000 training samples. The task involves mapping natural-language descriptions to executable Python programs. Evaluation spans multiple stages:

• Code Level: Python syntax validity and API correctness.
• Execution Level: Successful loading and building within Flluma.
• Geometry Level: Kernel solid validation, STEP export success, and normalized Chamfer Distance against reference point clouds.

Key Contributions

1. Paired Construction Representations: The dataset provides a canonical feature tree, an executable Python program, and a compact training IR that describe the same editable modeling history at different levels of abstraction, allowing for cross-modal verification.
2. Kernel-Grounded Multimodal Release: Unlike datasets relying on final meshes or unverified sequences, FllumaOne aligns 100,000 samples with kernel-validated STEP geometry, surface point clouds, canonical views, and text, ensuring that every sample represents a physically valid solid.
3. Auditable Generation and Integrity: The release includes comprehensive reports on modality completeness, split membership, and exact-duplicate checks across programs, feature trees, and solid signatures, ensuring data integrity.
4. Executable Baseline and Evaluation Tools: The authors provide a reproducible text-to-program baseline and a full evaluation pipeline that measures success from syntax through kernel validation and geometric similarity, establishing a closed-loop evaluation path.

Results

The primary release, FllumaOne-100K, contains 100,000 accepted samples distributed across four complexity levels (L1: ~3%, L2: ~17%, L3: ~55%, L4: ~25%).

• Baseline Performance: The Qwen2.5-Coder-1.5B LoRA baseline achieved:
  • 99.98% Python syntax validity.
  • 99.97% Flluma build success.
  • 99.14% STEP export validity.
  • 99.14% Kernel solid validity.
• Geometric Accuracy: For the 9,909 predictions successfully converted to point clouds, the mean normalized Chamfer Distance was 0.002124, with a median of 0.001491.
• Complexity Analysis: The dataset exhibits a median feature count of 6 and a median history depth of 4, indicating a focus on multi-step editable histories rather than isolated primitives. The operation vocabulary consists of 44 tokens, with "Hole Pattern" being the most frequent (14.2% of feature-tree labels).
• Integrity: Zero exact duplicates were found across program hashes, feature-tree hashes, training IR hashes, or solid signatures.

Significance and Claims

The paper positions FllumaOne as a practical solution to the disconnect between final-shape datasets and proprietary native CAD histories. By providing an inspectable construction record paired with replayable code, the dataset enables research into editable CAD reconstruction, feature-tree prediction, and reverse engineering where the output must be modifiable rather than static.

The authors claim that the dataset supports a reproducible path from language to executable, geometrically comparable CAD output. However, they modestly note that the results represent interpolation within a controlled generator distribution rather than generalization to unseen template families or open-domain design. The dataset inherits the biases of its procedural generator (template families, parameter ranges) and does not claim to replicate the full diversity of human-authored industrial design workflows. The primary value lies in the ability to trace failures across code, feature history, kernel output, and export, facilitating the development of models that prioritize editability and geometric validity alongside shape generation.