Physics Simulation with Kangaroo

Kangaroo is a physics engine that lives inside a Grasshopper definition. Ordinary Grasshopper computes once, left to right: inputs produce outputs and stop. Kangaroo adds a loop. Its solver component (historically the 'Kangaroo Solver' or the newer Solver/Zombie components) takes a set of goals, applies them to a set of points repeatedly, and keeps iterating - many times a second - until the system settles. That looping, iterative behaviour is what lets it simulate: it is doing tiny time-steps, like a game engine, rather than a single calculation.

The technique underneath is often called dynamic relaxation (or a projection-based solver in newer Kangaroo): treat the geometry as a set of particles, work out the force each goal wants to apply, move the particles a little in response, damp the motion so it does not oscillate forever, and repeat. Energy bleeds out of the system with each step until it reaches a low-energy equilibrium - the state where every goal is pulling but the pulls cancel. That equilibrium state is the found form. It is exactly the hanging chain reaching rest, only now the 'chain' can be a whole mesh with thousands of nodes and many kinds of goal acting at once.

The key mental shift is that you stop authoring geometry and start authoring behaviour. You do not place the final vertices; you state the rules they must obey and let the solver discover where they end up. This is form-finding made interactive: because it runs live inside the parametric graph, you can grab an anchor and drag it, and the whole membrane re-relaxes in front of you.

Everything in Kangaroo is expressed as goals - small components that each want one thing to be true, and each push the geometry toward it. A few you will use constantly:

Anchor fixes a point in place (or to a target). Anchors are your boundary conditions - the nails the chain hangs from, the points where a membrane clips to the ground. Without anchors the whole thing just falls or drifts. Length / Spring makes an edge want a target rest length with a given stiffness; a network of springs is how you model a cable net, a fabric, or the edges of a mesh. Set the rest length shorter than the actual length and the spring pulls inward - that inward pull is exactly what tensions a membrane. Load applies a constant force such as gravity to points, which is how you hang a shape. UnaryForce, Pressure (a force normal to mesh faces, for inflated / pneumatic forms), Planarize (push a quad's four corners into a plane - vital for buildable glass panels), and OnMesh / OnCurve (keep points stuck to a surface or line) round out the everyday kit.

The craft is in balancing goals and their strengths. Kangaroo lets each goal have a weight; when goals conflict - a spring pulling in while an anchor holds still - the solver finds a compromise weighted by those strengths. Turn up planarization strength and panels flatten but the surface distorts; turn it down and the surface stays true but panels warp. Much of real Kangaroo work is tuning these relative strengths until the compromise is the one you want. There is no single 'correct' number - it is a design dial.

A good habit early on is to build a definition with just two or three goals and really understand how each one behaves before stacking more on top. Add an anchor, watch it hold; add a spring, watch it pull; add a load, watch it hang. Once each goal's effect is intuitive, combining a dozen of them stops feeling like guesswork and starts feeling like conducting - you know which dial to turn to get the effect you want.

The most beautiful thing Kangaroo does is find minimal surfaces - the shape a soap film takes between boundaries, the surface of least area spanning a given edge. Dip a bent wire in soapy water and the film that forms is a minimal surface; it is in uniform tension everywhere, which is precisely why fabric structures and cable-net roofs are shaped this way. Frei Otto found these forms physically with soap films and stretched stockings for the Munich Olympic roofs; Kangaroo finds them numerically.

To do it you start with a rough mesh spanning your boundary, anchor the boundary points (some high, some low - that height difference is what creates the characteristic double-curved 'saddle' shape), and put a Length or spring goal on every edge with a rest length of zero. A zero-rest-length spring wants to shrink to nothing, so every edge pulls its neighbours as tight as possible; the mesh cannot collapse because the anchors hold the boundary, so it relaxes into the least-area surface that spans them - a minimal surface. That is the whole recipe, and it is remarkably short.

The result is a tensile membrane: a doubly curved surface in pure tension, the natural home of fabric, ETFE and cable nets. Because it is in tension everywhere it needs no bending stiffness, which is why these roofs can be so astonishingly thin and light. And because the whole thing is parametric, moving one anchor higher instantly re-finds a new minimal surface - you are exploring a family of tensile forms, not committing to one. This is the tension-side twin of the last lesson's compression arch: hang-and-relax for cables and fabric, invert-the-hang for masonry and shells.

A typical Kangaroo definition reads like a sentence. First, build or import a mesh (a Mesh from a surface via Mesh Surface, or a triangulated field). Second, extract its edges and naked (boundary) vertices - Mesh Edges and Naked Vertices are the usual components. Third, wire goals: a Length/Spring goal on the edges, an Anchor goal on the boundary vertices, and a Load goal if you want gravity. Fourth, gather all the goals into the Solver's goal input and give it the starting geometry. Fifth, attach a Bang! or timer / toggle to run it, watch it relax, and reset when you change something upstream. When it stops moving, bake or extract the relaxed mesh - that is your found form, ready to pass downstream for panelling, structure or drawing.

A few practical habits save hours. Keep meshes reasonably coarse while experimenting - relaxation cost grows with node count, and a 20x20 mesh finds the same shape as a 200x200 one far faster; refine only once the form is right. Watch for instability: too-high stiffness or too-large steps make the solver explode or vibrate - lower the strengths or add damping. And remember the solver finds an equilibrium, not necessarily the one you pictured; if it settles somewhere odd, your goals or anchors are telling it something you did not intend.

Finally, the same honest boundary as always. Kangaroo is a form-finding and geometry tool, not a structural analysis tool. Its springs are a physical analogy tuned for shaping, not calibrated material models; it does not report stresses, deflections under code loads, buckling or safety factors, and its 'forces' are relative dials, not kilonewtons. Use it to find the shape the forces prefer - then hand that geometry to a structural engineer, and to analysis tools such as Karamba3D or dedicated FEA, for the real sizing and verification. Kangaroo tells you where the forces want to go; it does not certify that your members can carry them.