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: out/metadata.csv (and out/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.
• Hybrid B-Rep + implicit kernel: exact B-Rep surfaces for control, implicit forms for robust intersections and trims (Chapter 1).
• The source is ~300 lines of code in 14 small files, described in Chapter 2.

---

Chapter 1: Kioko's mission and a hybrid approach to 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.

The hybrid approach: B-Rep for control, implicit for robustness

Geometry kernels usually pick one representation, and each has a known failure mode:

Representation	Strength	Weakness
B-Rep (boundary representation: NURBS curves, surface patches, shared edges)	Exact, editable shapes with precise control of every curve, tangent and edge	Intersections and trims rely on numerical searches that can miss or duplicate solutions, leaving gaps and slivers
Implicit (geometry as an equation f(x, y, z) = 0)	Robust queries: inside/outside and intersections become root-finding on one equation	Little direct control over the shape; sharp edges and precise boundaries are hard to express

Kioko uses both, each for the job it does best:

• B-Rep gives control. Every shape the engineer writes is a B-Rep object: NURBS and Hermite splines through exact points, Coons patches with chosen continuity (c0, c1) on each edge, surfaces of revolution and extrusions. The design intent stays exact and editable, and the final mesh is built conforming to the shared boundary curves, so neighbouring surfaces meet on the same nodes and the result is watertight by construction.
• Implicit gives robustness. Wherever an operand has an implicit form (lines, circles, planes and the datums built from them), Kioko substitutes the other operand's parametric curve into that equation and solves for the polynomial's roots. Intersections, trims and cuts are then found algebraically, all crossings at once, instead of by an iterative search that depends on a starting guess. Only spline against spline, the one pair with no implicit side, falls back to hull subdivision plus Newton refinement.

This is what makes large, unattended sweeps possible. Over hundreds of parameter combinations the blade meets the hub at angles nobody drew by hand. B-Rep keeps each sample exactly the shape the parameters describe; the implicit side keeps the operations between shapes reliable, 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 hybrid 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 B-Rep, robustness from implicit geometry, and meaning from the engineer's model. 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
├── out/                            the generated dataset (see Dataset structure)
├── 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 hybrid B-Rep and implicit 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 out \
  --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 out/.

main.cad, main.data, profile/, surfaces/   the Kioko source (Chapter 2)
out/<n>_main.stl          watertight triangle mesh of sample n (binary STL, millimetres)
out/<n>_main.png          front render
out/<n>_main_back.png     back render
out/metadata.csv          one row per sample: file paths and the 42 parameter values
out/index.json            sampling metadata, parameter domains and per-sample parameters
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 MIT License: free to use, modify and redistribute, including commercially.

---

Contact

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