Author: Scott Pollard

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.

---

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…

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.

---