Your First Definition

Every definition starts with inputs, and ours is a single curve. Draw any open curve in Rhino - an arc, a freeform interpolated curve, whatever you like. Then, in Grasshopper, place a Curve parameter (double-click the canvas, type curve), right-click it, and choose Set one Curve; the cursor jumps to Rhino and you click your curve. The parameter now references that Rhino object - it does not copy it, it points at it, so if you reshape the curve in Rhino the whole definition updates.

That referencing relationship is worth pausing on. Your curve lives in Rhino; your logic lives in Grasshopper; the Curve parameter is the bridge. This is the Module 1 idea 'from Rhino to Grasshopper' made concrete - Rhino provides the hand-modelled starting geometry, Grasshopper does the parametric work on it. You could instead build the curve entirely inside Grasshopper (from points, or a primitive), but referencing a Rhino curve is the most common and most tangible way to begin.

With the curve referenced and previewing, you have an input feeding an empty definition. Now we make it do something.

We want evenly spaced positions along the curve, so we reach for Divide Curve. Place it, then wire your Curve parameter's output into its C input. Add a Number Slider, set it to integer, range 1 to 40, and wire it into the N input - N is the number of segments. Divide Curve's P output now produces a list of points spaced equally along the curve.

Drop a Panel on that P output and look: a list of point coordinates, one per division. Drag the N slider and watch the list grow and shrink live in the Panel and in the Rhino viewport. This is the moment the whole course clicks for many people - you are not placing points, you are describing a rule ('divide this curve into N equal parts') and the points are its consequence. Change N and every point re-solves; change the curve and they redistribute along the new shape.

A subtlety worth naming: an integer slider matters here. N is a count, and a count of 12.5 is meaningless. Right-clicking the slider and setting it to integer stops it ever feeding a fractional value into N. Matching a parameter's type to its meaning - integer for counts, float for sizes - is a small habit that prevents a lot of orange-warning confusion.

It is worth being precise about what Divide Curve does, because the name misleads a little. N is the number of segments, and dividing a curve into N segments produces N+1 points on an open curve (the two ends plus the interior divisions), or N points on a closed one where the ends coincide. So a slider reading 12 on an open curve gives you thirteen points. This is exactly the kind of off-by-one detail that a Panel on the P output settles instantly - rather than assume, you read the actual count. There are sibling components too: Divide Length spaces points a fixed distance apart, and Divide Distance does likewise from the start; Divide Curve is the equal-count version and the one to reach for when you want a specific number of items regardless of the curve's length.

Now the payoff. We will place a circle at each division point, all sized by a second slider. Place a Circle component. It needs a plane or centre point and a radius; wire the P output of Divide Curve into the Circle's plane/centre input (P), and add a second Number Slider - this one a floating-point value, range say 0.1 to 2.0 - wired into the Circle's R (radius) input.

Here is the quietly magical part: Divide Curve produced a list of, say, twelve points, and you wired that list into a component expecting one centre. Grasshopper does not complain - it repeats the operation for every item in the list, giving you twelve circles automatically. This automatic 'do it for each item' behaviour is one of Grasshopper's most important habits (we formalise it as data matching in Module 3), and you just used it without ceremony. One Circle component, a whole ring of circles.

Step back and read what you built: a curve (input) drives a set of points (operation), which drive a set of circles (result), and two sliders - count and radius - steer the entire thing live. Drag N and the number of circles changes; drag R and they all resize together. That is a genuine parametric definition. It is small, but structurally it is the same as a facade or a tower - inputs, operations, generated geometry, live controls.

Notice too that Circle wanted a plane (a centre point plus an orientation), and you gave it bare points. Grasshopper again fills the gap with a sensible default: a point supplied where a plane is expected becomes a world-XY plane at that point, so every circle lies flat. That is fine for a first build, but it hints at the next level of control - if you fed Divide Curve's T (tangent) output in to build a plane aligned to the curve, the circles would tilt to follow it like the ribs of a boat. You do not need that yet; the point to absorb is that the same three-stage skeleton accepts richer inputs as your ambition grows, without changing its shape.

Before celebrating, read what you made. Keep a Panel on the point list and glance at the counts; toggle Circle's preview on and the intermediate points' preview off so the viewport shows only the clean result. Sweep both sliders through their ranges and watch behaviour at the extremes - N at 1, N at 40, R tiny, R large. Reading and sanity-checking a result is a real skill; a definition that looks right at one slider value can misbehave at another, and you want to discover that now, not in a review.

Then tidy the canvas into a group. Select the components that belong together - Curve, Divide Curve, Circle and their sliders - and press Ctrl+G (Command+G on Mac) to wrap them in a group: a coloured, named box that moves as one and documents intent. Right-click the group to rename it ('Circles along curve') and recolour it. Groups are not decoration; on a definition of any size they are how you and your collaborators navigate. A scribble (a text note on the canvas) near the sliders - 'N = count, R = radius' - is the other cheap documentation habit worth starting now.

Finally, if you want real Rhino objects - to dimension, render or export - select the Circle component, right-click, and Bake the circles into the Rhino document. The definition stays live for further tweaking; baking just takes a snapshot. It is worth baking onto a named layer so the results do not vanish into the default layer, and remember that a re-bake after changing a slider adds a second set of objects rather than updating the first - baked geometry has no memory of the definition that made it. You have now completed the full loop the course promised in Module 0: you designed a rule, and the geometry followed.