Scott Pollard — Design, Code & Art

Category: Generative Art

Finished artworks and collections created with code.

  • 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.

  • 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.

  • 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…

  • Study 03: Random

    Study 03: Random

    What if the computer only gave the instructions?

    For Study 003, I wanted to move away from using code to create the finished image.

    Instead, the computer would simply tell me what to do.

    The Processing sketch creates an invisible square grid. Each position in the grid is randomly assigned one of seven possible instructions:

    .↓      Colour 1 / down
..↓     Colour 2 / down
...↓    Colour 3 / down

.→      Colour 1 / right
..→     Colour 2 / right
...→    Colour 3 / right

blank   No mark

    The number of dots tells me which of three brush pen colours to use, while the arrow tells me whether to make the mark horizontally or vertically.

    That’s all the computer decides.

    Random within rules

    Unlike the previous two studies, there isn’t a mathematical relationship between one grid position and the next.

    Processing randomly chooses from the seven possible outcomes:

    int outcome = int(random(7));

    This means every generated sheet is different, but the randomness is still tightly controlled. The computer can only choose from the rules I’ve given it.

    Adding the blank or null instruction turned out to be particularly important. Without it, every position had to contain a mark and the results became very dense. Empty cells introduce gaps and allow irregular areas of white space to form naturally.

    From code to paper

    I printed the generated instructions onto A4 paper in a very light grey and then worked through the grid by hand with three brush pens.

    This is where the computer loses control.

    The algorithm determines the colour, position and direction, but it can’t determine exactly how I make the mark. Pressure changes. Lines aren’t perfectly straight. Some strokes are wider than others. Colours behave differently on the paper.

    Repeating the same generated process with different sets of three colours also produces surprisingly different results.

    What starts as a rigid grid of random computer instructions becomes something much less precise once it’s interpreted by hand.

    For me, that’s the interesting part of this study: the code creates the rules, randomness creates the composition, and the hand creates the final image.

  • Study 02: Addition

    Study 02: Addition

    For the second experiment in this series, I wanted to keep the rules almost identical to the first project and change just one thing.

    Study 01 used multiplication to determine the rotation of each line. This time, I’ve replaced the lines with outlined squares and changed the mathematics from multiplication to addition.

    The question became:

    What if every square knew where it was?

    Each square sits within a regular grid. Its position is described by two values: its column and its row. Instead of multiplying those values together, I simply add them.

    float angle = radians(column + row);

    Every square is then rotated by the angle produced from that calculation.

    The result is surprisingly different. Squares that share the same column + row value also share the same rotation, creating gentle diagonal bands that flow across the composition. Where the multiplication project felt more complex and unpredictable, this one feels calmer and much more structured.

    Nothing else changes.

    • The grid remains fixed.
    • Every square is the same size.
    • Every outline has the same weight.
    • Only the mathematical relationship has changed.

    This is what fascinates me about working in code. A tiny adjustment to a single formula can completely alter the visual language of the piece.

    Like the first project, this isn’t about creating a finished artwork. It’s about asking a simple question, changing one variable, and observing what happens.

    Sometimes the smallest mathematical change produces the biggest visual surprise.

  • Experiments: What if every line had a memory?

    Experiments: What if every line had a memory?

    What if every line could remember the moment it was created?

    This project explores that thought by treating every line as its own little life. Each one is born with a timestamp, a unique set of characteristics and its own colourful identity. Some grow quickly, some take their time. Some live long lives, while others disappear much sooner.

    As each line ages, it slowly grows, changing direction as it travels. Every twist and turn becomes part of its story. Although the movement appears random, each line is confined to its own invisible space, giving every life a set of boundaries it can never leave.

    When a line reaches the end of its lifespan, it doesn’t simply vanish. It fades to a soft grey and remains on the canvas as a memory of where it has been, while a new generation begins its own journey.

    Watching the artwork over time reveals hundreds of small, individual stories unfolding at once. Some areas become dense with memories, while others remain surprisingly sparse. No two runs are ever the same.

    Like many of my projects, this started with a simple question. It isn’t trying to represent anything literally; it’s more about exploring how a few straightforward rules can create something that feels surprisingly human.

  • How AI Helped Me Bridge the Gap Between Code and Art

    How AI Helped Me Bridge the Gap Between Code and Art

    I’ve always felt like I’ve had one foot in two different worlds.

    I’ve been creating art for as long as I can remember, and I’ve worked as a developer for years. The strange thing is that those two passions rarely overlapped as much as I wanted them to.

    When you’re learning to code professionally, your focus is very different. You’re learning how to solve problems, build websites, create applications and deliver reliable products. It’s practical, structured and driven by deadlines. There isn’t always much room to explore creativity through code.

    That meant there was always a gap between the ideas I could imagine as an artist and the code I was capable of writing.

    A few years ago I took some fantastic courses by one of my biggest inspirations, Joshua Davis. They introduced me to Processing and the HYPE Framework, opening my eyes to generative art and what was possible when design and programming came together.

    It completely changed how I thought about code.

    Even so, I still felt limited. I understood the concepts, but many of the ideas in my sketchbook felt just out of reach. I knew what I wanted to create, but I didn’t always know how to translate those thoughts into algorithms.

    Then came ChatGPT.

    For me, AI hasn’t replaced the creative process—it has unlocked it.

    Instead of staring at a blank editor wondering where to begin, I can now describe an image that’s only ever existed in my head. We can discuss the mathematics behind it, break down the logic, experiment with different approaches and iterate rapidly until the code starts producing something unexpected and exciting.

    More importantly, the conversation doesn’t stop once the first version works.

    What if the shapes reacted to sound?

    What if the colours were driven by live data?

    Could gravity affect typography?

    What if every square behaved like its own tiny organism?

    Those are the kinds of conversations that happen almost daily now. One idea naturally leads to another, and projects evolve far beyond where I originally imagined they would.

    It’s also become an incredible learning tool. Rather than simply copying code, I can ask why something works, explore different mathematical approaches, simplify algorithms and understand concepts that would previously have taken days of research.

    Every project teaches me something new.

    The more I create, the more confident I become writing Processing sketches myself. AI isn’t writing my artwork—it has become a creative collaborator that helps me turn abstract ideas into working prototypes that I can refine, question and develop.

    Looking back, the biggest barrier wasn’t a lack of imagination.

    It was the distance between imagination and implementation.

    AI has shortened that distance dramatically.

    This blog is becoming a record of that journey—experimenting, learning, making mistakes and discovering new ways to combine art, mathematics and code. Every project starts with a simple question: “What if…?”

    Now, for the first time, I feel like I have the tools to find the answer.