Scott Pollard — Design, Code & Art

Author: Scott Pollard

  • AI is spoiling the enjoyment of surprise

    AI is spoiling the enjoyment of surprise

    We seem to have become obsessed with how quickly things can be done. How quickly can we build the website? How quickly can we create the concept? How quickly can we write the code? And increasingly, how quickly can AI do all of the above?

    Speed has become one of the easiest ways to measure progress. If something took two days and now takes two hours, that must be better. And in plenty of situations, it absolutely is. But I’m starting to wonder whether we’ve accidentally started optimising something else out of the process.

    Surprise.

    We don’t like uncertainty very much

    Most businesses are naturally built around reducing uncertainty. We create processes, make templates, automate repetitive tasks, establish best practices and look at what worked last time so we can do more of it. It makes perfect sense.

    If a problem can be solved logistically rather than creatively, logistics normally wins. Creativity introduces uncertainty. You might spend three hours exploring an idea only to discover it doesn’t work. You might write some code, run it and get an error. You might design something, leave it overnight, come back the following morning and decide it’s rubbish.

    From a productivity point of view, this isn’t particularly efficient. But perhaps that inefficiency has some value.

    I’ve probably had this thought reinforced by watching many Rory Sutherland lectures. One of the recurring ideas I’ve taken from his work is that we’re very good at valuing things we can logically explain and measure. Efficiency is easy to defend in a meeting. Spending an afternoon experimenting with something that might go nowhere is rather harder.

    Ludwig von Mises wrote about something he called the “joy of labour”. Part of that joy comes from mastering something and being able to look at the result and think: I know how to make this. There’s another part I think anyone who has spent time coding will recognise. That feeling when something finally works.

    Not because somebody handed you the answer, but because you’ve spent an hour changing things, reading documentation, breaking it, fixing it, breaking something else and eventually understanding what was wrong. The result matters, but so does everything that happened before the result.

    I’ve been thinking about this quite a lot while using AI for coding. There’s a particular little dopamine hit that comes from writing some code, hitting run and seeing something happen that you weren’t completely expecting. Sometimes it works. Sometimes it spectacularly doesn’t. Occasionally the mistake is actually more interesting than the thing you were trying to make.

    That happens in design too. Move something accidentally, try the wrong colour, crop an image strangely, misunderstand an instruction or combine two ideas that weren’t originally supposed to go together. You stop and think, actually, there’s something in that.

    Those moments are difficult to put on a project plan. They’re also some of the most interesting moments in creative work.

    Then along came “the full script please”

    I should probably admit something here. I use AI a lot.

    Over the past year I’ve used it to help me build all sorts of creative coding experiments. Generative artwork, simulations, data visualisations and interactive pieces. I’ll have an idea, describe it to ChatGPT, get some code, run it and then start experimenting.

    Make the pixels move. Add some randomness. Change the colours. What happens if gravity is added? Can we make it 3D?

    And, quite regularly:

    “The full script please.”

    (If ChatGPT starts saying replace that with this somewhere)

    It’s brilliant. An idea that might once have remained scribbled in a notebook can be running on my screen twenty minutes later. AI has opened up a creative playground for me. I can explore ideas quickly, make dozens of variations and pick out the strange, unexpected and beautiful things that appear along the way.

    I wouldn’t want to give that up.

    But there is a contradiction in there. The quicker I ask AI to solve every problem, the less time I spend understanding the problem myself. Eventually something subtle changes. I’m no longer making the thing in quite the same way. I’m directing the making of the thing.

    Those aren’t necessarily the same experience.

    Creativity needs some friction

    Steve Jobs once described creativity as connecting things. His argument was that creative people often arrive at interesting ideas because they’ve accumulated experiences and thought about them enough to make connections between them.

    I think there’s something important in that. You need some dots before you can connect them, and those dots often come from doing things the slow way. Reading the documentation. Trying something that doesn’t work. Learning why it doesn’t work. Remembering a completely unrelated technique from five years ago.

    It’s about understanding enough CSS, JavaScript, PHP or whatever else you’re using to know when the obvious solution isn’t necessarily the right one. AI can jump straight to a plausible answer, but sometimes the wandering around before the answer was where we acquired the knowledge that would help us solve the next problem.

    There’s another problem with efficiency too. It encourages us to stay where things are predictable.

    Businesses understandably like repeatable outcomes. Designers develop styles. Developers use familiar frameworks. Marketing teams repeat campaigns that performed well previously. Then AI arrives with an extraordinary ability to look at everything that already exists and give us another plausible version of it.

    That can make the safe lane even safer.

    The danger isn’t necessarily that AI produces bad work. Quite the opposite. It can produce perfectly competent work incredibly quickly, and perhaps that’s the more interesting problem. If the competent answer arrives almost instantly, what makes us continue exploring?

    Why try the strange idea? Why spend an afternoon making something that might not work? Why write the awkward first version yourself?

    Efficiency tells us to stop when the problem has been solved. Creativity often asks what happens if we keep going.

    Perhaps we need slow AI

    Perhaps we don’t actually need less AI. Perhaps we need slower AI.

    I don’t mean artificially making the computer take thirty seconds to answer instead of three. That would just be annoying. I mean slowing down how we use it.

    There is already some interesting research around this idea. Researchers have explored “Reflective AI”, applying ideas from slow technology to creative education. Rather than treating AI purely as a machine for producing finished outputs, the idea is to use it in ways that encourage reflection, understanding and engagement with the process.

    I like that distinction because it changes the relationship we have with the tool.

    Imagine asking AI not to give you the finished function, but to explain what might be causing the problem. Ask for three possible approaches. Ask it to explain the part you don’t understand. Write your own version, break it and then ask AI why it broke.

    The goal changes from get me to the answer as quickly as possible to help me explore this.

    AI becomes less like a vending machine and more like someone sitting next to you while you work.

    I don’t want to give the speed back

    None of this means I want to return to development before AI. I don’t.

    AI has removed huge amounts of tedious work from my day. It helps me investigate unfamiliar code, generate starting points, debug problems and explore ideas that would otherwise require far more time than I have available.

    My everyday development work now sits somewhere between AI-assisted and traditionally written code. Sometimes I know exactly what I want and writing it myself is quicker. Sometimes AI gets me 80% of the way there. Sometimes I deliberately work through the problem because I want to understand it.

    And sometimes I just want the full script please.

    The important thing, I think, is recognising that these choices have different consequences. Saving time is useful. Learning is useful. Enjoyment is useful too.

    We’ve spent decades making computers faster. Then we made the internet faster, our workflows faster and our development tools faster. Now AI can compress hours of thinking and making into minutes. That’s an extraordinary achievement.

    But perhaps speed shouldn’t be the only measurement.

    There is value in knowing how something works. There is value in struggling with something for a while. There is value in making the wrong thing. And there is definitely value in pressing run without being entirely sure what is going to happen.

    Because sometimes the best part isn’t that it worked.

    It’s the surprise when it does.

    Acknowledgement

    A quick shout out to Rory Sutherland, whose lectures and talks I’ve really enjoyed watching online. His way of questioning our obsession with logic, efficiency and optimisation has definitely influenced some of the thinking behind this article.

    These aren’t necessarily Rory’s conclusions about AI. They’re my own thoughts, but his work certainly helped send me down this particular rabbit hole.

    References and further reading

    Ludwig von Mises, Human Action: A Treatise on Economics
    In his discussion of the “joy and tedium of labour”, Mises considers the satisfaction that can accompany work, including the pride of being able to look at something and say, essentially, “I know how to make this. This is my work.”

    Steve Jobs, interviewed by Gary Wolf, WIRED, 1996
    Jobs discusses design as something requiring genuine understanding rather than simply appearance. In the same interview he describes creativity as connecting experiences and argues that broader experiences give people more “dots” to connect.

    Rory Sutherland
    Vice Chairman of Ogilvy UK, author of Alchemy: The Surprising Power of Ideas That Don’t Make Sense, and a frequent speaker on behavioural economics, creativity and the limitations of purely rational decision-making. His talks and lectures around efficiency, logic and human behaviour were an influence on the thinking behind this article.

    Reflective AI and slow technology
    Research presented at CHI 2026 explores “Reflective AI”, looking at how deliberately slowing AI-supported creative processes can encourage reflection, understanding and creative agency rather than simply optimising for faster outputs.

  • Kaleidoscopes: cool, but still not very usable

    Kaleidoscopes: cool, but still not very usable

    I remember kaleidoscopes mostly from museum gift shops.

    Not necessarily the expensive museums either. Science museums, little local museums, National Trust gift shops — anywhere that had a rack of slightly educational toys alongside pencils, gemstones and things that glowed in the dark.

    I always thought kaleidoscopes were brilliant.

    You’d point one towards a window, slowly turn the end and suddenly something completely ordinary was transformed into this incredibly complicated geometric pattern. Turn it a few millimetres more and it was gone forever, replaced by something else.

    There was something particularly good about the fact that you weren’t really creating the image. You were just finding it.

    Sometimes retro stays retro

    The problem is that kaleidoscope graphics have never really escaped the kaleidoscope.

    There are plenty of old visual ideas that disappear for a while and then find a completely new context. Others seem permanently attached to the era or culture that popularised them.

    Tie-dye is perhaps a good example. You can reinvent it, change the colours, put it on an expensive T-shirt and photograph it beautifully — but somewhere underneath, it’s still tie-dye.

    Kaleidoscope graphics feel similar.

    They’re psychedelic. They’re a bit 1960s. They’re album artwork. They’re screen savers. They’re those music visualisers we used to leave running on computers.

    They’re cool, but still not very usable.

    And that’s partly what made me want to make one.

    Building my own kaleidoscope

    Rather than trying to make a single piece of artwork, I started building a kaleidoscope image generator in Processing.

    You load an ordinary photograph and the software starts pulling it apart through rotation, repetition and reflection.

    The first versions behaved much more like a traditional kaleidoscope. The image is divided into radial segments and those segments are repeated around a central point.

    Six sides.

    Eight.

    Ten.

    Twelve.

    Fourteen.

    Sixteen.

    Then mirrored versions. Flipped versions. Mirrored and flipped versions.

    And because it’s code rather than a physical object, the rules don’t have to stop there.

    The photograph can slowly rotate inside the segments while the overall structure rotates independently. Alternate sections can travel clockwise and anticlockwise. They can flip as they move.

    Suddenly the source photograph becomes almost irrelevant.

    You’re looking at relationships between tiny bits of it instead.

    Finding things in reflections

    This is where the experiment became more interesting to me.

    There are some genuinely interesting shapes and forms to be found in reflection.

    A small line in a photograph might become a six-pointed structure. A bit of shadow can turn into an architectural form. Something completely insignificant near the edge of the original image can become the dominant feature of the generated one.

    It feels a little like looking for faces in clouds.

    You’re not necessarily designing the shape directly. You’re creating the conditions that allow you to discover it.

    That also meant I became less interested in recreating a real kaleidoscope and more interested in abusing the underlying idea.

    Breaking the kaleidoscope

    The project now contains 34 different filters.

    Some remain fairly traditional: Hex Core, Octa Mirror, Dec Flip Mirror and Dodec Core.

    Others start pulling the principle apart.

    Spiral Mirror twists the repeated sections as they move away from the centre.

    Alternating Rings breaks the image into concentric sections travelling in opposing directions.

    Liquid Kaleido deliberately distorts the geometry so the reflections ripple and bend.

    Crystal Shards treats the photograph more like a sheet of fractured reflective material.

    Orbit Cells puts fragments of the image into individual circular lenses moving around the composition.

    Then there are experiments such as Infinity, Infinity Tunnel and Helix Tunnel, where the original two-dimensional kaleidoscope idea starts moving into three-dimensional space.

    At that point I’m not entirely sure they qualify as kaleidoscopes any more.

    Which is probably a good thing.

    The photograph becomes raw material

    One thing I’ve particularly enjoyed is seeing how differently photographs behave once they’re fed into the system.

    A photograph doesn’t need to be particularly good.

    In fact, an unremarkable photograph can sometimes produce a better result because you’re no longer really interested in its original composition.

    Colour, texture, edges, highlights and shadows become the raw materials.

    A tiny patch of yellow might suddenly repeat around the centre and create a flower-like form. Straight architectural lines become impossible structures. Organic textures can produce things that look strangely biological.

    And because everything is moving, you can simply pause when something interesting appears.

    P pauses the animation.

    S renders the current composition as a high-resolution PNG.

    So the software is less about producing the final kaleidoscope and more about continuously presenting possibilities.

    But would I actually use one?

    That’s the question I’ve kept coming back to.

    Probably not.

    At least, I don’t think I’m about to start putting giant kaleidoscope graphics into website headers or designing psychedelic posters.

    But I don’t think that makes the experiment pointless.

    The interesting bit might not be the finished kaleidoscope at all.

    It might be one tiny crop from it.

    A strange piece of reflected typography. An unexpected symmetrical mark. A texture. A shape that could become the beginning of something completely unrelated.

    That’s where generative tools become particularly useful to me. They don’t necessarily have to make the finished piece of design.

    Sometimes they just need to show you something you wouldn’t have thought to draw.

    And perhaps that’s ultimately what I liked about those little museum kaleidoscopes in the first place.

    You weren’t really looking through them to see the world.

    You were turning them until you found something interesting.

  • Pidge: making a little bit of street art

    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.

  • Iteration: how do we escape it?

    Iteration: how do we escape it?

    Almost everything is an iteration of something else.

    An artist sees another artist’s work and takes something from it. A musician hears a sound and pushes it somewhere slightly different. A designer borrows a layout, a typeface, a colour combination or an idea. Architecture responds to architecture. Fashion circles back on itself. Religions develop from older beliefs, traditions and stories.

    Even the things we describe as revolutionary rarely appear from nowhere.

    They are iterations.

    And perhaps that is simply how human creativity works.

    We see something.
    We absorb it.
    We change it.

    We combine it with something else. Then somebody sees what we have made and the process begins again.

    There is something quite comforting about that.

    But lately I’ve been wondering whether iteration has changed.

    Iteration used to have friction

    Before the internet, influences travelled relatively slowly.

    You might discover an artist through a book. Hear a new band through a friend. Find an unusual magazine in a shop. Visit another country and notice a completely different visual language.

    Those influences would get mixed together with where you lived, the people around you, what you could afford, what materials were available and your own ability.

    Copying was never perfect.

    And perhaps those imperfections were important.

    If ten people tried to recreate the same thing, they would probably produce ten slightly different results.

    Something would inevitably be lost, misunderstood or changed along the way.

    Perhaps that’s actually where originality lives.

    Not necessarily in creating something from nothing, but in the distance between the original idea and our imperfect interpretation of it.

    The gaps in our knowledge created variation.

    Now we can see almost everything, instantly.

    And everybody else can see it too.

    The algorithmic iteration

    Spend a little time on Instagram, TikTok or Pinterest and you can watch iteration happening at enormous speed.

    Someone makes something interesting.

    It performs well.

    Someone else notices.

    They make their version.

    That performs well too.

    Soon there are hundreds.

    The same photographic styles. The same interiors. The same graphic design. The same video edits. The same clothes. The same restaurants. The same coffee shops. The same phrases. The same personal brands.

    Eventually it becomes difficult to work out where the original idea came from.

    Maybe that doesn’t matter.

    What interests me more is what happens next.

    The platforms learn that we like this thing, so they show us more of this thing.

    We see more of it, so we become more familiar with it.

    Familiarity becomes preference.

    Preference becomes demand.

    And demand creates more of the thing.

    It is iteration feeding iteration.

    Then brands arrive

    Of course, brands understand this.

    If enough people begin presenting themselves in a particular way, there is an opportunity to sell them the things required to complete the picture.

    The right trainers.

    The right coffee machine.

    The right furniture.

    The right car.

    The right phone.

    The right holiday.

    Even the right houseplant.

    Products have always been marketed through aspiration, but social media has made the feedback loop extraordinarily efficient.

    We don’t just see advertising from brands anymore. We see thousands of people demonstrating the lifestyle surrounding the product.

    And because those people are also watching each other, certain lifestyles begin to converge.

    The strange part is that something can feel incredibly personal while being shared by millions of people.

    This is me.

    But where did me come from?

    How much did I choose, and how much was gradually presented to me until it felt like a choice?

    Is originality even possible?

    Perhaps we’ve put too much value on originality.

    The idea of creating something completely untouched by previous influence might be impossible.

    Every drawing I’ve ever made is influenced by drawings I’ve previously seen. Every website I’ve designed contains decades of established conventions. Every piece of code I’ve written relies on ideas developed by other programmers.

    Even rebellion requires something to rebel against.

    Punk needed what came before punk.

    Modernism needed what came before modernism.

    The avant-garde needs a garde.

    Trying to completely escape iteration might therefore be pointless.

    We would have to somehow forget everything we’ve ever seen.

    And even then we’d still have nature.

    Patterns, symmetry, repetition, rhythm, growth, decay.

    Iteration seems to be everywhere.

    Maybe the problem isn’t iteration

    Maybe it’s convergence.

    Iteration should create branches.

    One idea becomes two. Two become four. Four become hundreds of strange variations.

    Imagine an idea travelling slowly between people, places and disciplines.

    A painter sees something in architecture. A musician sees the painting. A fashion designer hears the music. A graphic designer sees the clothes. Each person takes something different from what came before.

    By the time the idea reaches the end of that chain, it might barely resemble where it started.

    That’s iteration doing something interesting.

    But what happens when everybody sees the same source at roughly the same time?

    We don’t necessarily get branches.

    We get thousands of people iterating from the same reference point. And increasingly, the platforms distributing those references are measuring the response.

    Likes. Views. Shares. Saves. Watch time. Clicks.

    Successful iterations are amplified. Unsuccessful ones disappear.

    The next person isn’t simply responding to an idea. They’re responding to an idea that has already been tested and ranked.

    That changes the process.

    Iteration starts becoming optimisation. And optimisation is very different from exploration.

    Instead of asking:

    What could this become?

    we begin asking:

    What version of this is most likely to work?

    That’s an incredibly useful question in many situations. But I’m not sure it’s always a particularly creative one.

    The value of getting it wrong

    I’ve become increasingly interested in processes where I don’t completely control the outcome.

    Generative art is an obvious example.

    You create the rules, but you don’t necessarily create the final image. You might define a grid, a set of colours, a movement system or a mathematical relationship. Then randomness enters the process. Run the same piece again and something changes. Run it a hundred times and occasionally something appears that you wouldn’t have consciously designed.

    I find that fascinating.

    Because in a strange way, the computer is introducing some of the friction we’ve been removing elsewhere.

    The unexpected result becomes part of the creative process. And it doesn’t have to involve code.

    It could be paint running somewhere you didn’t expect. A photograph being badly exposed. A material behaving differently from how you imagined. Mishearing a lyric. Picking up the wrong pen.

    Some of the most interesting iterations happen because something went wrong.

    Perhaps creativity needs a certain amount of information loss.

    A gap between the reference and the result.

    Deliberately introducing imperfection

    Perhaps one way out is to introduce that friction ourselves.

    Do something without researching it first. Use the wrong tool.
    Work with a material you don’t completely understand.
    Listen to music outside the genres recommended to you.
    Buy the strange magazine.

    Visit somewhere without searching for the ten things you’re supposed to see when you arrive.

    Make something and don’t immediately compare it with what other people have made.

    Allow randomness into the process. Allow mistakes. Allow bad ideas to survive slightly longer.

    Because sometimes the interesting part of iteration is the mutation.

    The misunderstood instruction. The accidental mark. The badly remembered reference. The technical limitation. The thing that wasn’t supposed to happen.

    Those are often the moments when an iteration stops being a copy and starts becoming something else.

    But do we actually want to escape?

    There is another possibility.

    Perhaps we don’t.

    Humans have always copied each other.

    It helps us communicate. It creates culture. It allows ideas to spread. It gives us common visual languages, rituals, music, fashions and beliefs.

    Iteration is how knowledge survives. If every generation started again from nothing, we’d get nowhere.

    So I don’t think iteration itself is something we need to escape.

    What might be worth escaping is unconscious iteration. Following because everyone else is following.

    Buying because everyone else is buying.

    Designing something a certain way because that’s what design currently looks like.

    Making something because the algorithm has quietly demonstrated that this is the sort of thing that gets rewarded.

    Maybe the important thing is simply to notice when it’s happening.

    To occasionally ask:

    Where did this idea come from?

    Why do I like this?

    Would I still make this if nobody else was going to see it?

    What happens if I deliberately take it in the wrong direction?

    We probably can’t escape iteration.

    I’m not convinced we should.

    Maybe we just need to put a little friction back into it.

    Enough randomness, misunderstanding, curiosity and failure to stop every branch growing in the same direction.

    Because perhaps originality isn’t the absence of influence.

    Perhaps it’s what happens to an influence on the journey.

  • Creatively coded, colourful contours

    Creatively coded, colourful contours

    I’ve always liked map contours. There’s something about those repeated lines wrapping around hills, valleys and changes in elevation that feels both technical and strangely abstract. Take away the labels, roads and place names and they become patterns in their own right.

    For this little Processing experiment, I wanted to take that idea and make it feel much less precise.

    I’m also drawn to low-resolution graphics, early digital imagery and anything that feels slightly blocky or restricted by a grid. So instead of smooth contour curves, these are built from sharp 90-degree steps. It gives them a kind of retro mapping feel — somewhere between topographic data, pixel art and an old computer-generated landscape.

    The terrain itself comes from Perlin noise. Each image is generated from a different random field, with contour levels gradually added until the piece is complete. I’ve always enjoyed using randomness in creative work because it introduces decisions I wouldn’t necessarily make myself. Sometimes the results are awkward, sometimes they’re unexpectedly balanced, and occasionally something appears that feels almost deliberately composed.

    That unpredictability is a big part of the appeal.

    Colour is random too, but within some boundaries. I’ve created a number of palettes based on colours I associate with favourite places, artists and bits of visual inspiration I’ve collected over the years. Each new piece chooses a palette and then distributes those colours across the landscape in different ways.

    So although the code and underlying rules stay the same, every output is different.

    Once a landscape has finished building, the sketch automatically saves it as an image before moving on and generating another. I can leave it running and gradually end up with a collection of strange, colourful, imaginary maps.

    They don’t represent anywhere real, but sometimes I find myself looking at them and trying to decide where the hills, lakes, paths and settlements might be anyway.

  • Ten Heartbeats and an Eclipse

    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.

  • Gold, Sediments, Waves and Oil

    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.

  • Making Birbs

    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.

  • Solar Eclipse 12/8/2026: A Dot-Matrix Sky

    Solar Eclipse 12/8/2026: A Dot-Matrix Sky

    There’s something wonderfully low-tech about watching a solar eclipse through a cardboard box.

    I remember being at school in the 80s and 90s and making simple pinhole viewers — cardboard boxes, a tiny hole and an image of the Sun projected safely onto the inside. No screens, no apps, no live streams. Just a little glowing circle of light and the slightly strange feeling that something unusual was happening above us.

    With another solar eclipse arriving on Wednesday 12 August 2026, I wanted to revisit that memory, but through generative art.

    Watch my live simulation here

    A digital pinhole viewer

    The idea for this project is deliberately simple.

    The entire sky is constructed from a grid of tiny dots. In the centre, brighter yellow and white dots form the Sun, while shades of sky blue create the surrounding atmosphere.

    Rather than drawing recognisable clouds, slowly moving noise passes through the grid. It creates subtle areas of light and shade that drift across the image — more like changing atmospheric conditions than illustrated clouds.

    The dot-matrix appearance is a little nod back to available technology back then. The image isn’t trying to reproduce the sky perfectly. It’s reducing it to light, dark and a grid of tiny marks.

    Following the real eclipse

    The project has two modes.

    Simulate compresses the entire eclipse into a short animation, allowing me to experiment with the effect at any time.

    Live is the more interesting one.

    On 12 August, the artwork follows the actual time of day and the progression of the eclipse. The sky begins as a light blue around #87CEEB, gradually changes with the natural daylight, and becomes darker as more of the Sun is obscured.

    As the Moon moves across the Sun, its dots are progressively swallowed by the darker grid. The surrounding sky responds at the same time, before gradually becoming lighter again as the Moon moves away.

    Because the eclipse is happening towards the evening, the natural transition towards sunset is happening at the same time. The two systems overlap: the real day is getting darker while the eclipse temporarily makes it darker still.

    Taking the cardboard version with us

    The digital version won’t be our only viewer.

    We’ll be heading to Moor Park in Preston with our pinhole box viewers to watch the real thing.

    A free community viewing event starts at 5.45pm, with astronomers from the University of Lancashire and Preston and District Astronomical Society bringing specialist equipment and eclipse glasses so people can observe it safely.

    It’s being billed as the UK’s deepest solar eclipse in over a decade, with the Moon covering up to 96% of the Sun in parts of the UK.

    So while there will be plenty of sophisticated astronomical equipment pointing towards the sky, I quite like the idea that we’ll also be standing there with a cardboard box.

    Some technology is difficult to improve upon.

    And somewhere nearby, my devices will be doing essentially the same thing — turning the Sun into a collection of little dots and watching them disappear.

    Watch my live simulation here

  • What if washing up looked like a solar eclipse?

    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…