I am pleased to announce version 0.06 of the Kangaroo physics plugin for Grasshopper.

Download it free from http://www.food4rhino.com/project/kangaroo

This version contains bug fixes and many new features – wind, planarization, vortex, shear, alignment, anchorsprings, constrain to curves… see my video page for some examples

I am also starting to upload an updated collection of example definitions showing how to use each of these new forces here:



New technologies get really interesting once we move beyond just recreating and incrementally improving what was possible with previous methods, and start exploring the qualitatively new things they enable .

The initial impetus for Kangaro­o was to embed in the digital modelling environment the kind of form-finding methods previously explored through real physical models – hanging chains, stretched fabrics and so on.
While this simulation of real physical material properties is still something I will be developing (and there is still much more work to be done here), the direction I find most exciting at the moment, and what I want to talk about today, is digital material behaviour which does 
not directly simulate anything from the real world, yet is nonetheless highly relevant to the design of buildable structures.

When we form-find and design through physical model making, we interact with the behaviour of the material. Depending on its internal structure, the material responds to the forces applied to it in a certain way, generating reaction forces and deforming its shape;
-stretch a spring and it tries to return to its original length,
-push the ends of a flexible rod together, and it buckles into a 
particular curve,
-attach a soap film to a boundary curve, and it
minimizes its surface area,
-crumple a piece of paper, and it bends and folds but with little shear or stretch.
Forms found through interaction with physical materials also impose certain constraints – not everything is possible. Try and force it into a shape which conflicts with its material properties and it resists, pushing back at you, or push it too far and it rips or crumples.
These limitations are an essential guiding part of the design process (and one which is often missing in digital design systems, where with a few clicks we can effortlessly loft a curve into a surface that would deform its intended fabrication material far beyond physical limits).

Of course the models we use for form-finding are usually not simply a scaled down version of the real structure, but involve a level of abstraction. We use materials which are quite different from those we will eventually build with at full scale, but which have key behaviours which give the forms they find geometric properties which will be relevant to their construction in other materials.
Surfaces modelled with paper or card are approximately 
developable (zero Gaussian curvature), which means they can be fabricated from sheet metal without expensive forming processes.
The surfaces found by soap films are useful because they are
minimal (zero Mean curvature), as is useful in a tensioned fabric structure.
Funicular or catenary models are yet another step removed from the final structure – not only are they a different scale and a different material, but we reverse their orientation with respect to gravity to find a form which acts in pure compression, as is suitable for masonry construction.

Nested catenaries project by the Auxiliary Architectures Studio at the Oslo school of Architecture and Design (form found using Kangaroo). Photo by Defne Sunguroğlu Hensel

In the computer we can go much further in these abstractions, creating virtual materials which have no real world analogue. We do not need to limit our form finding to only those geometric properties which have convenient existing modelling materials that maintain them, but can invent new custom materials to maintain a much wider range of possible geometric properties (ones based on ease of fabrication, or structural or environmental performance, or aesthetics…).
I am calling these
pseudo-physical materials – virtual materials with custom rules for how they respond to deformations, which do not correspond to the behaviour of any real material.


A physics engine (in this case Kangaroo) allows us to assign material properties to geometric objects, and then calculates how they interact with each other and any applied forces and constraints. These material properties are created through functions in the physics engine code which use some mathematical rules and variables to calculate what force to react with in response to a given deformation. Conventionally we use known mathematical expressions of physical laws here, such as Hooke’s law for springs.

However, as long as they fit within this general framework (of taking some geometry and numerical variables as input, and outputting some force vectors), the rules for calculating the material’s response can be anything we want – including ones based on purely geometric properties.

For example, we can create a surface made up of triangles and give it the property that these triangles attempt to stay equilateral, though they are free to change in size – something impossible with any known real world materials (perhaps suitably designed auxetic materials might be able to achieve somewhat similar properties, though that is a subject for another time…).

In the physics engine we can explicitly design and specify which geometric properties we want to leave free, which we want to constrain, and how we want to link them.

For form-finding we are usually interested in reaching a stable solution, so it often makes sense to define this material behaviour such that it produces a force which tends towards zero as the object’s shape gets closer to a certain target property. Many optimization techniques work by minimizing certain objective functions. Treating any and all objective functions as energy functionals, and actually simulating this as the potential energy of a physical system – which gets converted into kinetic energy and dissipated through entropy until an equilibrium is reached – makes them much more accessible and intuitive to interact with. Millions of years of evolution have given us brains highly adapted for interacting with physical material systems – so by putting otherwise abstract mathematical properties into this framework, we allow that powerful intuition to be applied to them.

Dealing with everything within the framework of classical dynamics also means that we can easily throw all these different forces and material properties together (combining conventional physical material properties with pseudo-physical ones), and simply add all the force vectors acting on each point in the system, then use the resultant or net force to find the acceleration (via Newton’s 2nd law) of that point.

Many powerful tools for constraint solving and optimization do already exist and are widely used in engineering, but the methods for specifying constraints and targets are often complex, and optimization techniques are often mysterious in how they reach their results, which limits their usefulness in early design.

In cases where the problem can be precisely defined, such as minimizing the weight of a truss subject to stress constraints, this need not be such a problem – as long as it outputs the right result, you don’t need to see how it got there.

But design in general is a much more fuzzy and flexible problem, and sometimes quite open ended. For this sort of design exploration it is better if the optimization process can be seen and controlled while it is running.

Optimum suggests something static and fixed, and in optimization literature metaphors of hill or mountain climbing are often used, with the peak representing the goal – and hills do not generally move as we climb them.

What I find more interesting though, is interactive optimization where the goal is not completely fixed at the start of the process, but the ‘optimum’ is something that can shift according to the changing desires of the designer, which are simultaneously being refined and altered in response to the constant visual feedback provided by the system. Unpredicted and emergent phenomena during this process can even suggest an entirely new goal.

A criticism which has often been levelled at digitally designed architecture over recent decades is that the tools adopted from the software of the animation industry allow wild formal exploration, and the creation of fantastic smoothly curved 3D objects, but without a way of building them at large scale so they stand up, they are somewhat irrelevant or indulgent.
While manufacturing technologies have been catching up, and more of what we create on screen can now be created in the real world, much of it is still expensive to fabricate on a large scale, and only gets applied on a few high profile, high budget buildings, lending further weight to the criticism of architects’ indulgence.

There are various geometric properties which are very important for making forms practical to fabricate that are not easy to maintain with conventional CAD modelling tools, particularly when dealing with complex curved forms.

Quad panels taken from NURBS surfaces and subdivision meshes (the common ways of making curved surfaces in current software) will nearly always be slightly doubly curved. Doubly curved panels are typically something like an order of magnitude more expensive to fabricate than planar ones.
Some sophisticated techniques do now exist for
post rationalizing ‘freeform’ geometry so that it can be fabricated, and with specialist help many of the curved forms created by architects can eventually be panelized, but this is a complex process, constrained by what is geometrically possible, and meeting demands such as planarity and number of panels and surface smoothness will often require some modification of the design.

This separation of geometric constraints from the main design process seems to me a slightly bizarre situation. NURBS and subdivision technologies are powerful and well developed for applications such as vehicle/product design and animation/rendering, but if we need these additional highly complex techniques for converting and post rationalizing the models we produce with them before they become buildable then they are not really working for architects as well as they should.

I believe the term ‘freeform’ is often rather a misnomer. Tools such as NURBS modelling constrain and guide the shapes created with them in all sorts of ways – it’s just that those constraints are a mismatch with those needed for many large scale construction techniques.

I propose pseudo-physical digital materials as a possible way of remedying this situation.
No modelling technology is neutral or ‘free-form’ – as soon as the form moves from the designer’s mind to paper, screen or physical model, the tool being used starts to play a role in shaping the design (and I would argue that even in the designers mind, the tools they are habituated to shape their intuition and the forms they are able to conceive).

Let us acknowledge and embrace this and look not just for modelling tools which give us the freedom to design anything, but rather tools which will intelligently and responsively constrain the shapes we create with them, so that the virtual model is shaped by what works for structure and fabrication.
Far from stifling design, I believe the constraints pseudo-physical materials impose, and the way they adjust themselves in response to our manipulations could suggest exciting new formal languages.

Special thanks to the following, with whom I have had many enjoyable conversations over recent months that were helpful in the development of these ideas:

Helmut Pottman, Mark Pauly, Daniel Hambleton, Niloy Mitra, Yongliang Yang, Harri Lewis, Tomohiro Tachi, Lars Hesselgren, Hugh Whitehead, Giulio Piacentino(thanks also for his plugin WeaverBird, which was used in many of the videos above), Dimitri Demin, Matthias Nieser, Felix Kälberer, Philippe Block, Lorenz Lachauer, Adrià Bassaganyes, Mathias Gmachl, Kristoffer Josefsson, Jonathan Rabagliati, Daniel Davis, Enrique Soriano, Pep Tornabell, Sam Joyce, Al Fisher, Chris Williams, Robert Aish, Jose Luis Garcia del Castillo y Lopez, Anders Holden Deleuran, Gennaro Senatore, Matthias Kohler, Marc Syp

I’m happy to announce that this year’s SmartGeometry conference in Copenhagen in March will feature a 4 day workshop cluster ‘Use the Force’ exploring the use of Kangaroo as a form-finding tool, and linking it to real-time sensor input.
I think this is a unique and very exciting opportunity to come together to develop, test and really push the boundaries of what is possible with these design tools.

The cluster will be lead by myself (Daniel Piker), Robert Cervellione and Andrew Payne (developer of the Firefly plugin).

The deadline for applications to the workshops has been extended until this Sunday 6th Jan
read more about it and apply here.

I am very pleased to announce that Robert Cervellione has nearly finished porting the Kangaroo Physics engine to work with Generative Components.
To read more and see some videos, visit CERVER.org

I’m excited to see how it gets used in this different software environment.
Thank you Robert!
Development for both the GC and GH versions will continue in parallel.

Also coming soon – a new version of Kangaroo for GH, and a first draft of the (long awaited) manual.