Weather is something we all experience, yet it’s often reduced to numbers on a chart or icons on a forecast. For this project I wanted to explore a different approach by translating decades of climate data from North West England and North Wales into an abstract woven composition.
Using Java and Processing, the artwork is generated from historical Met Office climate datasets covering rainfall, sunshine and maximum temperatures. Rather than plotting the information as a conventional graph, each data series influences a different visual characteristic, allowing the climate to emerge as a textile-like structure.
Rainfall is represented through dashed threads that build density and rhythm across the composition. Sunshine introduces bright yellow strands and small bead-like markers that punctuate the weave, creating moments of light amongst the darker fibres. Temperature is expressed as a flowing gradient, shifting from cool blues to warm reds, giving the piece an additional layer of movement and seasonal character.
One of the most striking patterns isn’t just that the summers are getting warmer, but that the warmth is lingering for longer, gradually stretching further into autumn and delaying the onset of winter.
One of the most enjoyable parts of the project was discovering how a simple woven structure could communicate such complex information. The result isn’t intended to be read as a chart. Instead, it encourages the viewer to experience the data first as an artwork before gradually recognising that every thread is responding to genuine climate records.
Developing the project also became an exercise in balancing aesthetics with information. Too much emphasis on the data and the composition lost its visual appeal; too much abstraction and the connection to the climate disappeared. Finding that middle ground became the focus of the design process.
The sketch is fully generative, meaning each composition is created programmatically while remaining rooted in historical weather observations. Features such as animated fibres, interactive colour modes and woven layering help transform static datasets into something that feels organic and alive.
This project continues my exploration of using code as a creative medium, where information becomes material rather than simply content. By treating climate data as texture, rhythm and structure instead of statistics, the work aims to reveal familiar weather patterns from an entirely different perspective.
Although this is an early iteration, there are plenty of directions to explore next. I’m interested in introducing more complex weaving behaviour, allowing threads to respond to long-term climatic trends, and experimenting with larger-format outputs where the fine details become even more immersive.
As with many of my Processing projects, the goal isn’t to create a digital chart or dashboard, but to build something that sits somewhere between data visualisation, generative art and printmaking—using code to uncover beauty hidden within everyday information.
Can you understand an artist by rebuilding their process?
Over the last few years I’ve been experimenting with Processing and Java to create generative artwork. Most projects have explored modern computing power, real-time animation and increasingly complex systems.
This project is different.
Rather than asking “What can today’s computers do?” I wanted to ask:
“What could have been achieved with the mathematical thinking available in the 1960s?”
That naturally led me to the pioneering work of Vera Molnár.
Looking backwards instead of forwards
Vera Molnár is recognised as one of the earliest artists to embrace computers as a creative partner. Long before generative art became fashionable, she was exploring systems, rules and controlled randomness.
What’s remarkable is that many of her ideas existed before she even had regular access to a computer.
She imagined what she called an “imaginary machine”—a conceptual computer capable of carrying out simple instructions repeatedly. When computers eventually became available, they simply became another tool for testing those ideas.
Looking through her work, it’s easy to become distracted by the finished images.
What interests me more is the thinking behind them.
This isn’t about copying
The intention isn’t to reproduce Vera Molnár’s artwork.
Instead, it’s an attempt to understand the constraints she worked within.
Today’s software makes almost everything effortless:
millions of calculations every second
unlimited colours
complex animation
advanced rendering
countless libraries
Removing those luxuries forces different decisions.
For this series I’ll deliberately restrict myself to:
Basic geometric shapes
Straight lines
Simple transformations
Repetition
Small amounts of controlled randomness
Elementary mathematics
Black and white compositions
A3 portrait layouts
Every project will be written in Processing using Java.
Not because it’s historically accurate, but because it allows me to think algorithmically without unnecessary complexity.
Designing with limitations
One thing that becomes obvious very quickly is that limitations are surprisingly creative.
Instead of asking:
“What should I draw?”
the question becomes
“What simple rule should I write?”
A square becomes interesting once it’s repeated.
A line becomes interesting once it’s rotated.
A grid becomes interesting once every element breaks the rules slightly.
Tiny mathematical changes produce surprisingly rich compositions.
Thinking like an early computer
Modern generative artists often build systems with noise functions, particle engines, physics simulations and GPU shaders.
For this project I’m intentionally avoiding most of that.
Instead I’ll explore ideas that feel closer to the computational mindset of the 1960s:
Regular grids
Rotation
Translation
Scaling
Sequential plotting
Iteration
Random number generation
Permutation
Probability
Simple geometric relationships
Almost every image should be explainable in a few lines of mathematics.
A study rather than a tribute
I’m treating this as a research project.
Each artwork will begin with a question.
What happens if every square rotates by one degree more than its neighbour?
What if a perfect grid slowly loses its precision?
How much randomness is enough before order disappears?
Those questions feel far more interesting than chasing a particular visual style.
Hopefully, by rebuilding these ideas from first principles, I’ll gain a deeper appreciation of why Vera Molnár’s work remains so influential today.
The series
Over the coming weeks I’ll be creating a collection of A3 portrait artworks, each exploring a single mathematical idea.
Every piece will be generated entirely in Processing using Java and deliberately limited to the simplest possible visual language.
No textures.
No gradients.
No effects.
Just mathematics, repetition and controlled variation.
Sometimes the simplest rules produce the richest results.
That’s a lesson Vera Molnár understood more than sixty years ago—and one that’s still worth exploring today.
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.
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.
