Using real bird observations to create evolving digital flocks in Processing (Java).
Every year, thousands of bird sightings are submitted by birdwatchers across the UK. They usually end up as lists of species, dates and locations. They’re invaluable for conservation, but I wondered what they might look like if the data could move.
This project explores that idea by transforming bird sighting records into a living murmuration.
Rather than plotting observations on a map, every record becomes an individual bird within a simulation. As more sightings are added, the flock begins to organise itself using simple behavioural rules inspired by nature. Over time, scattered points become flowing shapes that continuously form and dissolve across the screen.
The result sits somewhere between data visualisation, simulation and generative art.
The Idea
The project takes recent bird sighting data and uses it as the starting point for a flocking simulation built in Processing.
Each observation creates a bird within the system. From there, the birds respond to one another using the classic flocking behaviours:
- Separation – avoiding collisions with nearby birds.
- Alignment – matching the direction of neighbouring birds.
- Cohesion – moving towards the local flock.
To prevent the movement feeling too mechanical, Perlin noise is introduced to create subtle environmental forces. The flock constantly shifts, stretches and reforms in ways that feel closer to watching real starlings overhead.
The original data simply starts the conversation. The artwork takes over from there.
From Data to Movement
One aspect I particularly enjoyed was avoiding a literal representation of the data.
There are no maps, charts or graphs.
Instead, the information becomes behaviour.
A busy day of sightings naturally produces a larger, denser flock, while quieter datasets create more open formations. Different species could eventually influence colour, speed or movement characteristics, allowing each dataset to generate its own personality without ever needing labels or axes.
Building the Simulation
The project was written in Java using Processing.
Alongside the flocking algorithm, I added a number of features to make the artwork feel more alive:
- Procedurally generated Perlin noise flow.
- Species-based colour palettes.
- Motion trails showing the history of each bird.
- Pause and restart controls.
- High-resolution image export.
- Randomised initial formations.
One idea i’ve introduced is adding a peregrine falcon into the simulation. At random intervals it would pass through the flock, forcing the birds to scatter before gradually reforming into a new murmuration.
Why I Like This Project
I’ve always enjoyed projects that blur the boundary between science and art.
The underlying algorithms are relatively simple, but when hundreds of individual agents interact together, surprisingly natural behaviour emerges. Watching order appear from a collection of independent birds feels remarkably similar to observing a real murmuration.
It’s also a reminder that data doesn’t always need to be presented analytically. Sometimes the most engaging way to understand information is to experience it.
What’s Next?
There are plenty of directions I’d like to take this further:
- Live bird sighting feeds updating the flock in real time.
- Species-specific behaviours and movement styles.
- Environmental influences such as wind or weather.
- 3D murmurations that viewers can rotate and explore.
- Large-format print series generated from moments within the simulation.
Like many of my Processing experiments, this is less about producing a finished piece and more about discovering what happens when simple rules interact over time.
Sometimes the most interesting results are the ones you never explicitly programmed.