UI Lab

Text breaking apart into dust

Angular scatter + noise jitter

Explosion, detonation, shrapnel

Strong radial push + glow spike

Glass shatter, breaking, fragmentation

Hash-based random direction per particle

VHS tracking, datamosh, corrupted data

Quantized time steps + teleport offsets

Confetti, celebration, party popper

Hash scatter + gravity + random brightness

Expansion, flower bloom, outward spiral

Spiral with growing radius

Wind, gust, blowing, drift

Slowly rotating wind dir + turbulence

Whirlpool, tornado, centrifugal spin

Orbit at current distance

Black hole, gravity well, singularity

Pull inward + shrink point size

Galaxy, nebula, fibonacci spiral

Two-arm spiral with distance wrap

Drain, whirlpool, toilet flush

Fast rotation + shrinking radius + sink z

Assembling, gathering, magnetic convergence

Mix to cursor + orbital offset

Magnetic alignment, crystallization, lattice snap

Snap to grid lattice + intersection glow

Earthquake, vibration, trembling

High-freq sin with per-particle phase

Balloon inflating, expansion, swelling

Uniform outward expansion + z-push

Gravity, falling, dropping

Fall down + horizontal sway

Water parting, laminar flow, viscous fluid

Tangent flow with side sign

Camera focus pull, depth of field, dreamy blur

Z-depth push + alpha fade

Taffy pull, elastic stretch, rubber band

Pull along home-to-cursor direction

Breathing, meditation, organic pulse

Slow 0..1 cycle + outward expansion

Depth of field, 3D parallax, z-space push

Z-depth push + xy shift + fade

Shape morphing, text-to-circle, transformation

Mix to circle positions around cursor

Slicing, cutting, text cleaving in two

Top/bottom split + opposite slides + gap glow

Pinch, squeeze, accordion compression

Pull to horizontal line + expand outward

Wringing, twisting, torsion

Rotation by height around vertical axis

Flattening, squishing, pancake

Compress vertically + expand horizontally + z-push

Campfire, sparks, hot ash rising

Rise + flicker drift + intense glow

Matrix digital rain, cascading code

Quantized columns + cyclic fall + leading edge

Starry night, twinkling stars, celestial map

Twinkle sines + glow pulse, no displacement

Magnifying glass, lens distortion, refraction

Magnify inside ring + edge glow

Quantum superposition, teleportation, uncertainty

Discrete time steps + random teleport + mask

Planetary orbit, satellite, stable rotation

Stable circular orbit at current distance

TV static, white noise, signal lost

Hash-based random on all 3 axes

Hourglass, sand timer, granular flow

Accelerated fall + horizontal pile spread

Bubbles, effervescence, carbonation

Rise + wobble + soft pulse glow

Comet tail, motion trail, streak

Trail behind cursor velocity + head glow

Ink in water, diffusion, bleeding

Slow turbulent flow + dark intense glow

Particles fall from above into position

origin.y = target.y + offset, gravity-like ease

Particles slide in from the right edge

origin.x = target.x + canvasW, linear ease

Particles slide in from the left edge

origin.x = target.x - canvasW

Particles slide in from the bottom

origin.y = target.y - canvasH

Particles slide in from the top

origin.y = target.y + canvasH

Particles slide in from top-left corner

origin.x -= W, origin.y += H

Particles slide in from top-right corner

origin.x += W, origin.y += H

Particles slide in from bottom-left

origin.x -= W, origin.y -= H

Particles slide in from bottom-right

origin.x += W, origin.y -= H

Particles converge from all screen edges

origin = edge nearest to target

Particles start at center, diverge outward to targets

origin = center, mix to target

Sharp deceleration (current default)

ease = 1 - (1-t)^3

Even sharper deceleration

ease = 1 - (1-t)^5

Exponential deceleration

ease = 1 - pow(2, -10 * t)

Gentle sine deceleration

ease = sin(t * PI / 2)

Overshoot then settle back

ease = 1 + 2.7 * pow(t-1, 3) + 1.7 * pow(t-1, 2)

Bouncy spring with oscillation

ease = sin(t * PI * 3) * pow(2, -10*t)

Multiple bounces

Piecewise: ease = bounce(t)

Circular deceleration

ease = sqrt(1 - pow(1-t, 2))

Constant speed

ease = t

Particles start on a cube surface

origin = cubeFace(face, uv)

Particles start on a grid lattice

origin = floor(random * grid) * cell

Particles start on a circle ring

origin = circle(angle, radius)

Particles start on a line

origin = line(t, axis)

Particles start as a random cloud

origin = random * spread

Particles start on a spiral

origin = spiral(angle, r)

Particles start on a torus

origin = torus(u, v)

Particles start on a wave surface

origin = wave(x, y, t)

Particles start scattered, implode to targets

origin = random * 3W, mix inward

Particles burst from center outward then settle

origin = center, expand past target, settle

Multiple burst points, particles fly to targets

origin = burstPoint + random * burst

Particles spiral inward from outer ring

origin = spiral(angle, maxR)

Particles twist down/up into position

origin = spiral + heightOffset

Particles orbit center, then spiral into targets

angle = t * speed, r = lerp(maxR, dist, ease)

Particles scatter outward then gather back

Phase 1: expand, Phase 2: contract to target

Particles blink in sequentially at full opacity

if t > delay: alpha = 1, no movement

Particles blink in at random quantum times

delay = random * duration, instant appear

Particles start blocky/quantized, smooth to text

origin = floor(target / gridSize) * gridSize

Particles materialize from noise pattern

alpha = noise(target.xy, t) > threshold

Particles fade in with slight scatter, then settle

alpha = ease, pos = target + scatter * (1-ease)

Particles start with large z-spread, focus to plane

origin.z = random * spread, mix z to 0

Particles start at 0 size, grow to full size

pointSize = uSize * ease, no movement

Particles start huge, shrink to normal size

pointSize = uSize * (1 + (1-ease) * 10)

Particles rotate in on X axis (3D flip)

angleX = (1-ease) * PI, pos.z = sin(angle) * depth

Particles rotate in on Y axis (3D flip)

angleY = (1-ease) * PI, pos.x += sin(angle) * depth

Particles cascade in like dominoes falling

delay = i / count * duration, sequential

Particles flow in like liquid, viscous motion

origin = offscreen, pos = origin + flow(t)

Stars twinkle in sequentially, then connect

delay = random, alpha = twinkle(t, delay)

Letter-by-letter reveal

delay = charIndex * charDelay, per-letter

Particles split from center, open like curtains

origin.x = target.x ± (W/2 * (1-ease))

Particles appear in horizontal strips sequentially

delay = floor(yNorm * strips) / strips

Particles appear following a scanning line

delay = yNorm, bright scanline at y = progress

Particles glitch in with random offsets then settle

origin = target + glitch, glitch decreases with t

Particles spread from a point like ink in water

origin = point, r = ease * dist, turbulent