core concepts - blossommerz/locus-hub GitHub Wiki

Home > Core concepts

< Previous: Beta License Agreement | Next: Interface tour >

Getting Started

Core concepts

The ideas the rest of the manual assumes - construction vs. node graph, exact geometry, associativity, and the compass-and-straightedge law.

A handful of ideas run through everything in Locus. Understanding them once makes the rest of the manual click.

Construction vs. node graph

Locus has two ways to make geometry, and they're complementary:

  • Construction (Modeling window): you build objects by hand, each defined relative to others: a midpoint of two points, a tangent to a circle, an intersection of two lines. It's direct and visual.
  • Node graph (Nodes window): you describe geometry as a flow of data through nodes. It's parametric and repeatable: one slider can drive a hundred copies.

Neither replaces the other. You typically draw a motif by construction and then repeat and vary it in the node graph.

Two panels side by side. Left, the Modeling window: a compass-and-straightedge construction - points A and B, the segment between them, two compass arcs crossing, and the perpendicular bisector through their midpoint, built by hand. Right, the Nodes window: a small node graph, a Segment node wired into a Rotate node, describing geometry as a flow of data.

Color tells you the type

Locus color-codes every kind of data, and the same color means the same type everywhere you look - so once the palette clicks, you can read the whole interface at a glance.

It starts in the menus. A tool's icon is tinted by what it produces: point tools are blue, curve tools (segments, lines, circles) are green, and the region tools (the booleans) are orange.

Two open menus. In Draw, the Point and Midpoint tools have blue icons (they make points) while Segment, Circle, and Rectangle are green (they make curves). In Combine, Union, Intersect, Difference, and Fill are all orange (they make regions).

Pick a tool and that color carries straight through. The node it creates wears the color on its header; its output socket is the same color; and any wire leaving it is drawn in that color too.

Three mini nodes. A Point node has a blue header, a blue round output socket, and a blue wire; a Segment node is green with a green triangular socket and green wire; a Union node is orange with a square socket and orange wire - the same color on the header, the socket, and the wire in each case.

So a green header, a green socket, and a green wire are all saying the same thing: this is a curve. Sockets add a shape on top of the color - a colorblind-safe backup - so you can still tell types apart without relying on color alone. See the full palette on Data types, and how wires read on Sockets & wires.

Shape tells you how a point was made

Color tells you a point's type. Its shape tells you two things at once: how the point was created, and whether you can drag it.

Three panels. Free: a filled dark disc with grey arrows radiating in every direction. On an object: a green ring with a dot at its center sitting on a black circle, with a green double-headed arrow curving along the circle beside it. Calculated: a hollow blue ring on the crossing of two black lines, with no arrows at all.

  • Filled disc. You placed it yourself, on empty canvas. Nothing holds it, so drag it anywhere.
  • Ring with a dot. You placed it on something: a circle, a segment, an arc. It is still yours to move, but only along its host. One degree of freedom instead of two.
  • Hollow ring. You did not place it at all. The construction worked it out, from a crossing, a midpoint, a tangent, so there is nothing to drag. Move what it was built from and it follows.

The full set of point kinds is on Points.

Everything is associative

Objects remember how they were defined. A perpendicular bisector knows it bisects a particular segment; move the segment and the bisector moves. In the node graph, changing an upstream value re-evaluates everything downstream. You rarely edit geometry directly - you edit the definitions, and the geometry follows.

Exact lines and arcs

All geometry is analytic - real lines and arcs with exact math behind them, not polylines pretending to be curves. The booleans (union / intersect / difference) return true arcs, so paths stay smooth and corners meet cleanly at any zoom.

The compass-and-straightedge law

The Modeling canvas follows one design law:

Nothing in the construction that a compass and straightedge couldn't do.

No typing in an angle, no protractor, no numerically-placed vertices. This is a deliberate constraint that keeps constructions honest and, for pattern work, exact.

Note

The node graph is a parametric layer The compass-and-straightedge law governs the construction canvas. The node node graph is a parametric layer that intentionally goes further - offsets, booleans, arbitrary-angle rotation and arrays, grids, image-driven fields. Think of the canvas as the pure construction and the node graph as the machine that repeats and varies it.

Units

Locus works internally in millimeters - the real-world size of the finished piece. Where measurements surface, they're at that real-world scale.

The bridge

Dataflow across the Modeling | Nodes divide: a drawn object in the Modeling window is pulled into the node graph by a Reference node (a live pointer, model -> node graph), flows through node operations, and reaches a Realize node whose output is sent back into the model as realized geometry the node graph manages (node graph -> model). Reference and Realize are the two opposite-direction bridges between the windows.

The two windows exchange geometry through two nodes:

  • Reference takes a model object and feeds it into the node graph.
  • Realize takes the node graph's geometry and makes it real in the model.

Everything you build ultimately flows across this bridge. See Bridging Modeling & Nodes.

< Previous: Beta License Agreement | Next: Interface tour >

Related

⚠️ **GitHub.com Fallback** ⚠️