I recently watched this talk on generative art by @wblut, a fellow Belgian generative artist whose work I really appreciate and enjoy. A very interesting and inspiring talk on generative art in general with some insights and examples of how he approaches his work. A talk I can definitely recommend, so here it is:

<iframe width="560" height="315" src="https://www.youtube.com/embed/L-k9NneqsHQ?si=UXKmftc3ZHvreGEI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

The one thing that strongly resonated with me was how in generative art you don't exactly start with an idea of what the final piece is going to look like. In stead it start with a curiosity about a certain topic and then exploring the concepts or systems that its made up of. Or to summarize, I guess you could say generative art is a curious exploration. A way of thinking about generative art as a medium that I hadn't really before, but I definitely felt like there was something there.

So then, a few days later, I'm scouring OpenProcessing to find some interesting sketches that I could use for a live A/V performance I'm working on (soon more about that! drop your email if you want to stay posted ;). I soon came across this sketch mimicking the ripples on a water surface (click & drag the screen to see the ripples):

<iframe src="https://openprocessing.org/sketch/1678058/embed/?plusEmbedHash=0b26191d&userID=362930&plusEmbedTitle=true&show=sketch"></iframe>

A very simple algorithm that beautifully mimics ripples on a water surface. Basically in every step, every pixel that is white will propagate to the pixels around it. In the original code this looks like:

for (int i = 1; i < cols-1; i++) {
    for (int j = 1; j < rows-1; j++) {
      current[i][j] = (
        previous[i-1][j] + 
        previous[i+1][j] +
        previous[i][j-1] + 
        previous[i][j+1]) / 2 -
        current[i][j];
      current[i][j] = current[i][j] * dampening;
      int index = i + j * cols;
      pixels[index] = color(current[i][j]);
    }
  }

I quickly got interested to find out what would happen if, instead of activating just one pixel at the time, I could light up a whole range of pixels. Or a specific shape. And what better shape than a circle? Click/tap a few times on my forked version here and see what happens:

<iframe src="https://openprocessing.org/sketch/2229886/embed/?plusEmbedHash=8c78297c&userID=362930&plusEmbedTitle=true&show=sketch"></iframe>

Isn't that amazing? Out of nothing these crazy patterns emerge. I had never planned this. But yet here I find myself. Staring at funky patterns and wondering what else I can make this algorithm do... That exploration is still ongoing, but for now I'll leave you with one last still from the version of this sketch in my creative coding playground:

Until next time! x