For me this project started when fx(hash) announced fxhackathon, a hackathon/competition that challenges artists to make use of a newly introduced feature: code-driven parameters.

This new feature makes it possible for artists to create their own interfaces for their works. No longer limited to the typical sliders of the params() interface, I tried to think of possible interactions that would feel more natural and fitting to a generative work.

The three nodes

From the start I knew I wanted to keep the amount of interface elements to a minimum. I started to think about how with three nodes you could influence a number of elements in an intuitive way.

Maybe intuitive is not the right word for how things turned out.

Each of the nodes controls the dimension and position of several elements. Some relations are straightforward, others are less obvious. For example the size of the circle is decided by the distance of the second node to the center of the image.

What I found was that even though some of the inner workings might not immediately be clear, the interaction as a whole felt very rich. Moving a single node can change the composition drastically and it felt joyful to play around with the system and slowly get a feel for it.

The two views

From early on in the project I felt it would be good to separate the composing from the rendering. I created the nodes view for interacting with the overall composition. And the render view for trying out color palettes and decoration variants.

This was also partially done to prevent a laggy interaction while dragging around the nodes. I expected the work to get complex enough that rendering it continuously would slow things down.

Decoration

With the basic surfaces now in place it was time to decorate them. I wanted to go for bold with a lot of contrast and movement.

And bold they were.

I was very pleased with the strong shapes and the pleasant chaos brought by the overlapping segments, but I wanted more detail and maybe even more chaos. I was looking for a bigger contrast between the underlying structure and the final outcome.

I added a small chance for elements to be slightly transparent, adding some depth to the whole.

I always enjoy iterating on the color palette throughout a project. Slowly getting a feel for what works and what not. This time I even dared to get an orange in.

At this point I was happy that the work allowed for both very chaotic overloaded outputs and ones that kept the base shapes recognisable with more of the background visible. But I felt that how the colors were arranged was too random at the moment. It lacked some structure.

Also these very minimal outputs made me want to see more of that combined with the abundance of the others.

The fader node

Though I was very happy with having only three nodes to control the whole composition, I decided to add one more. This one doesn't control the shapes, but instead changes the distribution of colors. Creating some sort of fade to the background.

In addition to creating a more deliberate color distribution, the fader node also helps with balancing a composition. It felt like a useful tool to have and having four nodes in total didn't feel overly complex.

Colors

All colors in this work stem from one base palette of 14 colors. The white and black appear twice in the palette so we are left with 12 unique colors.

Every time the color palette is generated, between 3 and 11 colors are picked from the base palette. And since white and black can be picked twice, there is a chance of having a monochrome palette.

I like that this system is simple enough so that people roughly understand what is going on just by trying out new palettes. At the same time it is complex enough to allow for many different combinations. So many that I can still get surprised even after having seen so many already.

And that brave orange that I added early in the process? It slowly turned red, but then almost at the end of development I added one last color, a more subtle orange, named coral.

Final thoughts

Generative art is in essence always about constraints. How much freedom can one give the system? When the artist allows someone else to control parameters, the question becomes how much freedom to give this person?

I believe that too much freedom doesn't help, but instead can be overwhelming. Limiting the amount of parameters that can be controlled, means that those parameters can be explored more in depth.

The level of complexity that people enjoy exploring is not the same for everyone, but systems with many variables easily become overly complex. With this work I want to offer something manageable, something you can finish, that allows you to feel you have explored enough. That you craft a version knowing this is the one for you. That there is closure.