Points, Vectors & Planes

A point is the simplest primitive: a single location in space, three numbers {x, y, z}. That is all it is - no size, no direction. In Grasshopper you rarely type coordinates; you generate points. The two components you will use constantly are Construct Point (feed it x, y, z sliders and it builds a point) and Deconstruct Point (feed it a point and it hands back the three numbers). This pair - build-from-parts and break-into-parts - is a pattern you will see for almost every geometry type in this course.

Why does it matter so much? Because points are the anchors everything hangs from. A wall starts at a point, a column sits on a point, a curve is drawn through a list of points, a facade panel is placed at a point on a surface. When you learn later modules - dividing a curve, sampling a surface, laying out an attractor grid - the output is almost always points, and you steer the design by moving them. Get comfortable reading a point as "just three numbers I can compute" and you have the mental model that unlocks the rest. A common early habit worth building: whenever you are stuck, Deconstruct the geometry back to its points and look at the raw numbers - the bug is usually visible there. Points are also the cheapest, most legible thing to display while you work, so seasoned users scatter them liberally as diagnostic breadcrumbs across a definition.

A vector looks like a point - it is also {x, y, z} - but it means something completely different. A vector encodes a direction and a magnitude (a length), and crucially it has no fixed position. The vector {0, 0, 5} means "go 5 units straight up" no matter where you are standing. That homelessness is the whole point: a vector is a movement or an aim, not a place. Confusing points and vectors is the single most common beginner error, because Grasshopper draws them similarly and both have three components.

The practical distinction: you place points, you apply vectors. Move takes geometry plus a motion vector and shifts it. Rotate takes an axis vector. A surface hands you a normal vector telling you which way is 'out'. Grasshopper has friendly unit-vector shortcuts - Unit X, Unit Y, Unit Z - that give you a length-1 arrow along a world axis, and Vector 2Pt builds a vector from one point to another (this is how you get 'the direction from A to B'). Once you internalise that a vector answers "which way and how far", not "where", the components stop blurring together.

Here is a professional habit that pays off endlessly: separate the direction of a move from its distance. A vector bundles both together, which is awkward when you want to reuse an aim at different lengths. The fix is two components. Unitize (or the 'Unit Vector' component) rescales any vector to length exactly 1 while keeping its direction - now it is a pure aim. Amplitude then sets that unit vector's length to whatever number you feed it. So the idiom is: unitize to get the direction, then Amplitude to set the exact distance.

Why bother? Say you want to push a row of panels 200mm off a curved facade along each panel's own normal. The normals come out at all sorts of lengths depending on the surface parameterization - useless directly. Unitize them and every normal is length 1; feed Amplitude a slider and now one number controls the offset of the whole facade, cleanly. This 'unit + amplitude' split is also how attractor fields work later (Module 5): the attractor gives you a direction toward or away from a point, and a distance-based value drives the amplitude. Learn the pattern here and that module will feel obvious. The reverse tool, Vector Length (or Deconstruct Vector), reads a vector's magnitude back out when you need to measure rather than set it.

If points and vectors are famous, the plane is the quiet workhorse that beginners undervalue and experts lean on constantly. A Grasshopper plane is not just a flat sheet - it is a coordinate frame: an origin point plus three perpendicular axis vectors (X, Y, and the normal Z). It answers not only "where" but "which way is up, and which way is sideways". Whenever you need to place something with an orientation - a rectangle facing the right way, text that lies flat on a slope, a panel aligned to a facade, a box that tilts along a curve - you feed a plane.

The default is the world XY plane at the origin, but the power comes from building your own. Construct Plane takes an origin and two direction vectors. Plane Normal takes an origin and a single normal vector and figures out the rest - perfect for 'a plane sitting on this surface, facing out'. Plane 3Pt fits a plane through three points. And along a curve, Perp Frame (perpendicular frame) and Horizontal Frame give you a plane at any parameter, correctly aimed along the curve - the key to arraying anything on a path (next lesson but one). The reason planes matter is subtle but huge: orient a plane and the geometry riding on it comes along for free. Instead of rotating a complex object with fiddly angles, you build the target plane you want and let one Orient move do the work. When your geometry ends up mysteriously flat, twisted, or facing the wrong way, ninety percent of the time the answer is 'your plane is wrong' - so learning to see the frame is a genuine superpower.

These three primitives are not separate topics; they interlock, and seeing how is the real skill. A plane is built from a point and vectors (an origin plus axis directions). A vector is often built from two points (Vector 2Pt: the direction from A to B, with A and B being positions). A point can be found by starting at another point and adding a vector (Move a point by a motion vector). So the everyday flow of a definition is a constant conversation between the three: sample points on a surface, read the normal vector at each, build a plane from point-plus-normal, place a panel on the plane. Every later module is variations on that sentence.

It also helps to notice the frame you are already standing in. Rhino and Grasshopper have a world coordinate system - a global origin {0,0,0} and the world X, Y and Z axes - and unless you say otherwise, geometry is measured against it. The default construction plane is the world XY plane (the ground), with Z pointing up. Most beginner confusion about 'up' and 'flat' traces back to unknowingly working against the world frame when the design needed a local one. The remedy is the whole thrust of this lesson: when a task has its own natural orientation - a sloped roof, a curved wall, a tilted panel - stop fighting world XY and build the local plane that suits it. Points, vectors and planes are precisely the vocabulary for saying 'here, this way, on this frame' instead of being stuck with 'somewhere, world-aligned, flat'. Hold that and you will read other people's definitions - and debug your own - far faster.