The quest for the right geometry kernel

Every CAD system is built on a geometry kernel — the engine that decides what a shape is before anyone draws it. Long before the menus, the colours and the keyboard shortcuts, the kernel makes one foundational choice: how do we represent geometry in a computer? Everything else inherits the consequences of that choice.

For decades the answer has come from one of two great families — explicit and implicit representation. Each is a genuinely good idea. Each is also a bargain, and the price is paid in the one currency engineers care about most: control. This post is about that bargain, and about a third option sitting quietly at the junction between the two.

Explicit representation: all the control, none of the guarantees

The explicit family is what runs the mechanical CAD world — CATIA, NX, SolidWorks. The dominant form is the boundary representation, or B-rep: a shape is described by its skin. You store vertices, the edges that join them, and the faces stretched between those edges. Each face carries an embedding surface, almost always a NURBS patch — a grid of control points, knots and weights.

The appeal is immediate and human. Everything that defines the shape is a parameter you can grab. Drag a control point and the surface follows. Select an edge, fillet it, pull a face. The model is a dense lattice of explicit knobs, and a designer reasons directly in terms of them. Explicit representation gives you control in its purest form.

The trouble is that all those parameters are held together by hand. A B-rep is a patchwork of separately-defined NURBS faces stitched along shared edges — and nothing in the representation guarantees that the stitching is clean. Neighbouring patches can disagree at their interface: a gap here, an overlap there, a sliver face born of nothing but the order someone clicked in. The academic literature has a wonderfully blunt name for it — geometric sloppiness.

The consequences are the daily pain of CAD:

• Booleans and fillets fail on tiny inconsistencies that the eye can't see.
• The model isn't watertight, so it can't be trusted as a solid without repair.
• Simulation is a battle — meshing a sloppy trimmed-NURBS patchwork is slow, fragile, and often needs manual cleanup before a solver will touch it.

So the explicit bargain is this: maximum control, minimum robustness. You hold every knob, and the structure holding the knobs together can fall apart at any moment.

Implicit representation: all the robustness, none of the handles

The implicit family takes the opposite road. Instead of describing the boundary, you describe a function. A shape is the set of points where some function reaches zero:

f(x, y, z) = 0

Everything inside is where f is negative, everything outside where it's positive. A signed distance field is the best-known example. The surface is never stored explicitly — it's implied by the sign of the function everywhere in space.

This is robust by construction, and that is its whole reason for being:

• Booleans are arithmetic. Union is a min, intersection a max. No stitching, no failure modes.
• The result is always a valid, watertight solid. There are no sliver faces to create, because there are no faces — only a function.
• Offsets, shells and blends are trivial, falling straight out of the function.

There are no gaps to repair because there is nothing to stitch. Where the explicit world fights for watertightness, the implicit world gets it for free.

But notice what disappeared. There are no control points. There are no edges to select. There are no parametric features. The shape is the consequence of a function, and a function is not something a designer reasons about the way they reason about a control point. You can't grab the leading edge of a wing in a level set — there is no leading edge, only a region where a number crosses zero.

This is the heart of the implicit bargain, and the precise reason it has never displaced explicit CAD for design: it removes control because it removes the input parameters. To change the shape you change the function — indirectly, abstractly, one step removed from the geometry you actually want. Robustness is total; designer-facing control is gone.

So the two families sit at opposite ends of a single axis:

	Control	Robustness	Watertight	Analysis-ready
Explicit (B-rep / NURBS)	full — every parameter is a handle	fragile — geometric sloppiness	not guaranteed	needs heavy meshing
Implicit (level set / SDF)	almost none — no input parameters	robust by construction	always	indirect

The quest for the right geometry kernel is the quest to stop choosing between these two columns.

The Kioko way: a contender at the junction

We think the interesting work is happening exactly between the two families — and we are not alone. A recent paper from the team at Inria (Université Côte d'Azur) and International TechneGroup — From CAD to Representations Suitable for Isogeometric Analysis: a Complete Pipeline, by Marsala, Mantzaflaris, Mourrain, Whyman and Gammon (2024) — lays out a representation that, to us, is the most promising candidate yet for that middle ground. It guides how we think about the Kioko kernel.

The key word in the paper is hybrid. The goal is explicitly not to replace B-rep, but to complement it — to build a representation that keeps the strengths of each family and a direct link back to the manufacturing CAD. The vehicle for this is an engineering-grade subdivision surface, refined into a smooth spline representation.

Here is why it lands so neatly at the junction.

It recovers implicit-grade robustness. A subdivision surface can describe an entire B-rep body — many contiguous faces, arbitrary topology — as a single, watertight surface. This is the thing NURBS cannot do: NURBS patches are strictly rectangular grids, which is exactly why the industry ends up stitching dozens of them together and inheriting all the sloppiness. One subdivision surface over an arbitrary-topology control mesh has no interior seams to come apart. You get the watertightness and the structural soundness that, until now, only the implicit world handed out for free.

It keeps explicit-grade control. A subdivision surface is still driven by a control cage — a mesh of control points, far fewer than a NURBS patchwork, that a designer (or a script, or an AI) can grab and move. The handles are back. And the paper's central trick restores the one thing plain subdivision surfaces always lacked for engineering: control of the boundary curvature. By adding Bézier edge conditions — slope control points that act like tangent vectors stored at the ends of each edge — the limit surface can be made to respect curvature across a boundary and behave like a true MCAD edge, to be manipulated as such. That is the explicit family's prized direct control, living on top of a watertight single surface.

It is generated automatically, and it stays linked to the real CAD. The control cage isn't hand-built. The pipeline derives it from the original B-rep, fits the smooth surface to a point cloud sampled from the genuine CAD geometry, and keeps a direct link to that manufacturing model throughout. The robustness doesn't cost you fidelity to the part you actually meant to build.

And it comes analysis-ready. Because the construction yields a geometrically smooth (G¹, tangent-plane continuous) spline space over the mesh, you can run isogeometric analysis directly on the representation — feeding the same smooth geometry to the solver instead of throwing it over the wall to a fragile meshing step. The explicit world's worst chore, simulation prep, partly dissolves.

Put the columns back up and the contender refuses to sit in either one:

	Control	Robustness	Watertight	Analysis-ready
Explicit (B-rep / NURBS)	full	fragile	no	no
Implicit (level set / SDF)	almost none	robust	yes	indirect
The junction (engineering-grade SubD / G¹ splines)	control cage + slope control points	single watertight surface, any topology	yes	yes — direct IGA

Finding the balance

We are not claiming a free lunch. The honest framing is that this is a balance, not a conquest. A subdivision-based kernel asks more of the construction step than either pure family: generating a clean control cage from a messy B-rep is hard, and the smoothness guarantees around irregular points are an active research frontier. The point isn't that the middle ground is effortless — it's that it's the only ground where control and robustness coexist at all.

That is the bet behind the Kioko kernel. Explicit CAD gave engineers every handle and no guarantees. Implicit CAD gave every guarantee and took the handles away. The representation worth building is the one that keeps the cage in your hands while making the surface impossible to tear — a kernel that is robust like a function and controllable like a control point.

The quest for the right geometry kernel isn't about picking the winning family. It's about building at the junction between them.

If this is something you'd like to talk more about, we'd love to hear from you — send us an email at contact@kioko.io.