Open the OpenNURBS documentation on developer.rhino3d.com and the whole edifice of free-form modelling collapses into a single honest sentence: a NURBS curve is defined by four things — degree, control points, knots, and an evaluation rule. That is the entire object. Not a cloud of magic, not a proprietary secret. Four ingredients and a black box that eats a number and hands back a point. Once you can name all four, Rhino stops being a mystery and becomes a machine you can reason about.

This is the maths you do not have to derive, but absolutely should understand — because the day the plugin goes dark, the curve you cannot reconstruct is a beautiful guess you cannot defend in a structural review.

←TODAY: The 2026 Rhino 8 curve on your screen is still four numbers wide — degree, control points, knots, a basis function. →3012: File formats will die; the B-spline recurrence will not, because it is a theorem, not a feature. Fulcrum: A geometry you can name is a geometry you can rebuild — the derivation outlives the software.

Start from the letters

The acronym is the syllabus. N-U stands for non-uniform — the knots are allowed to be unevenly spaced. R stands for rational — the control points carry weights, which is the only way to draw an exact circle. B-S stands for basis spline — the evaluation rule is a weighted sum of B-spline basis functions. The Wikipedia entry on NURBS traces this back further than most designers realise: the physical spline was a thin strip of wood held down by lead weights (the “ducks”) so a shipwright could draw a fair hull curve. Carl de Boor’s 1978 A Practical Guide to Splines (Springer, ISBN 0387953663) — cited at the foot of the very Rhino page that prompted this piece, alongside Böhm, Farin and Kahmann’s 1984 survey in Computer Aided Geometric Design Vol. 1 (pp. 1–60) — turned that strip of wood into a recurrence relation. The wood became an algorithm.

Degree is a positive whole number: 1 for polylines, 2 for circles, 3 or 5 for the free-form curves you actually push around. The order is just degree+1 — a bookkeeping convention from older evaluators, nothing deeper. Raising the degree never changes the shape; lowering it almost always does. That asymmetry is your first real clue that a NURBS curve is not symmetric in its parameters — some moves are lossless, some are not.

Control points are the handles. At least degree+1 of them. They do not lie on the curve (except at the ends) — they pull it, like the rubber band the Wikipedia article describes. Move one, and only a local stretch of curve responds. That locality is not a convenience; it is a mathematical property of the basis functions, and it is why NURBS won over the global polynomials that came before.

Weight is the number bolted to each control point. All-equal weights (usually 1) give you a non-rational curve — the honest majority. Unequal weights make it rational, and rationality is precisely the trick that lets a piecewise-polynomial curve trace a perfect conic. A circle in Rhino is always rational; it has to be, because no non-rational polynomial can be a circle. That is a theorem, not a Rhino limitation.

The knots are where the confusion lives

Here is the beat everyone skips. The knots are a non-decreasing list of degree+N−1 numbers (N = number of control points). They are not 3-D directions — “vector” here is old spline vocabulary. What they actually encode is where along the parameter one basis function hands off to the next. The OpenNURBS overview gives the worked example: for a degree-3 curve with 11 control points, 0,0,0,1,2,2,2,3,7,7,9,9,9 is legal; 0,0,0,1,2,2,2,2,7,7,9,9,9 is not, because four 2s exceeds the degree.

Why does that ceiling matter? Because multiplicity — how many times a knot value repeats — is the smoothness dial. A knot in the middle of the list, repeated degree times, lets the curve bend into a sharp kink. Full multiplicity at the ends is what clamps the curve to its first and last control points. This is the single most useful mental model on the page: duplicate interior knots = local loss of smoothness. Designers who add and remove knots to sharpen or soften a curve are, whether they know it or not, dialling the continuity of the basis functions.

And the myth the Rhino authors go out of their way to kill: one knot does not pair with one control point. That one-to-one intuition only holds for degree-1 polylines. For higher degree, groups of 2×degree knots govern groups of degree+1 control points — the influence overlaps. If you have ever wondered why moving a single control point on a degree-3 curve nudges four spans of curve, that overlap is the answer.

Atelier: For a Swiss Büro standardising on Rhino + Grasshopper, the risk this week is not that anyone draws a bad curve — it is that half the team treats NURBS as an opaque black box and the other half quietly fixes their geometry. The Monday move: run a 30-minute internal Kaffi where one person rebuilds a circle, a fillet, and a lofted free-form panel and reads out the degree and control-point count from the properties panel for each. Make “what degree is this, and how many CVs?” a normal question in a model review. A team that can name the geometry can defend it in a Prüfstatiker’s structural review; a team that can only operate the tool cannot.

Hack: Watch a knot become a kink with your own eyes. Drop this into a GhPython component in Grasshopper — it builds a degree-3 curve, then rebuilds it with a tripled interior knot so you can bake the smooth version and the kinked version side by side.

import Rhino.Geometry as rg
pts = [rg.Point3d(x, 0, 0) for x in range(6)]; pts[2] = rg.Point3d(2, 3, 0)
smooth = rg.NurbsCurve.Create(False, 3, pts)          # simple knots -> C2 fair
kinky = smooth.Duplicate(); kinky.Knots.InsertKnot(kinky.Knots[kinky.Knots.Count // 2], 3)
a = [smooth, kinky]   # same CVs, same degree: only the knot vector differs

Same control points, same degree — the only difference is the knot vector, and it changes the curve from C² smooth to a hard corner. That is the whole lesson of the letters N and U made visible.

Why this is the maths you can skip and the maths you can’t

You will never hand-evaluate a B-spline basis function on the job — the Cox–de Boor recurrence that de Boor formalised in 1978 runs invisibly inside every Curve.PointAt call. That is the maths you can skip. But you cannot skip knowing that the four inputs exist and what each one does, because that is the difference between steering the tool and being steered by it. PAZ has framed exactly this before: in our Universal Glue piece, Rhino’s NURBS core and David Rutten’s Grasshopper (shipped with Rhino since September 2007) are described as the “universal glue” that makes parametric thinking legible — because the geometry underneath is nameable. Naming it is the point.

The trajectory worth naming: the parametric work my generation came to regret was never the ugly form — it was the form whose logic nobody could reconstruct after the plugin went dark. A generated geometry with no derivation cannot be defended. The defence against that future is cheap and available today: when you make a curve, know its degree, count its control points, and understand that its smoothness lives in the knots. Keep the maths. The file format will not survive you.

Open Rhino, draw one curve, and read its four numbers off the properties panel before you touch another tool. Thirty minutes now buys you a geometry you can rebuild for the rest of your career.

Sources & Further Reading

• Primary: developer.rhino3d.com — What are NURBS? (OpenNURBS overview)
• Reinforcing: Wikipedia — Non-uniform rational B-spline
• PAZ context: PAZ — Universal glue