Six Grasshopper exercises that could be buildings

These are exercises I did while learning Grasshopper. None of them is a building. All of them could be, and that's exactly the point I want to make here.

They're geometric figures: a lattice, some rotating ribs, a relief built from an image. Sitting in a folder they look like coursework, nothing more. But each one is a written rule, and a written rule can be scaled, deformed and applied to a real commission. In parametric architecture I covered where this way of working comes from; here I show what it looks like when you're just learning.

A lattice that started as random points

A Voronoi diagram divides a plane into cells: each cell holds everything closer to one point than to any other. It's the pattern of soap bubbles, of a turtle shell, of cracked dry soil. Here I projected it onto a curved surface and used the cells to perforate it.

Look at it for two seconds and it stops being an exercise: it's a façade screen, a brise-soleil, a perforated ceiling. And since it's parametric, cell density can respond to something —the sun on that face, the privacy the room behind needs— instead of being a fixed drawing.

Ribs that follow a curve

This is one of the simplest and most useful: you take a section, repeat it along a curve and rotate it as you go. That's it. The result reads as a ring of ribs.

It's literally the logic of a laminated timber rib structure, of a pavilion, of an acoustic ceiling. Change the curve and the whole pavilion changes; change the rotation and the light between pieces changes. Nobody drew eighty ribs: one was drawn and its path described.

When geometry reads an image

Here the exercise got personal: I used the logo of Winteri, the practice I was a partner in for years. The Image Sampler component reads an image and returns a number for each point on a grid —that pixel's brightness—. I used that number as the height of each hexagon.

The result is the logo turned into relief. It sounds like a game, but it's the same principle behind façades that respond to a data map: instead of a logo, the image can be a map of solar radiation, views or noise, and the height can be the depth of a shading fin. Geometry stops inventing and starts reading information.

A wall that comes apart at the bottom

This exercise is about data structures, the least glamorous and most important part of Grasshopper. The boxes are organized in a data tree, and by splitting it into branches you can treat each group differently: the top ones stay aligned, the bottom ones scatter and pull apart.

As an image, it's a wall that opens progressively toward the ground. But look again: it could just as easily be an apartment building facing the beach, terraces offsetting so none blocks another. Or it could be street furniture, at the scale of someone sitting on it.

That shift in scale isn't in the geometry, it's in the trained eye. The same form can be a park bench or a building where people live, and being able to see that is exactly what separates a shape from a project. The tool produces the figure; the architect decides how big it is and who it's for.

And one where the computer searches for the answer

This one isn't descriptive geometry anymore: it's optimization. The central massing positions itself relative to tension points in its surroundings —the neighboring buildings— and Galapagos, Grasshopper's evolutionary solver, tries thousands of combinations until it finds the one that best meets the condition I defined.

It's the same mechanism I use today on real projects to orient a building by visibility or sunlight, which I write about in Data Driven Design. The difference between this exercise and a commission is the quality of the question, not the tool.

All of this runs on three sliders

This vault of arcs and beams is the clearest example of why it's worth it. On the right there are three sliders: arc count, radius and spacing. Move one and the entire structure rebuilds itself, every piece coordinated.

If this were drawn by hand, changing the number of arcs would mean redoing the drawing. Here it's dragging a control. That's the whole difference, and it's enormous when the client asks to see three alternatives by Thursday.

From exercise to built building

So this doesn't stay a lab exercise, it's worth looking at where it ends up. Little Island, by Heatherwick Studio, is a park over the Hudson River held up by 132 prefabricated concrete pots shaped like tulips. No two are alike.

That's the catch: prefabrication normally demands repetition, and this project had none. Arup's engineers used parametric algorithms to resolve the concrete thickness of each pot and the geometry of the steel joints, piece by piece. Without that model, the project would have been impossible to fabricate at a reasonable cost.

If you want more built examples, ArchDaily gathered twelve parametric façades that show the range well: from purely formal patterns to skins that respond to climate.

Will AI replace the architect?

It's the question I get most, almost always with some fear behind it. My answer is no, and not out of optimism: because of how this actually works in practice.

Every exercise above has one thing in common: someone decided what was being looked for. The Voronoi doesn't know it's a façade screen. Galapagos doesn't know what a good building is, it only optimizes the condition I wrote. When the result is interesting it's because the question was well posed, and when it's a disaster —it's happened to me— it's because the question was wrong.

The tool doesn't know what a good project is. It knows how to meet the condition you gave it.

What has changed, a lot, is the barrier to entry. A few years ago building these algorithms meant wrestling with the program's logic for weeks. Today you can describe what you want in plain language and ask for help building it. That doesn't replace us: it pulls us out of the technical draftsman role and returns us to the architect's, which is making decisions.

I wrote it in parametric architecture and I'll repeat it here: we already went through this with CAD and with BIM. Each time, mechanical work disappeared, not judgment.

Where to start, if this got you curious

These are the three courses I took and recommend, in the order they served me:

1. 3D modeling with Grasshopper in Rhinoceros, on Domestika. The friendliest way in: short, visual and enough to grasp the node logic. It's in Spanish.
2. Parametric design specialization: Rhinoceros, Grasshopper and Archicad, on Arcux. This is where the jump happens: most of the exercises in this article came out of it, and it adds the Archicad connection, which is what makes it useful in a BIM office. In Spanish.
3. The Ultimate Rhino 3D & Grasshopper Course, on Udemy. The most extensive one, good as a reference to come back to when you get stuck on something specific.

You need Rhino, which has shipped with Grasshopper since version 6. And one piece of advice: don't start with your office's project. Start with a geometric figure with no purpose, like these. It's much easier to understand a concept when there's no deadline on top of you.