Scott Pollard — Design, Code & Art

Author: Scott Pollard

  • Making Bird Calls Visible with Processing (Java)

    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.

    A page of Scott Pollards sketch book showing a coding concept

    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.

  • Generative Murmurations from Bird Sightings

    Generative Murmurations from Bird Sightings

    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.

  • Generative Bird Portraits in Processing

    Generative Bird Portraits in Processing

    How thousands of flowing lines can gradually reveal a wildlife photograph.

    The idea

    I’ve always been fascinated by the point where photography and generative art meet.

    Rather than creating a portrait with traditional brushes or pixels, I wanted to explore whether an image could emerge from movement alone. The challenge wasn’t to copy a photograph exactly, but to build a system that slowly discovers it.

    Using Processing (Java), I created an algorithm that starts with a blank white canvas. Guided by Perlin noise and the colour information within a photograph, thousands of flowing lines gradually build the portrait over time.

    Each run is unique. The subject remains recognisable, but the path taken to reach the final image is never exactly the same.

    The inspiration

    Wildlife photography has been one of my longest-standing hobbies, and many of my favourite photographs eventually find their way into creative coding experiments.

    This kingfisher was the perfect subject.

    Its vivid blues and warm chestnut feathers create a striking colour palette, while the distinctive shape allows the portrait to emerge surprisingly early in the drawing process. I also liked the idea of extending the colours beyond the bird itself, allowing the background to dissolve into abstract flowing contours that echo reflections on moving water.

    The result sits somewhere between illustration, map contours and fluid motion.

    Generative Art of. a Kingfisher using code

    The process

    The system begins with the original photograph loaded into Processing.

    Rather than drawing the image directly, the sketch continuously releases thousands of virtual particles across the canvas. Each particle follows a flow field generated with Perlin noise, creating smooth organic movement rather than straight mechanical lines.

    As each particle moves it samples the colour beneath it from the original photograph.

    The sampled colour determines:

    • The stroke colour
    • The opacity
    • The line weight
    • The amount of movement

    Areas containing stronger contrast gradually accumulate more detail, while flatter areas remain lighter and more open. The portrait slowly appears as countless individual decisions overlap.

    Because every particle has its own journey, the finished image feels drawn rather than rendered.

    Development

    The artwork evolves through several distinct stages.

    Stage One

    The first lines establish the flow field. At this point there’s almost no indication of the final subject, only delicate contour-like structures beginning to spread across the canvas.

    Stage Two

    As more particles are released, hints of colour begin to appear. The background develops its own visual language while the first recognisable shapes of the bird begin to emerge.

    Stage Three

    The silhouette becomes readable. Individual feather groups and larger areas of colour start to define the subject, while the flowing background continues to build complexity.

    Stage Four

    Fine detail accumulates around the eye, beak and plumage. The image now balances abstraction with realism, retaining visible traces of every particle path.

    Final Artwork

    After thousands of individual strokes, the portrait reaches a point where enough visual information exists for the photograph to feel complete. The image is never perfectly recreated—instead it becomes an interpretation built entirely from movement and time.

    What I learned

    One of the most interesting discoveries was that restraint often produces a stronger image.

    My early experiments tried to reproduce every detail from the photograph. While technically successful, they lost much of the atmosphere created by the flowing lines.

    By reducing the amount of information and allowing areas of the portrait to remain unfinished, the final artwork became far more expressive. The viewer naturally fills in the missing detail, creating a stronger connection between the abstract and the recognisable.

    I also found that allowing colour to escape into the background helped unite the composition, preventing the bird from feeling isolated against a plain backdrop.

    What’s next?

    This project forms part of a wider series exploring wildlife through generative systems.

    Future developments include:

    • Building portraits entirely from flow fields without using direct colour sampling.
    • Adding depth through layered particle systems.
    • Creating animated versions where the portrait continuously forms and dissolves.
    • Producing large-format A3 and A2 prints suitable for exhibition.

    Ultimately, I’d like to create a collection of British wildlife portraits where every piece is generated from its own unique algorithm.

    Final thoughts

    One of the reasons I enjoy creative coding is that the computer becomes a collaborator rather than simply a tool.

    I define the rules, but I don’t dictate every outcome.

    Each execution of the program introduces small variations, meaning every portrait carries its own character while remaining faithful to the original photograph. Watching the image slowly emerge from thousands of flowing lines is often just as rewarding as the finished artwork itself.

  • Why I Make Things

    Why I Make Things

    I’ve always enjoyed understanding how things work.

    Whether it’s a website, a piece of software, a printed poster or a generative artwork, I’m interested in the process as much as the finished result. I like taking something apart, learning from it and rebuilding it in a different way.

    That curiosity has shaped much of my career.

    Professionally, I work as a designer and developer, creating websites, digital products and online experiences. My work sits somewhere between design and engineering; thinking about typography one minute and writing code the next. Both disciplines solve problems, just in different ways.

    Outside of work, that same mindset continues.

    This website is where I document the projects I create for myself. Some begin as a sketch in a notebook. Others start with a question: What happens if thousands of particles try to draw a bird?
    Can server statistics become a landscape?
    Could an algorithm recreate the structure of a long-tailed tit’s nest?

    Sometimes those ideas become finished prints. Sometimes they become software. Occasionally they fail completely.

    They’re all worth documenting.

    Much of my recent work explores generative art using Processing (Java). I enjoy writing systems rather than fixed compositions, giving algorithms a set of rules and watching them produce unexpected results. Small adjustments to colour, movement or randomness can transform a piece entirely, which means every iteration becomes part of the creative process.

    Nature is a constant source of inspiration. Birds, landscapes, geology and patterns found in the natural world often influence the direction of my work. I enjoy observing how complex forms emerge from simple behaviours, and many of my projects borrow those same principles through code.

    I also have a fascination with data.

    Numbers don’t have to live in spreadsheets. They can become textures, structures and compositions. Whether I’m visualising website analytics, support metrics or wildlife sightings, I’m interested in finding ways to turn information into something engaging and visually meaningful.

    This site isn’t intended to be a polished portfolio or a showcase of only the finished pieces. Instead, it’s a working archive of ideas, experiments and lessons learned along the way.

    You’ll find sketches alongside completed artwork, code next to photography, and successes sitting comfortably beside projects that never quite worked. Creativity is rarely a straight line, and I think the unfinished work often tells the more interesting story.

    If something here sparks an idea, teaches you something new or simply encourages you to make something yourself, then this site has done its job.

    Thanks for reading.

    — Scott