Precision & Transforms

Under every model is a coordinate system: a world origin at 0,0,0 with x, y and z axes. When a command asks for a point, you can click - or you can type an exact location, which is how precise models are really built. Absolute coordinates (10,5,0) place a point at that exact spot in the world. Relative coordinates (r5,0,0, or in Rhino simply typing a distance after picking a start) place it a set displacement from the last point - usually what you want when drawing. You can also type a distance then direction: start a line, type 3000, and move the cursor to lock the length while aiming the direction.

This is the foundation of exactness. A wall that is '3000 long' because you typed 3000 is trustworthy; a wall that is 'about 3000' because you eyeballed it is a latent error. Combine typed distances with the Ortho constraint (hold Shift to lock to the axes) and you can draw precise orthogonal geometry at speed without ever guessing. Get comfortable typing values into the command line while you draw - it is the single fastest upgrade to your accuracy.

It helps to hold a clear picture of the frame you are typing into. Coordinates are read against the current construction plane (more on that below), so 2,0 means 'two units along the current x, zero along y' - which is the ground plane by default but can be any local frame you choose. Rhino also accepts constraints you can combine mid-command: type a distance to lock length, tap Tab to freeze a value while you set the direction, or type an angle to lock direction. You do not need to memorise every form at once; you need the habit of asking, for each point, 'do I actually know where this should be?' - and if you do, typing it rather than clicking near it.

Object snaps (Osnaps) are the second pillar of precision. With Osnaps on, your cursor latches onto meaningful points of existing geometry: End, Mid, Cen (centre), Int (intersection), Quad, Perp, Tan, Near. Snap the start of a new line to the exact endpoint of an existing one and the two genuinely share a point - no gap, no overlap - which is precisely what lets them Join, Loft or Boolean later. The persistent Osnap toolbar lets you keep a few running (End and Mid are the everyday pair); one-shot snaps let you invoke a specific one for a single pick.

Alongside snaps sit the constraints on the status bar. Ortho locks movement to the axes. Grid Snap rounds to the grid. SmartTrack and Project extend Osnaps with temporary tracking lines and force picks onto the CPlane. The mindset is: never place a point 'roughly on' something you can snap 'exactly to'. Almost every downstream failure - a Join that won't close, a surface with a sliver gap, a fabrication file that's a hair off - traces back to a point that was placed by eye when it could have been snapped. Snaps make exactness the path of least resistance, which is exactly why disciplined modellers lean on them constantly.

The Gumball is the coloured widget that appears on a selected object: arrows to move along each axis, arcs to rotate, and small squares to scale. It is fast and tactile - drag the red arrow to slide along x, the blue arc to spin about z. Crucially, it is also precise: start dragging and type a number, and the transform snaps to that exact value. The Gumball is not a sloppy alternative to typed commands; it is a typed command with a handle.

Behind it sit the explicit transforms you will use constantly. `Move` shifts by a vector (pick from-point to to-point, or type a distance). `Rotate` turns about a point by an angle. `Scale` (Scale, Scale1D, Scale2D) resizes about a base point - and note that Scale1D and Scale2D let you stretch in one or two directions only, which is how you resize without distorting the rest. `Array` is the precision powerhouse: ArrayLinear repeats an object a set count at a set spacing, ArrayPolar repeats it around a centre, and ArrayCrv distributes copies along a path - exactly the kind of controlled repetition that computational design formalises later, done here by hand. `Orient` (Orient, Orient3Pt, OrientOnCrv) is the one people under-use: it moves-rotates-and-optionally-scales an object from one set of reference points onto another, letting you drop a component precisely onto a sloped face or along a curve. Together these are the vocabulary of putting things exactly where they belong.

It is worth noticing how directly these hand tools foreshadow Grasshopper. An ArrayLinear you set by typing a count and spacing is the manual version of a Series feeding a Move in a definition; an Orient onto a face is the manual version of orienting geometry to a Plane. Doing them by hand now builds the physical intuition that makes the parametric versions obvious later - you are learning the grammar of transformation, then automating it.

By default you draw on the world x,y plane - the ground. But real geometry is not all horizontal, and drawing a detail on a tilted roof by wrestling world coordinates is miserable. The construction plane (CPlane) is the fix: a local 'drawing table' you can reposition and reorient so that your x, y directions align with whatever surface or angle you are working on. Set a CPlane to a sloped facade (CPlane > Object, or 3Point) and suddenly typing 2,0 draws two units across the facade, snaps and Ortho work in the facade's frame, and the work becomes as easy as drawing on the ground.

Each viewport carries its own CPlane, and you can save named CPlanes to jump back to a working frame. This is quietly one of Rhino's most powerful precision features: instead of building tilted geometry with awkward 3D coordinates, you move the reference frame to the geometry and draw simply. It also foreshadows Grasshopper, where planes are first-class objects that orient components, arrays and boxes - the CPlane you set by hand here is the same idea you will later generate and manipulate by the thousand. Learning to think in local frames now makes that leap natural.

Every Rhino document has units (mm, cm, m, inches) and an absolute tolerance - the distance within which Rhino treats two points as coincident. Tolerance is the least glamorous setting in the program and one of the most consequential. It governs whether a Join closes, whether a Boolean resolves, how finely curves are approximated when they are converted, and how much slop your fabrication files carry. Set it too loose (say 0.1 mm on a jewellery-scale part) and joins silently gap and Booleans fail; set it absurdly tight (0.0001 mm on a building) and operations crawl and produce needlessly heavy geometry.

The rule of thumb is to match tolerance to scale and purpose: architectural models often work well around 0.001 m (1 mm) or finer; product and fabrication work goes tighter. Set units and tolerance at the start of a document - changing them midway does not re-heal geometry already built loose. And be deliberate about model scale: a model built in metres will behave differently under the same numeric tolerance than one built in millimetres, so keep units, tolerance and the physical size of your features consistent. This is where precision stops being about individual clicks and becomes a property of the whole file - and it is exactly the property that determines whether your careful geometry survives the trip to a CNC, a laser cutter, or a fabricator's shop floor. When in doubt, model to real-world size in real units; never model 'unitless' and hope to sort out scale later.