kiokoio/kioko-discs

Kioko Parametric Brake Discs

Summary

This dataset holds 500 watertight brake-disc geometries in the style of Formula 1 discs: a thick ring drilled through with hundreds of radial cooling holes, up to 1,000 per disc, laid out for maximum cooling. Air enters at the disc's bore and is pumped out through the holes to the rim. Every disc 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, 9 million triangles on average, 4.4M to 18M) plus a render (.png).
• 303 to 995 cooling holes per disc (median 485): 101 to 199 rows around the disc, each a stack of 3, 4 or 5 holes through the thickness, 2.0 to 3.5 mm in diameter.
• 8 design parameters per sample: hole rows and holes per row, inner and outer radius, hole size and spacing, and the shape of the air inlet at the bore. Two derived sizes, hole diameter and pitch, are recorded alongside them.
• Every sample is buildable: hole size and spacing are sampled as fractions of the room the holes have, so no two holes touch and none runs off the face it is drilled through.
• 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, and the two triangles on every edge wound consistently. Samples that failed were dropped rather than repaired.
• 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 ~130 lines of code in 9 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.

A brake disc is a demanding test of that aim. Its cooling performance lives in hundreds of small holes, each one a cut through two curved faces, and a single gap anywhere in the part makes the geometry useless for thermal or flow simulation.

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: the disc's cross-section as lines and a Hermite curve, the faces as surfaces of revolution, each hole as an extruded circle, then trims, joins and a circular pattern. 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 whole disc, with all its holes, is one watertight surface.

This is what makes large, unattended sweeps possible. Over hundreds of parameter combinations the holes meet the bore and the rim at angles and spacings 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 the disc's section is drawn, how the holes are sized to the room they have and tilted when rows crowd each other, how they are cut through the rim and the bore and how one sector is patterned round the disc. Every sample inherits this structure, so every sample is a plausible brake disc.
2. The machine explores the design space. A .data file turns chosen inputs into ranges (Generator(low, high)), and the sweep samples them at random, 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 disc family is defined by 9 .cad files totalling ~130 lines of code (about 190 with blank lines and comments), plus a 14-line main.data that declares which parameters vary and over what range, all in code/. No mesh, script or external geometry is involved.

disc/
├── README.md
├── dataset/                            the generated dataset (see Dataset structure)
└── code/
    ├── main.cad              5 lines   project root: units, modules
    ├── main.data            14 lines   the 8 parameter ranges for the sweep
    └── caketin/
        ├── mod.cad                     (empty)
        └── disc/
            ├── mod.cad       6 lines
            ├── inputs.cad   53 lines   default values of every input, and the hole sizing rules
            ├── profile.cad  14 lines   the disc's cross-section: rim, faces, shoulder, inlet curve
            ├── faces.cad    12 lines   seven surfaces of revolution, one sector wide
            ├── holes.cad    81 lines   up to five rows of radial hole tubes, tilted when they crowd
            ├── trims.cad     8 lines   cut the holes through the rim and the bore
            └── final.cad     7 lines   join one sector, pattern it round the disc

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:

The air inlet at the bore is one Hermite curve between the shoulder and the bell, its tangents set by two angles and its fullness by a tension:

s_tan = Line<Angle>(-inlet_ib_angle, 0, 1)[shoulder.end, shoulder, reference.plane.x]
inlet = Spline<Hermite>(inlet_ib_tension, 1, 5, -1)[shoulder.end, s_tan, bell_ib.end, b_tan]

A face of the disc is that curve revolved through one sector:

#disc_inlet = Surface<Revolve>(-half_row_angle, half_row_angle)[inlet, reference.line.y]

A cooling hole is a circle extruded along a radial axis, from inside the bore to beyond the rim:

h0_axis = Line<Angle>(-hole_angle, inner_radius-5, outer_radius+5)[h0_point, h0_vertical, reference.plane.y]
h0_profile = Circle<Radius>(hole_radius, 0, 360)[h0_axis.start, h0_pl]
#h0_surface = Surface<Extrude>(0, outer_radius-inner_radius+10)[h0_profile, h0_axis]

The whole disc is the holes cut through the rim and the bore, one sector joined, and that sector patterned round the axis:

#top_trim = Operation<Trim>(start)[disc_top, h_group]
#inlet_trim = Operation<Trim>(start)[disc_inlet, h_group]
#hole_trim = Operation<Trim>(end)[hole_trim_top, disc_inlet]
#sector = Operation<Join>[disc_ib, disc_ob, disc_shoulder, disc_bell, disc_bell_ib, inlet_trim, top_trim, hole_trim]
disc = Operation<Circular>(number_rows, 0, 360)[sector, reference.line.y]

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

number_rows = Generator(100, 200).with_stride(1)
holes_per_row = Generator(2, 5).with_stride(1)
hole_fill = Generator(0, 1)

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.

Sizing the holes so every sample can be built

Sampling hole diameter and spacing directly, about 15% of the parts had holes that overlapped at the bore or ran off the inlet face. inputs.cad sizes the holes as fractions of the room they have instead:

• hole_fill (0 to 1) places the diameter between 2.0 mm and the largest hole that fits: at most 3.5 mm, the stack of holes within the inlet face, and one hole plus 0.2 mm clearance either side across the sector at the narrowest point of the bore.
• neck_ratio is the material left between neighbouring holes in a row, as a fraction of the diameter: hole_pitch = hole_diameter * (1 + neck_ratio), so holes never touch.
• holes.cad tilts alternate rows apart when the pitch alone would bring holes of neighbouring rows closer than 1.25 diameters, and limits the tilt so a hole keeps its clearance from the sector side.

Regenerating the dataset

A whole disc compiles in minutes and tens of GB, one sector in about a minute and under one, so the sweep runs in two stages (scripts/disc_sweep.py). Stage A compiles each sample's single sector and keeps it only if its mesh is sealed and free of adjacent extraordinary-vertex pairs; stage B compiles the kept samples as whole discs and keeps the watertight ones:

python3 scripts/disc_sweep.py --project service-cad/compiler/compiler-core/examples/disc \
  --out service-cad/compiler/compiler-core/examples/disc/dataset --work target/disc_sweep \
  --chunks 10 --chunk-size 500 --seed 20261020 --a-jobs 12 --b-jobs 5 --stop-after 500

Chunk k is drawn under seed 20261020 + k. In this release stage A screened 5,000 sectors and kept 1,000; stage B compiled 507 of them as discs, wrote the first 500 and dropped 7 that leaked. Every surface patch is meshed at 3 x 3 quads before triangulation (--detail 3, the default).

---

Dataset structure

The repository is the Kioko project itself: the .cad source in code/, and the generated samples in dataset/.

code/                      the Kioko source: main.cad, main.data, caketin/ (Chapter 2)
dataset/<n>_main.stl       watertight triangle mesh of sample n (binary STL, millimetres)
dataset/<n>_main.png       render from above
dataset/metadata.csv       one row per sample: file paths, the 8 parameter values and 2 derived sizes
dataset/index.json         sampling metadata and per-sample parameters, plus the dropped samples
dataset/disc_grid_spin.gif 400 samples, evenly spaced through the 500, turning like coins in a
                           20 x 20 grid at one scale
dataset/disc_single_spin.gif  sample 201 (995 holes) turning slowly, close up on the holes

metadata.csv columns: sample (n), stl_file, front_png (paths relative to the repository root), the parameters named as in main.data (hole_fill, holes_per_row, inlet_ib_angle, inlet_ib_tension, inner_radius, neck_ratio, number_rows, outer_radius), then the derived hole_diameter and hole_pitch. It is the table shown by the dataset viewer and loads directly:

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

The number of cooling holes in a disc is number_rows * holes_per_row.

index.json fields:

• data_file, seeds, screened, sample_num: how the sweep was run (one seed per chunk of 500, the sectors screened, the discs compiled).
• segments: one entry per sample, with file_name, the parameters (variable and value) that produced it, the derived hole diameter and pitch, and the source chunk sample.
• failed: the 7 discs that compiled but leaked, with the error the watertightness check gave.

Every disc is 32 mm thick. Lengths are millimetres and angles degrees; hole_fill and neck_ratio are ratios, inlet_ib_tension is the Hermite curve's tension.

---

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 Brake Discs, 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.