Building unimaginable shapes

Inspired by cell division, Michael Hansmeyer writes algorithms that design outrageously fascinating shapes and forms with millions of facets. No person could draft them by hand, but they're buildable -- and they could revolutionize the way we think of architectural form.

As an architect, I often ask myself,

what is the origin of the forms that we design?

What kind of forms could we design

if we wouldn't work with references anymore?

If we had no bias, if we had no preconceptions,

what kind of forms could we design

if we could free ourselves from

our experience?

If we could free ourselves from our education?

What would these unseen forms look like?

Would they surprise us? Would they intrigue us?

Would they delight us?

If so, then how can we go about creating something that is truly new?

I propose we look to nature.

Nature has been called the greatest architect of forms.

And I'm not saying that we should copy nature,

I'm not saying we should mimic biology,

instead I propose that we can borrow nature's processes.

We can abstract them and to create something that is new.

Nature's main process of creation, morphogenesis,

is the splitting of one cell into two cells.

And these cells can either be identical,

or they can be distinct from each other

through asymmetric cell division.

If we abstract this process, and simplify it as much as possible,

then we could start with a single sheet of paper,

one surface, and we could make a fold

and divide the surface into two surfaces.

We're free to choose where we make the fold.

And by doing so, we can differentiate the surfaces.

Through this very simple process,

we can create an astounding variety of forms.

Now, we can take this form and use the same process

to generate three-dimensional structures,

but rather than folding things by hand,

we'll bring the structure into the computer,

and code it as an algorithm.

And in doing so, we can suddenly fold anything.

We can fold a million times faster,

we can fold in hundreds and hundreds of variations.

And as we're seeking to make something three-dimensional,

we start not with a single surface, but with a volume.

A simple volume, the cube.

If we take its surfaces and fold them

again and again and again and again,

then after 16 iterations, 16 steps,

we end up with 400,000 surfaces and a shape that looks,

for instance, like this.

And if we change where we make the folds,

if we change the folding ratio,

then this cube turns into this one.

We can change the folding ratio again to produce this shape,

or this shape.

So we exert control over the form

by specifying the position of where we're making the fold,

but essentially you're looking at a folded cube.

And we can play with this.

We can apply different folding ratios to different parts

of the form to create local conditions.

We can begin to sculpt the form.

And because we're doing the folding on the computer,

we are completely free of any physical constraints.

So that means that surfaces can intersect themselves,

they can become impossibly small.

We can make folds that we otherwise could not make.

Surfaces can become porous.

They can stretch. They can tear.

And all of this expounds the scope of forms that we can produce.

But in each case, I didn't design the form.

I designed the process that generated the form.

In general, if we make a small change to the folding ratio,

which is what you're seeing here,

then the form changes correspondingly.

But that's only half of the story --

99.9 percent of the folding ratios produce not this,

but this, the geometric equivalent of noise.

The forms that I showed before were made actually

through very long trial and error.

A far more effective way to create forms, I have found,

is to use information that is already contained in forms.

A very simple form such as this one actually contains

a lot of information that may not be visible to the human eye.

So, for instance, we can plot the length of the edges.

White surfaces have long edges, black ones have short ones.

We can plot the planarity of the surfaces, their curvature,

how radial they are -- all information that may not be

instantly visible to you,

but that we can bring out, that we can articulate,

and that we can use to control the folding.

So now I'm not specifying a single

ratio anymore to fold it,

but instead I'm establishing a rule,

I'm establishing a link between a property of a surface

and how that surface is folded.

And because I've designed the process and not the form,

I can run the process again and again and again

to produce a whole family of forms.

These forms look elaborate, but the process is a very minimal one.

There is a simple input,

it's always a cube that I start with,

and it's a very simple operation -- it's making a fold,

and doing this over and over again.

So let's bring this process to architecture.

How? And at what scale?

I chose to design a column.

Columns are architectural archetypes.

They've been used throughout history to express ideals

about beauty, about technology.

A challenge to me was how we could express

this new algorithmic order in a column.

I started using four cylinders.

Through a lot of experimentation, these cylinders

eventually evolved into this.

And these columns, they have information at very many scales.

We can begin to zoom into them.

The closer one gets, the more new features one discovers.

Some formations are almost at the threshold of human visibility.

And unlike traditional architecture,

it's a single process that creates both the overall form

and the microscopic surface detail.

These forms are undrawable.

An architect who's drawing them with a pen and a paper

would probably take months,

or it would take even a year to draw all the sections,

all of the elevations, you can only create something like this

through an algorithm.

The more interesting question, perhaps, is,

are these forms imaginable?

Usually, an architect can somehow envision the end state

of what he is designing.

In this case, the process is deterministic.

There's no randomness involved at all,

but it's not entirely predictable.

There's too many surfaces,

there's too much detail, one can't see the end state.

So this leads to a new role for the architect.

One needs a new method to explore all of the possibilities

that are out there.

For one thing, one can design many variants of a form,

in parallel, and one can cultivate them.

And to go back to the analogy with nature,

one can begin to think in terms of populations,

one can talk about permutations, about generations,

about crossing and breeding to come up with a design.

And the architect is really, he moves into the position

of being an orchestrator of all of these processes.

But enough of the theory.

At one point I simply wanted to jump inside

this image, so to say, I bought these red and blue

3D glasses, got up very close to the screen,

but still that wasn't the same as being able to

walk around and touch things.

So there was only one possibility --

to bring the column out of the computer.

There's been a lot of talk now about 3D printing.

For me, or for my purpose at this moment,

there's still too much of an unfavorable tradeoff

between scale, on the one hand, and resolution and speed, on the other.

So instead, we decided to take the column,

and we decided to build it as a layered model,

made out of very many slices, thinly stacked over each other.

What you're looking at here is an X-ray

of the column that you just saw, viewed from the top.

Unbeknownst to me at the time,

because we had only seen the outside,

the surfaces were continuing to fold themselves,

to grow on the inside of the column,

which was quite a surprising discovery.

From this shape, we calculated a cutting line,

and then we gave this cutting line to a laser cutter

to produce -- and you're seeing a segment of it here --

very many thin slices, individually cut, on top of each other.

And this is a photo now, it's not a rendering,

and the column that we ended up with

after a lot of work, ended up looking remarkably like the one

that we had designed in the computer.

Almost all of the details, almost all of the

surface intricacies were preserved.

But it was very labor intensive.

There's a huge disconnect at the moment still

between the virtual and the physical.

It took me several months to design the column,

but ultimately it takes the computer about 30 seconds

to calculate all of the 16 million faces.

The physical model, on the other hand,

is 2,700 layers, one millimeter thick,

it weighs 700 kilos, it's made of sheet that can cover

this entire auditorium.

And the cutting path that the laser followed

goes from here to the airport and back again.

But it is increasingly possible.

Machines are getting faster, it's getting less expensive,

and there's some promising technological developments

just on the horizon.

These are images from the Gwangju Biennale.

And in this case, I used ABS plastic to produce the columns,

we used the bigger, faster machine,

and they have a steel core inside, so they're structural,

they can bear loads for once.

Each column is effectively a hybrid of two columns.

You can see a different column in the mirror,

if there's a mirror behind the column

that creates a sort of an optical illusion.

So where does this leave us?

I think this project gives us a glimpse of the unseen objects that await us

if we as architects begin to think about designing not the object,

but a process to generate objects.

I've shown one simple process that was inspired by nature;

there's countless other ones.

In short, we have no constraints.

Instead, we have processes in our hands right now

that allow us to create structures at all scales

that we couldn't even have dreamt up.

And, if I may add, at one point we will build them.

Thank you. (Applause)