kiokoio/kioko-propellers

Kioko Parametric Propellers

Summary

This dataset holds 500 watertight propeller geometries. Each one was generated from the same parametric model, written in Kioko's CAD language, with a different set of design parameters.

• 500 samples, each a closed triangulated surface (.stl, ~730k triangles on average, 0.4M to 1.2M), plus front and back renders (.png).
• 42 design parameters per sample: span, blade count (sampled from 4 to 6; this release holds 4-, 5- and 6-blade propellers, 167, 164 and 169 of them), chord and sweep at five stations, and the camber, thickness, leading and trailing shape of four airfoil sections.
• Space-filling sampling: parameters are drawn with a Sobol sequence over the ranges in main.data, so the design space is covered evenly rather than clustered.
• Full traceability: dataset/metadata.csv (and dataset/index.json) records, for every file, the exact parameter values that produced it. Any sample can be regenerated from its row.
• Validated geometry: every published sample compiled without error and passed a watertightness check (no open edges, no edge shared by more than two triangles). Samples that failed were dropped rather than repaired. Every mesh is also consistently oriented, with all triangles facing outward, so enclosed volume and normals are correct. In this release the triangle winding was normalised after export (positions unchanged to within 0.001 mm); current Kioko writes it that way and its check rejects any sample that is not.
• A kernel at the junction of explicit and implicit geometry: smooth G1 spline surfaces driven by a control mesh, editable like B-Rep and watertight by construction (Chapter 1).
• The source is ~300 lines of code in 14 small files, described in Chapter 2.

---

Chapter 1: Kioko's mission and a kernel built for large, robust datasets

The mission

Kioko is building a CAD engine in which geometry is code. A part is described by a short, readable program: points, curves, surfaces and the operations that combine them. A compiler and geometry kernel turn that program into exact geometry and meshes.

Machine learning for engineering needs data that today's 3D datasets rarely provide: shapes that are valid (closed, manufacturable surfaces, not scans with holes), labelled with their design intent (which parameters made this shape) and available in quantity. Kioko's aim is to make that kind of data cheap to produce, for any family of parts an engineer can describe.

Between explicit and implicit: control and robustness in one surface

Geometry kernels usually belong to one of two families, and each pays for its strength with the other's:

Representation	Strength	Weakness
Explicit B-Rep (NURBS surface patches stitched along shared edges)	Full control: every curve, tangent and edge is a parameter you can grab	Nothing in the representation guarantees the stitching is clean: trims and seams leave gaps and slivers
Implicit (geometry as a function, f(x, y, z) = 0, e.g. a signed distance field)	Robust by construction: the result is always a valid, watertight solid	The input parameters are gone, so there is almost no designer-facing control

Kioko does not pick a side, and it does not run the two side by side either. It builds at the junction between them (The quest for the right geometry kernel): a smooth spline surface driven by a control mesh, the approach of engineering-grade subdivision surfaces.

• Control comes from the model. The engineer writes the shape the way a CAD designer would: NURBS and Hermite splines through exact points, Coons patches with chosen continuity (c0, c1) on each edge, surfaces of revolution and extrusions, trims, joins and patterns. Those parameters stay in the code, so every sample remains exactly the shape its inputs describe.
• Robustness comes from the representation. The compiler meshes every surface into quads that conform to the shared boundary curves, so neighbouring surfaces meet on the same nodes, and fits a single G1 (tangent-plane continuous) spline surface over that control mesh. Unlike a patchwork of rectangular NURBS stitched at its edges, a surface built over one control mesh has no interior seams to come apart: a joined part is one watertight surface of any topology.

This is what makes large, unattended sweeps possible. Over hundreds of parameter combinations the blade meets the hub at angles nobody drew by hand. The model keeps each sample under the engineer's control; the control-mesh surface keeps it closed, so a sample either compiles to valid geometry or fails loudly, never silently wrong.

From one model to a large, robust dataset

Large 3D datasets are usually either collected (scans, scraped CAD files: real variety, but inconsistent quality, no parameters and hard to scale) or produced by generative models (unlimited volume, but no guarantee the output is valid or closed). Kioko takes a third route:

1. An engineer writes the design once. The parametric model holds the engineering knowledge: how an airfoil section is built, how the blade is lofted through its sections, how it is trimmed against the hub and patterned around the axis. Every sample inherits this structure, so every sample is a plausible propeller.
2. The machine explores the design space. A .data file turns chosen inputs into ranges (Generator(low, high)), and the sweep samples them with a Sobol sequence, compiling many variants in parallel.
3. The kernel enforces validity. Each sample goes through the full CAD pipeline (curve and surface construction, trimming, joining, circular patterning, conforming quad meshing) and is checked for watertightness and consistent orientation before it is written. Anything invalid is rejected; the geometry is never patched.

The result is a dataset where variety comes from sampling, control from the parametric model, robustness from the control-mesh surface, and meaning from the engineer's design. Scaling up is a matter of asking for more samples, and building a new dataset is a matter of writing a new model.

---

Chapter 2: The Kioko code behind the dataset

The whole propeller family is defined by 14 .cad files totalling ~300 lines of code (about 500 with blank lines and comments), plus a 62-line main.data that declares which parameters vary and over what range. No mesh, script or external geometry is involved.

propeller/
├── main.cad              6 lines   project root: units, modules
├── main.data            62 lines   the 42 parameter ranges for the sweep
├── dataset/                        the generated dataset (see Dataset structure)
├── output/                         the default propeller's STL and pictures
├── profile/
│   ├── mod.cad           6 lines
│   ├── inputs.cad      122 lines   default values of every input
│   ├── base.cad         21 lines   hub profiles
│   ├── setup.cad        47 lines   leading- and trailing-edge spines of the blade
│   ├── airfoil_0.cad    31 lines   ┐
│   ├── airfoil_1.cad    36 lines   │ four airfoil sections along the span
│   ├── airfoil_2.cad    35 lines   │
│   └── airfoil_3.cad    33 lines   ┘
└── surfaces/
    ├── mod.cad           4 lines
    ├── hub.cad          11 lines   hub surfaces of revolution
    ├── blade.cad        32 lines   blade skin as Coons patches between sections
    ├── tip.cad          49 lines   blended, rounded blade tip
    └── final.cad        11 lines   trim the blade into the hub, pattern N blades

Why so little code

Each line declares one geometric object in terms of others, and the compiler tracks the dependencies between them. Change one input and everything downstream follows. A few representative lines:

An airfoil section is a pair of cubic splines through points placed relative to the chord:

chord = Line<Points>[lead_datum.point.o, trailing_datum.point.o]
len = Operation<Length>[chord]
vthickness = 0.25 * a0_thickness * len

a0_upper_profile = Spline<Nurbs>(3)[lead_datum.point.o, leading_upper_tan.end, width_upper_line.end, trailing_upper_tan.end, trailing_datum.point.o]

The blade skin is a set of Coons patches spanning consecutive sections, with continuity conditions on their shared edges:

a1_upper_surface = Surface<Coons>(c1, c0, c0, c0)[a1_upper_profile, a2_upper_profile, lead_mid, trail_mid]

The whole propeller is four lines: trim the blade against the hub, join, and pattern it around the axis:

blade_trim = Operation<Trim>(end)[blade_join, outer_surface]
outer_trim = Operation<Trim>(start)[outer_surface, blade_join]
blade_outer = Operation<Join>[blade_trim, outer_trim, front_surface, inner_surface]
propeller = Operation<Circular>(number_blades, 0, 360)[blade_outer, reference.line.x]

Making it a dataset takes one line per parameter in main.data:

propeller_span = Generator(250, 600)
number_blades = Generator(3, 6).with_stride(1)
a2_angle_attack = Generator(-20, 20)

The hard parts (surface intersection, trimming, watertight joining, conforming quad meshing) live in Kioko's kernel, not in the model. The model stays short, readable and easy to review, so an engineer can audit or modify a whole dataset's design logic in minutes.

Regenerating the dataset

kioko cad dev gen-parametric main.cad main.data dataset \
  --detail 3 --samples 500 --surface propeller --seed 843601473 --sampling sobol

--detail 3 meshes every patch at 3 x 3 quads before triangulation.

---

Dataset structure

The repository is the Kioko project itself: the .cad source at the root, and the generated samples in dataset/ (both dataset/ and output/ are gitignored).

main.cad, main.data, profile/, surfaces/   the Kioko source (Chapter 2)
dataset/<n>_main.stl      watertight triangle mesh of sample n (binary STL, millimetres)
dataset/<n>_main.png      front render
dataset/<n>_main_back.png back render
dataset/metadata.csv      one row per sample: file paths and the 42 parameter values
dataset/index.json        sampling metadata, parameter domains and per-sample parameters
dataset/propeller_grid_spin.gif  400 samples, evenly spaced through the 500, spinning in a
                          20 x 20 grid at one scale: the hub is the same size in every cell

metadata.csv columns: sample (n), stl_file, front_png, back_png (paths relative to the repository root), then one column per parameter, named as in main.data. It is the table shown by the dataset viewer and loads directly:

from datasets import load_dataset
ds = load_dataset("kiokoio/kioko-propellers", split="train")

index.json fields:

• data_file, sample_num, seed, sampling: how the sweep was run.
• inputs: the 42 varied parameters, each with its source file, name and domain (kind, low, high, step).
• segments: one entry per sample, with file_name and the parameters (variable and value) that produced it.
• failed: samples that did not produce a valid mesh (empty in this release).

Units are millimetres for lengths and degrees for angles. The remaining inputs are ratios, either of the local chord length or of the angular sector each blade occupies.

---

License

Released under the Creative Commons Attribution-NonCommercial 4.0 International License (CC BY-NC 4.0).

• Academic and non-commercial research use is free: you may use, share and adapt the dataset and its source, provided you credit Kioko.
• Attribution: cite the dataset as "Kioko Parametric Propellers, Kioko (kioko.io)", link to this repository, and indicate if you made changes.
• Commercial use requires our permission. This includes use by or for a company, in a commercial product or service, or to train models that are used commercially. Contact contact@kioko.io for a commercial license.

---

Contact

For more information about Kioko, custom datasets or the CAD engine, contact contact@kioko.io.