For Study 003, I wanted to move away from using code to create the finished image.
Instead, the computer would simply tell me what to do.
The Processing sketch creates an invisible square grid. Each position in the grid is randomly assigned one of seven possible instructions:
.↓ Colour 1 / down
..↓ Colour 2 / down
...↓ Colour 3 / down
.→ Colour 1 / right
..→ Colour 2 / right
...→ Colour 3 / right
blank No mark
The number of dots tells me which of three brush pen colours to use, while the arrow tells me whether to make the mark horizontally or vertically.
That’s all the computer decides.
Random within rules
Unlike the previous two studies, there isn’t a mathematical relationship between one grid position and the next.
Processing randomly chooses from the seven possible outcomes:
int outcome = int(random(7));
This means every generated sheet is different, but the randomness is still tightly controlled. The computer can only choose from the rules I’ve given it.
Adding the blank or null instruction turned out to be particularly important. Without it, every position had to contain a mark and the results became very dense. Empty cells introduce gaps and allow irregular areas of white space to form naturally.
From code to paper
I printed the generated instructions onto A4 paper in a very light grey and then worked through the grid by hand with three brush pens.
This is where the computer loses control.
The algorithm determines the colour, position and direction, but it can’t determine exactly how I make the mark. Pressure changes. Lines aren’t perfectly straight. Some strokes are wider than others. Colours behave differently on the paper.
Repeating the same generated process with different sets of three colours also produces surprisingly different results.
What starts as a rigid grid of random computer instructions becomes something much less precise once it’s interpreted by hand.
For me, that’s the interesting part of this study: the code creates the rules, randomness creates the composition, and the hand creates the final image.
Finding generative inspiration in an evening of sound, sea and code.
On a warm Saturday evening I found myself lying on the beach, listening to the sound of Tibetan singing bowls as the sun disappeared over the horizon. It’s not something I’d ever done before, and if you’d asked me a year ago if I’d spend an evening at a beach sound bath, I’d probably have said no. I’m glad I did.
There was something fascinating about hearing the bowls live. The tones didn’t feel like they travelled in perfect circles; they seemed to bend, overlap and interfere with one another as they drifted across the beach. Looking around, everyone was scattered naturally across the sand, each person having their own quiet experience while all sharing the same source of sound.
That stayed with me long after the evening had finished.
Turning a memory into code
Rather than recreating the event literally, I wanted to capture the feeling of it.
The piece starts from a simple aerial view. People become nothing more than small circles. The Tibetan bowls are reduced to three outlined rings. Everything else is generated procedurally.
Clicking and holding one of the bowls allows it to “charge”. Releasing the mouse sends a wave travelling outwards. As those waves reach people sitting around the bowls, they begin to emit their own smaller ripples, creating a constantly changing network of responses.
The result isn’t intended to be physically accurate. It’s more like a visual interpretation of shared resonance.
Inspired by the beach
The first colour palette came directly from photographs I took that evening.
Soft golden sand, fading evening blues and warm sunset yellows became the foundation of the artwork. Those colours appear only in the waves, while the people and bowls remain simple white forms. Keeping the geometry minimal lets the movement become the focus.
As the project developed, two additional modes emerged:
Beach – warm sand tones with colourful waves inspired by the evening sky.
Paper & Ink – reducing everything to black lines on textured paper, giving the piece the feel of a hand-drawn print.
Night – a dark background with softly glowing coloured waves, creating a more meditative atmosphere.
Each mode changes the mood of the same underlying simulation without changing the behaviour.
Building the interaction
The sketch is written in Processing (Java) and is entirely interactive.
Rather than looping through a fixed animation, the user creates the experience by interacting with the bowls. Holding a bowl increases its energy before releasing expanding waves that trigger reactions from nearby participants.
Those reactions then become part of the composition, with multiple wave systems overlapping and slowly fading away. Every interaction produces a slightly different arrangement.
What I enjoyed most
This project reminded me that inspiration doesn’t always come from galleries, books or websites.
Sometimes it’s simply being somewhere unfamiliar, experiencing something for the first time, and noticing the patterns your brain keeps replaying afterwards.
I never expected a Saturday evening listening to Tibetan singing bowls on a beach to become the basis for a generative artwork, but that’s exactly why I enjoy working with code. It gives me a way to translate memories and experiences into something visual, interactive and constantly evolving.
Using Java, live microphone input and three-dimensional forms to create a visual response to bird song.
I wanted to explore how bird calls could be translated into something visual using code.
The finished Processing sketch listens through the computer’s microphone, analyses the incoming frequencies and uses them to control a grid of transparent 3D boxes. As the sounds change, the depth, rotation and colour of the boxes change with them.
The idea
The starting point was a simple question: what might a bird call look like?
I did not want to draw the bird itself or display the sound as a conventional waveform. Instead, I wanted the audio to control a collection of geometric forms.
I chose transparent keyline boxes because they could respond in several ways without becoming too visually heavy. Each box can change its depth, position, rotation and colour, allowing the grid to develop into a constantly changing three-dimensional structure.
The inspiration
Bird calls contain a surprising amount of variation. Some are short and sharp, while others are slower, lower or more repetitive.
I wanted to use these differences as data rather than trying to recreate the sound literally. The code establishes a set of visual rules, but the bird calls determine what happens within them.
This creates a balance between a controlled system and the unpredictable nature of a live recording.
The process
The project was created in Processing using Java and the Processing Sound library.
The sketch accesses the computer’s default microphone and listens to the surrounding environment in real time. It separates the incoming sound into low, middle and high-frequency ranges before applying those values to the grid.
Middle frequencies control much of the general activity.
Higher frequencies respond to sharper calls and details.
Overall volume controls the strength of the reaction.
Frequency levels also influence the keyline colours.
The audio values are smoothed before they reach the visual system. Without this, every small change in the microphone signal would make the boxes jump too abruptly.
The microphone sensitivity is set for normal recording levels and can be adjusted while the sketch is running. The code also measures the general background noise, helping the visual response remain useful in different environments.
Development
Stage one: using recorded audio
The first version used a saved audio file.
This was helpful during development because I could replay the same sound while adjusting the frequency ranges and testing how the boxes responded.
It confirmed that the basic idea worked, but every result was tied to the same recording.
Stage two: using a live microphone
I replaced the audio file with live input from the computer’s microphone.
This made the project feel much more immediate. The visual structure now responds to whatever is happening around it at that particular moment.
A quiet environment creates a restrained arrangement of boxes. Bird calls produce sharper movements and changes in colour, while voices, music and other background sounds create entirely different results.
Stage three: refining the boxes
During development, I experimented with solid shapes and smaller blocks placed inside the main boxes.
These versions became visually heavy and distracted from the overlapping structure. I returned to transparent cuboids drawn entirely with coloured keylines.
Because the boxes have no filled surfaces, their edges remain visible through one another. This creates a more complex sense of depth while keeping the individual forms simple.
Stage four: tuning the response
One of the most difficult parts was finding the right microphone sensitivity.
If the response was too low, quieter calls produced very little movement. If it was too high, normal background noise caused the whole grid to react constantly.
I added adjustable sensitivity and background-noise detection so the sketch could respond more naturally in different recording conditions.
The outcome
The finished project is a live visual interpretation of bird calls and the surrounding soundscape.
Every result is created from the same grid and the same set of rules, but the composition changes depending on what the microphone hears.
The structure can also be rotated using the mouse, making it possible to explore the generated forms from different angles. The animation can be paused when an interesting arrangement appears.
What I learned
This project showed me that audio does not need to be represented as a waveform.
By dividing the microphone input into frequency ranges, I could use a single sound source to control several visual properties at once. Depth, rotation, movement and colour can all respond differently while remaining connected to the same recording.
I also found that simpler forms created the strongest results. Removing the solid surfaces made the overlapping lines and three-dimensional structure much easier to see.
Most importantly, the project demonstrated how code can translate something temporary, such as a bird call, into a visual experience.
What’s next?
I would like to test the project with different bird species and compare the visual results.
Each species has its own rhythm, pitch and pattern of calls, so it would be interesting to see whether these differences create recognisably different structures.
I would also like to experiment with recordings made in different habitats and at different times of day. A woodland at dawn should produce a very different response from a garden, wetland or urban environment.
Another possibility would be to improve the frequency detection so the sketch can react more precisely to individual calls while ignoring unrelated background noise.
Final thoughts
This began as an experiment in making bird song visible through code.
Java provides the rules, the microphone supplies the data and the surrounding sounds create the changing composition. Although the visual system remains consistent, the result is never quite the same twice.
I like that the project does not attempt to illustrate a bird or reproduce its call literally. Instead, it creates a visual response to the rhythm, frequency and energy of the sound.
