5.1.1 Sand Simulation

Staggered starts — each grain draws its delay from random.gauss(50, 15). The Gaussian peaks at frame 50 but spreads across roughly frames 20–80, so the desert peels away in waves rather than as one moving block. That peel mirrors how real wind lifts loose particles unevenly.

Curved paths — the initial velocity_y is small but nonzero, so each grain drifts vertically as well as horizontally. That tiny perpendicular component is what makes the trajectory look “turbulent” instead of ruler-straight.

Exponential speed-up — once a grain’s velocity_x exceeds 1, the update applies velocity_x *= 1.08, which is geometric growth. After thirty moving frames a grain is ten times faster than when it started. That is the visual signature of acceleration as opposed to drift.

In update, flip the sign of the acceleration:

if self.velocity_x > -1.0:
    self.velocity_x -= 0.2
else:
    self.velocity_x *= 1.08

Also flip the exit check (self.x <= 0) so off-canvas-left grains finish. The desert reads right-to-left and the dark “waiting” pixels are revealed in reverse.

Accelerate velocity_y instead of velocity_x. A constant downward +0.3 per frame mimics gravity (sand on Earth falls at 9.81 m/s², but we are working in pixels per frame so this is a unit choice rather than a physics fact). The grains stream straight down, fanning slightly because each one starts at a different x.

self.delay = max(0, int(random.gauss(10, 5))). Now most delays fall in the 5–15 range. The whole field starts moving by frame 20, which trades the “peeling” effect for a uniform shove. Useful when you want a single gust rather than a continuous wind.

Set SAND_BASE = (255, 120, 50) and shift the per-grain colour jitter toward reds and yellows:

self.color = (
    random.randint(200, 255),
    random.randint(50, 150),
    random.randint(0, 50),
)

The desert now reads as Mars — same physics, different palette. Colour is the cheapest narrative tool in generative art.

class Particle:
    def __init__(self, x, y):
        self.x, self.y = float(x), float(y)
        self.is_active = True
        self.velocity_x = random.uniform(-0.3, 0.3)
        self.velocity_y = random.uniform(3, 5)
        self.color = (
            random.randint(150, 200),
            random.randint(200, 230),
            255,
        )

    def update(self):
        if not self.is_active:
            return
        self.x += self.velocity_x
        self.y += self.velocity_y
        if self.y > HEIGHT:
            self.is_active = False

Spawn along the full width at y = random.randint(-50, 0) so drops trickle in rather than appearing all at once.

import math

class Particle:
    def __init__(self, x, y):
        self.x, self.y = float(x), float(y)
        self.is_active = True
        self.velocity_y = random.uniform(-2, -1)
        self.phase = random.uniform(0, 2 * math.pi)
        self.age = 0
        self.color = (
            random.randint(100, 150),
            random.randint(200, 230),
            255,
        )

    def update(self):
        if not self.is_active:
            return
        self.age += 1
        self.x += math.sin(self.age * 0.1 + self.phase) * 0.5
        self.y += self.velocity_y
        if self.y < 0:
            self.is_active = False

Each bubble has its own phase so the wiggle is desynchronised — without that, every bubble would weave left and right in lockstep and the swarm would look like a marching band.

import math

class Particle:
    def __init__(self, x, y):
        self.x, self.y = float(x), float(y)
        self.is_active = True
        angle = random.uniform(0, 2 * math.pi)
        speed = random.uniform(3, 8)
        self.velocity_x = math.cos(angle) * speed
        self.velocity_y = math.sin(angle) * speed
        self.color = (
            random.randint(100, 255),
            random.randint(100, 255),
            random.randint(100, 255),
        )

    def update(self):
        if not self.is_active:
            return
        self.x += self.velocity_x
        self.y += self.velocity_y
        self.velocity_x *= 0.98  # friction
        self.velocity_y *= 0.98
        self.velocity_y += 0.1   # gravity
        if self.x < 0 or self.x > WIDTH or self.y > HEIGHT:
            self.is_active = False

Spawning all particles at the centre with uniformly-random angles produces a clean circular burst. Adding the small gravity term makes it sag — the difference between fireworks and a soap-bubble pop.