Scott Pollard — Design, Code & Art

Category: Print & Physical

Posters, prints, exhibitions, sculptures and tangible outcomes.

Pidge: making a little bit of street art

Pidge started as one of those ideas that didn’t really have a grand plan behind it.

I wanted to make a character. Something simple, physical and a little bit scruffy. Something that could exist away from a screen.

And eventually, Pidge appeared.

From an idea to an actual object

I’ve always liked making things.

A lot of my day-to-day work involves websites, design and things that ultimately exist on a screen. Personal projects give me an excuse to go in completely the opposite direction and make something physical.

Pidge is part character design, part sculpture, part street art and probably part toy.

The basic shape is deliberately simple. There’s something vaguely pigeon-like about him, but he’s also just a strange little character with big feet, a blank expression and not much enthusiasm for whatever is happening around him.

That expression became quite important.

He always looks slightly unimpressed.

Making the Pidges

Rather than making a single Pidge, I wanted to be able to create variations.

The original was made as a 3D model, which then gave me a physical form I could work from. From there I made my own silicone moulds and started casting them.

That’s probably one of my favourite parts of projects like this.

There’s a process.

Design something digitally. Print it. Make a mould. Cast it. Paint it. Photograph it.

Each stage changes the thing slightly.

The casts aren’t supposed to be absolutely perfect either. Small marks, textures and imperfections actually help. Once they’re painted, splattered, drawn on and covered in tiny bits of graffiti, those imperfections become part of the character.

I don’t really want them to look mass-produced.

Quite the opposite.

Giving each one an identity

The basic Pidge might be the same, but each finished character is different.

Different hats. Different colours. Different tags. Stickers. Scribbles. Paint splatters. Little references and marks.

I’ve treated the surface almost like a tiny wall somewhere in a city.

Things overlap.

Some bits are neat. Some aren’t.

New marks cover old ones.

There isn’t really a strict design system governing where everything goes. I prefer letting each one develop as I’m making it.

It means they end up feeling related without being identical.

A little Pidge crew.

Taking them outside

The project became much more interesting when I started photographing them away from home.

Instead of photographing them against a clean backdrop, I’ve been taking them into places that feel like they belong there.

Concrete.

Graffiti.

Underpasses.

Tower blocks.

Wet pavements.

Old brick buildings.

Suddenly the scale becomes slightly ambiguous.

A little cast character sitting on a concrete wall can almost look like it has always been there. Photographing them from close to ground level exaggerates that even further.

That’s become as much a part of the project as making the actual Pidges.

I’m not just making an object and documenting it.

I’m putting a character into an environment and photographing the little scene that happens as a result.

Why pigeons?

I’ve always loved pigeons.

They’re everywhere, particularly in towns and cities, but we barely notice them.

They’re scruffy, adaptable and surprisingly full of character.

They also seem appropriate for something influenced by graffiti and urban environments. A pigeon doesn’t need permission to be somewhere. It just turns up.

Pidge has ended up feeling much the same.

No real destination

I’m deliberately not trying to work out what Pidge needs to become.

It doesn’t need to become a product.

It doesn’t need a complicated story.

And it definitely doesn’t need a five-year brand strategy.

For now I like making them, experimenting with different finishes and taking them out to find places to photograph them.

That’s enough.

There will probably be more Pidges.

And they’ll probably continue looking completely unimpressed about it.

August 17, 2026
Ten Heartbeats and an Eclipse

There’s something quite nice about watching a solar eclipse through a Pringles tube.

For all the technology we have around us, our preparations for the eclipse involved raiding the recycling and making pinhole viewers from cereal boxes and Pringles tubes. Very similar, really, to the sort of thing I remember doing at school in the 90s.

We’d planned a fairly secluded spot to watch it from, only to discover that a few other people had apparently had exactly the same idea.

That actually made the evening better.

We met some like-minded people, compared our slightly questionable homemade viewing contraptions and then stood around together waiting for the Moon to move across the Sun.

It got me thinking afterwards about the experience of an eclipse beyond simply seeing it.

What if you could see how people reacted?

The eclipse is obviously a huge visual event, but there’s another part of it that you can’t see.

Anticipation.

Excitement.

The strange change in light.

Waiting for the right moment.

And, potentially, the physiological response to all of that.

That led to another little generative art experiment.

What if ten people watching an eclipse recorded their heart rates, and those heartbeats became the eclipse’s corona?

Rather than creating a conventional graph showing beats per minute over time, I wanted the data to become part of the artwork itself.

Ten people. Ten heart rates. One Eclipse.

The piece is being developed in Processing.

At the centre is a simple representation of the eclipse: a black disc surrounded by a thin, warm edge of light.

Behind it are ten separate circular systems.

Each person gets their own complete 360-degree layer made from hundreds of fine radial lines. Every layer has its own colour, pattern and heart rate, but they’re all positioned around exactly the same point.

So you don’t immediately see ten separate data visualisations.

You see one.

The layers overlap, interfere with each other and occasionally align, creating something resembling a colourful solar corona.

The important difference is that the corona is being generated by people.

Turning a heartbeat into movement

I didn’t want the heart-rate data to simply control the height of the lines.

That felt too much like an audio equaliser.

Instead, each heartbeat creates an event.

The radial lines slowly push away from the eclipse, reach their maximum extension and then ease back towards it.

I’ve deliberately exaggerated and slowed this movement. A literal visual representation of a heartbeat becomes incredibly frantic when ten people are running simultaneously.

The data determines when something happens, but the artwork determines how that event feels.

So each beat becomes more of a swell:

rest → expansion → peak → decay

At the peak of a pulse, fragments also begin to escape from the ends of the lines.

These become tiny particles travelling away from the centre before slowly disappearing.

I like the idea that the lines represent the immediate physical response, while the particles leave behind a temporary memory of what has already happened.

Stacked, not divided

One decision that became important quite early was how to represent the ten participants.

The obvious solution would be to divide the circle into ten sections, giving everyone a 36-degree slice.

But that would turn the artwork into a diagram.

Instead, all ten people occupy the entire circle.

Their layers are stacked.

Person one can pulse across all 360 degrees. So can person two, person three and everyone else.

Their heartbeats are also staggered, so the layers continually move in and out of phase with one another.

Every so often several beats might happen at almost the same moment and create a much larger burst.

Those moments aren’t specifically animated or programmed.

They’re coincidences in the data.

And that’s probably one of my favourite parts of the idea.

Compressing an eclipse into sixty seconds

I don’t want the final piece to run for the actual duration of the eclipse.

Instead, the recorded heart-rate data would be compressed into roughly one minute.

The beginning of the observation becomes the beginning of the animation. Maximum eclipse sits somewhere within that timeline, followed by the gradual return towards normality.

That gives the finished piece its own beginning, middle and end.

It also raises an interesting question.

Will anything actually happen at maximum eclipse?

It would be very easy to artificially make that moment enormous — more particles, longer lines, brighter colours.

But that would defeat the point.

If everyone’s heart rate increases as the eclipse approaches maximum, the artwork should naturally become more energetic.

If everyone’s heart rate remains relatively unchanged, then that’s what the artwork should show.

The interesting bit is finding out.

Building an instrument rather than a fixed animation

While developing it, I’ve also added a control panel to the Processing sketch.

I can adjust the pulse duration, strength, radial density, line thickness, particle speed, particle lifetime, eclipse size, glow, layer spacing and overall playback speed while the artwork is running.

This has become quite important.

There isn’t really a calculation that tells me a heartbeat should produce a line exactly 126 pixels long or that a particle should survive for precisely 140 frames.

Those are visual decisions.

The data provides the structure, but there’s still a process of designing how that data is interpreted.

Being able to move a slider and watch all ten systems respond immediately makes the Processing sketch feel less like a finished animation and more like an instrument for exploring the idea.

From a Pringles tube to Processing

That’s probably what I like most about this little project.

It started with something incredibly analogue.

A cardboard tube. A cereal box. A tiny hole. Sunlight projected onto a piece of card.

The same basic method of observing an eclipse that I remember from being younger.

Then there we were, years later, standing outside with our homemade viewers and a few people we’d only just met, all looking at the same event.

Now I’m taking that experience back to the computer and asking what else could have been recorded.

Not just what did the eclipse look like?

But:

What did it feel like to be there?

And could ten tiny streams of biological data turn that feeling into something we can see?

That’s what I want to find out next.

August 13, 2026
Gold, Sediments, Waves and Oil
Sometimes an idea for a generative art project starts with data, a mathematical rule or something I’ve deliberately gone looking for.

This one started with an ornament sitting on my desk.

It’s one of those liquid motion ornaments filled with coloured sediment, oil and air. Turn it over and gravity takes care of the rest. The different materials slowly separate, collide and flow past one another, creating landscapes that exist for a few seconds before disappearing.

I’ve always found them strangely fascinating.

A little bit of 90s nostalgia

I remember seeing these sorts of things in gift shops while we were on holiday when I was much younger, particularly during the 1990s.

They’d be alongside lava lamps, plasma balls and all the other slightly odd things that seemed impossibly interesting at the time.

My dad always took a particular fancy to these liquid ornaments. I can remember stopping to look at them and watching the sand and oil slowly make their way from one side to the other.

There was something compelling about the fact that you didn’t really control what happened. You simply turned it over and watched.

Years later, I’ve somehow ended up with one sitting next to my computer.

And while watching it recently, I started wondering:

Could I recreate some of that behaviour with code?

Looking closer

Taking a few close-up photographs made the ornament considerably more interesting.

From a distance, you see flowing purple sediment.

Up close, there’s much more going on.

Tiny particles collect into dense areas before thinning out into clouds. Oil forms bubbles of wildly different sizes. Those bubbles gather into groups and channels. Sediment flows around them. Fine gold particles occasionally collect along boundaries, while elsewhere large areas remain almost completely empty.

It started to look less like a desk ornament and more like an abstract painting.

That became the starting point for the Processing experiment.

Building the system

I didn’t particularly want to reproduce the ornament literally. The aim was to identify some of its behaviours and use them as rules for generating something new.

I started with a 1600 × 1600 pixel white canvas and a limited palette derived loosely from the ornament: blue, purple, magenta and a contrasting sediment-like gold.

Rather than drawing large solid shapes, the colour is made from thousands of tiny particles.

Each particle starts somewhere within a larger group and moves across the canvas according to a flow field.

A simplified version of the idea looks something like this:
```
float n = noise(
  x * flowScale,
  y * flowScale
);

float angle =
  n * TWO_PI * 2.9;

x += cos(angle) * speed;
y += sin(angle) * speed;
```
I’m using Perlin noise here because completely random movement quickly looks exactly that: random.

Noise gives neighbouring particles similar instructions. Instead of visual static, thousands of individual dots begin to form currents, folds, waves and larger structures.

That’s where the experiment became much more interesting.

Making bubbles into obstacles

Initially the bubbles were simply circles drawn over the finished artwork.

Visually it worked, but physically it didn’t make much sense.

Looking again at the real ornament, the bubbles are part of the system. Material has to move around them.

So the bubbles became obstacles within the simulation.

When a particle approaches a bubble, its normal direction is altered. An outward force stops it entering the circle while a tangential force encourages it to travel around the circumference.

Conceptually, it became something like:
```
float nx = dx / distance;
float ny = dy / distance;

float tx = -ny;
float ty = nx;

vx += tx * tangentForce;
vy += ty * tangentForce;

vx += nx * outwardForce;
vy += ny * outwardForce;
```
The result was unexpectedly effective.

Instead of bubbles merely appearing on top of the artwork, streams started dividing around them. Groups of bubbles produced channels. Pigment accumulated around their edges and then rejoined further downstream.

Suddenly the bubbles were helping to create the composition.

Gold behaves differently

The gold became another little experiment within the experiment.

I didn’t want it evenly distributed throughout the image. In the physical ornament it feels more like a sediment: something heavier that collects in particular places.

So the gold particles have their own behaviour.

They follow the same underlying flow, but respond more strongly to bubble boundaries and have a chance of being deposited when they get close to an edge.
```
if (edgeDistance < 8) {

  if (random(1) < 0.035) {
    deposited = true;
  }
}
```
It’s a tiny rule, but across thousands of particles it produces occasional concentrations and thin gold trails.

I particularly like that I don’t decide exactly where the gold appears.

The system does.

Controlled, but not designed

That’s probably my favourite aspect of this project.

I’m choosing the palette, particle density, noise scale, bubble sizes, forces and probabilities, but I’m not actually drawing the final composition.

Every regeneration produces a different result.

Some are balanced.

Some are chaotic.

Some contain huge empty areas.

Some become almost completely overwhelmed by colour and bubbles.

And occasionally one appears where everything happens to come together.

There’s something pleasingly similar about that process to turning over the original ornament and waiting to see what happens.

From simulation to artwork

Once I started getting outputs I liked, I realised they worked surprisingly well away from the Processing window.

At 1600 × 1600 pixels they’re naturally suited to square digital artwork, but the detail also makes them interesting as prints.

I’ve experimented with them as large square framed pieces, groups of three prints, desktop artwork and phone wallpapers. Cropping into the images also reveals smaller compositions that I hadn’t deliberately created.

That opens another interesting possibility: generating at a much larger resolution and treating the resulting image almost like a landscape, finding compositions within compositions.

The artwork could equally become animation. Instead of saving the final particle paths, the movement itself could become the work: pigment slowly flowing around bubbles, separating and collecting before eventually settling.

Back to the desk

What I like most is how circular the whole experiment feels.

A fairly simple ornament sitting beside my computer reminded me of being on holiday in the 90s and watching these things with my dad.

Thirty-odd years later, I’m looking at the same object and wondering how its behaviour can be translated into Perlin noise, particles, collision detection and Processing.

The finished images aren’t really simulations of oil and sediment.

They’re interpretations of it.

Gold, sediment, waves and oil — translated from something physical into a set of rules, then handed back to chance.
August 12, 2026
Making Birbs

I’ve been making birbs.

They started life digitally, as a very simple 3D model. I deliberately kept the form minimal: a rounded body, the suggestion of a beak and two eyes. Just enough information for your brain to decide that, yes, this little lump is probably a bird.

From that original model I created a 3D print, then used the print to make my own silicone mould.

That meant I could start casting them in Stonecast.

And that’s where things became much more interesting.

From digital to physical

A 3D model is predictable. You can duplicate it endlessly and every copy is essentially identical.

Casting doesn’t quite work like that.

The basic form might come from the same mould, but every birb comes out with its own collection of tiny bubbles, marks, imperfections and variations in the surface.

Rather than trying to eliminate all of that, I’ve started embracing it.

The slightly rough surface of the Stonecast actually suits the simplicity of the shape. Some look almost like little carved stones rather than something that began life on a computer.

Same birb, different experiments

Once I had a repeatable form, the birb became a small three-dimensional canvas.

I’ve tried leaving them completely white, adding washes of colour, working into the surface with black, creating loose landscapes and using much more expressive painted marks.

Some experiments are very restrained.

Others definitely aren’t.

What I like is that the underlying object never changes. Two eyes, a tiny beak and a vaguely bird-shaped lump remain constant while everything happening on the surface can be completely different.

There is something quite liberating about that.

I’m not starting with a blank canvas each time. The decision about what I’m making has already been made.

The question becomes:

What happens to this birb?

Imperfect multiples

I’ve become particularly interested in the idea of multiples that aren’t really multiples.

The 3D print gives me an original.
The silicone mould gives me repetition.
The casting introduces variation.
Painting makes each one unique again.

It’s a strange little journey from something completely digital and reproducible to something physical and individual.

And I think that’s probably why I’ve enjoyed making them so much.

They combine quite a few things I’m interested in: 3D design, making, materials, repetition, randomness and experimentation.

They’re also just quite nice little objects to have sitting around.

More birbs

I don’t really have a grand plan for them.

For now I’m happy treating each cast as another experiment: different materials, pigments, textures, painting techniques and probably a few ideas that won’t work at all.

The mould gives me permission to experiment because I can always cast another one.

Same birb.

Different outcome.

And there will almost certainly be more of them.

August 11, 2026
What if washing up looked like a solar eclipse?
Sometimes an idea for a project doesn’t come from looking for one.

I was doing the washing up after breakfast and noticed the sediment left in the bottom of a cereal bowl. The liquid had drained away, leaving behind a strange collection of stains, particles, darker edges and almost vein-like structures.

I took a photograph.

At first, I was simply interested in whether I could recreate some of those textures using Processing. But there was something else about the shape that seemed familiar.

A dark crescent.

And, by coincidence, this Wednesday evening there’s a major solar eclipse.

Suddenly the experiment had a direction.

Cereal bowl inspiration No 1

Cereal bowl inspiration No 2

From cereal bowl to crescent

I wasn’t particularly interested in recreating the photograph pixel for pixel. What interested me was working out why it looked the way it did.

There seemed to be a few different things happening:
- a large area of very diluted colour;
- pigment collecting more heavily in one area;
- thousands of tiny particles spreading away from it;
- occasional larger deposits;
- branching, vein-like structures;
- areas where the sediment had disappeared completely.
Instead of drawing a crescent, I wanted to create a system that could produce something that felt like one.

The main structure is therefore made from hundreds of individually generated curves.
```
for (int i = 0; i < 650; i++) {

  float startAngle =
    radians(105) + radians(random(-20, 35));

  float endAngle =
    radians(255) + radians(random(-35, 20));

  // draw the sediment curve...

}
```
The important part here is the randomness in the starting and finishing angles.

My first attempts gave the crescent very obvious straight edges. Giving every strand a slightly different length allowed the sediment to gradually break apart instead.

An accidental eclipse

Once the crescent began appearing, it was difficult not to see an eclipse in it.

That’s particularly timely because on 12 August 2026 a total solar eclipse will cross parts of the Northern Hemisphere, with a deep partial eclipse visible from the UK.

I liked the idea of taking two completely unrelated events from the same week — washing a cereal bowl and looking forward to an eclipse — and allowing one to influence how I interpreted the other.

The code isn’t actually drawing the Sun or Moon.

There are no circles being placed on top of one another to manufacture an eclipse symbol.

Instead, the illusion comes from the distribution of sediment.

Making sediment with code

The smallest particles are just ellipses.

Lots of them.
```
float d = random(0.4, 2.1);

fill(0, alpha);

ellipse(
  x,
  y,
  d,
  d
);
```
On their own they’re nothing particularly interesting.

The important part is where they appear.

Each particle originates somewhere around the crescent before being allowed to drift away from it.
```
float drift =
  pow(random(1), 2.2)
  * width
  * 0.52;

float x =
  sourceX + drift;

float y =
  sourceY
  + randomGaussian()
  * (12 + drift * 0.18);
```
Using:
```
pow(random(1), 2.2)
```
means most of the particles remain relatively close to their source while progressively fewer travel a long distance.

It’s a very small mathematical decision, but visually it makes the particles feel as though they are dispersing from something, rather than simply being sprinkled randomly across the canvas.

A little imperfection

One detail I particularly liked in the original bowl was that the darkest sediment wasn’t uniformly dark.

There were tiny holes and lighter particles within it.

So I added a deliberately limited number of white sediment particles over the black.
```
int fineCount =
  int(random(70, 130));

float d =
  random(0.7, 2.7);

fill(
  255,
  random(100, 210)
);

ellipse(x, y, d, d);
```
There aren’t many.

That’s intentional.

Too many and it starts looking like a graphic effect. A small number helps break apart the otherwise dense black area.

Adding washed-out colour

The original photographs also contained very subtle colour.

Rather than creating a palette of unrelated colours, the sketch starts with just one:
```
color baseColour = #208FA0;
```
Processing then generates lighter tones by mixing that colour with white.
```
washLight =
  lerpColor(
    baseColour,
    color(255),
    0.84
  );

washMid =
  lerpColor(
    baseColour,
    color(255),
    0.58
  );

washDeep =
  lerpColor(
    baseColour,
    color(255),
    0.25
  );
```
That gives me several concentrations of effectively the same pigment.

The lighter tones form the watery areas while the darker tones sit closer to the sediment.

The black particles remain black, which keeps the contrast of the original experiment.

And because everything comes from one hex value, I can completely change the character of the image by changing a single line of code.

One set of rules, many eclipses

The finished sketch doesn’t actually have a finished composition.

Pressing R creates a new random seed.
```
void generateNew() {

  seed =
    int(random(1000000));

  redrawArtwork();
}
```
That seed controls the proportions, sediment, texture and rotation.

So every generation is related, but none is identical.

Sometimes the result looks very obviously like an eclipse. Other times it looks more like ink, a microscopic image, a coastline or something geological.

I prefer that ambiguity.

The eclipse was the inspiration for the form, rather than something the program has been instructed to illustrate.

Turning the light off

There’s also an inverted version.

Pressing I switches between the light and dark compositions.
```
if (key == 'i' || key == 'I') {

  inverted = !inverted;

  redrawArtwork();
}
```
Importantly, it doesn’t generate another random seed.

The same artwork is redrawn with the relationship between light and dark reversed.

It felt particularly appropriate for a project that had unexpectedly become about an eclipse.

Look at the washing up

I like that this project started with something as mundane as doing the washing up.

There was no plan to make an eclipse artwork.

I noticed some sediment in a cereal bowl, wondered whether I could reproduce it with code, started experimenting with particles and curves, and then realised the forms I was producing connected with something happening in the sky a few days later.

A cereal bowl gave me the texture.

An eclipse gave me the form.

Processing gave me a way of connecting the two.

And on Wednesday evening, assuming the British weather cooperates, I’ll hopefully get to see the other version.

One last thought…

I’m wondering what happens if I take these back out of the computer. I’m thinking of printing a few of the black-on-white versions and adding washes of real watercolour by hand — bringing some of the unpredictability of the original cereal-bowl sediment back into the finished pieces.

Code, ink, water and a little randomness.

Watch this space…
August 10, 2026
Study 03: Random
What if the computer only gave the instructions?

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.
August 7, 2026
Sound Bath
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.

Tools used: Processing (Java), procedural animation, Perlin noise, generative drawing, interactive simulation.
August 4, 2026
Making Bird Calls Visible with Processing (Java)
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.

Each range has a different influence:
- Lower frequencies create deeper, heavier movements.
- 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.
July 26, 2026