diff --git a/crates/effects/src/sim.rs b/crates/effects/src/sim.rs
index dc8d20ed..024a91fc 100644
--- a/crates/effects/src/sim.rs
+++ b/crates/effects/src/sim.rs
@@ -1,7 +1,1530 @@
-//! Simulation effects (particles, physics, liquids).
+//! Simulation effects (particles, physics, liquids): CC Rainfall, CC Snowfall, CC Bubbles,
+//! CC Drizzle, CC Star Burst, CC Particle World, CC Particle Systems II and CC Mr. Mercury.
+//!
+//! Written from the public descriptions of the effects' behaviour. Weather/bubble/star effects
+//! are closed-form functions of time (every frame independent); particle systems are stepped
+//! from layer time 0 at a fixed rate through [`SimCache`], so any frame can be rendered
+//! directly and equals the frame reached by scrubbing.
+//!
+//! Shared here (also used by `sim2`): a band-bucketed rasteriser for many small items
+//! ([`raster`]), particle sprites ([`Sprite`]) and transfer-mode compositing ([`combine`]).
 
-use crate::EffectSpec;
+use effectcraft_keyframe::Value;
+use effectcraft_project::ParamUi;
+use effectcraft_raster::{Image, Px};
+use rayon::prelude::*;
+
+use crate::generate::value_noise;
+use crate::util::{SimCache, hash1, params_key, unpremul};
+use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider};
+
+pub(crate) fn spec(id: &'static str, name: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
+    EffectSpec { id, name, category: "Simulation", params, render, gpu: false, float: true }
+}
+
+pub(crate) fn pt(x: f64, y: f64) -> Value {
+    Value::Vec2([x, y])
+}
+
+pub(crate) fn pct() -> ParamUi {
+    slider(0.0, 100.0, 0.0, 100.0, 1)
+}
+
+/// Deterministic hash → [0, 1).
+#[inline]
+pub(crate) fn h(i: u32, k: u32, seed: u32) -> f32 {
+    hash1(i, k, seed)
+}
+
+/// Signed hash → [-1, 1).
+#[inline]
+pub(crate) fn hs(i: u32, k: u32, seed: u32) -> f32 {
+    hash1(i, k, seed) * 2.0 - 1.0
+}
+
+// ------------------------------------------------------------------ band rasteriser
+
+const BAND: usize = 16;
+
+/// How rasterised items combine with what is already in the target.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum Acc {
+    /// Premultiplied "over" (later items on top).
+    Over,
+    /// Additive (glows, light).
+    Add,
+}
+
+/// Rasterise many small items into `img` (buffer pixels). `bbox` gives an item's pixel bounds
+/// `[x0, y0, x1, y1]` (or `None` to skip), `shade` its premultiplied colour at a pixel centre.
+/// Items are bucketed into horizontal bands rendered in parallel; within a band they are drawn
+/// in slice order.
+pub(crate) fn raster<T: Sync>(
+    img: &mut Image,
+    items: &[T],
+    bbox: impl Fn(&T) -> Option<[f32; 4]> + Sync,
+    shade: impl Fn(&T, f32, f32) -> Option<Px> + Sync,
+    acc: Acc,
+) {
+    let (w, hgt) = (img.width as usize, img.height as usize);
+    if w == 0 || hgt == 0 || items.is_empty() {
+        return;
+    }
+    let nb = hgt.div_ceil(BAND);
+    let boxes: Vec<Option<[i32; 4]>> = items
+        .par_iter()
+        .map(|it| {
+            let b = bbox(it)?;
+            if !(b[0].is_finite() && b[1].is_finite() && b[2].is_finite() && b[3].is_finite()) {
+                return None;
+            }
+            let x0 = b[0].floor().max(0.0) as i32;
+            let y0 = b[1].floor().max(0.0) as i32;
+            let x1 = (b[2].ceil() as i32).min(w as i32 - 1);
+            let y1 = (b[3].ceil() as i32).min(hgt as i32 - 1);
+            if x1 < x0 || y1 < y0 || b[2] < 0.0 || b[3] < 0.0 {
+                return None;
+            }
+            Some([x0, y0, x1, y1])
+        })
+        .collect();
+    let mut buckets: Vec<Vec<u32>> = vec![Vec::new(); nb];
+    for (i, b) in boxes.iter().enumerate() {
+        if let Some(b) = b {
+            for band in (b[1] as usize / BAND)..=(b[3] as usize / BAND).min(nb - 1) {
+                buckets[band].push(i as u32);
+            }
+        }
+    }
+    img.data.par_chunks_mut(w * BAND).enumerate().for_each(|(band, chunk)| {
+        let by0 = band * BAND;
+        let rows = chunk.len() / w;
+        for &i in &buckets[band] {
+            let Some(b) = boxes[i as usize] else { continue };
+            let it = &items[i as usize];
+            let ya = (b[1] as usize).max(by0);
+            let yb = (b[3] as usize).min(by0 + rows - 1);
+            for y in ya..=yb {
+                let row = &mut chunk[(y - by0) * w..(y - by0 + 1) * w];
+                for x in b[0] as usize..=b[2] as usize {
+                    if let Some(c) = shade(it, x as f32 + 0.5, y as f32 + 0.5) {
+                        let d = &mut row[x];
+                        match acc {
+                            Acc::Over => {
+                                let k = 1.0 - c[3];
+                                *d = [c[0] + d[0] * k, c[1] + d[1] * k, c[2] + d[2] * k, c[3] + d[3] * k];
+                            }
+                            Acc::Add => {
+                                *d = [d[0] + c[0], d[1] + c[1], d[2] + c[2], (d[3] + c[3]).min(1.0)];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+
+// ------------------------------------------------------------------ sprites
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub(crate) enum Shape {
+    /// Soft round dot (Gaussian-like falloff).
+    Soft,
+    /// Hard anti-aliased disc.
+    Disc,
+    /// Lit sphere (upper-left light, specular).
+    Sphere,
+    /// Disc fading linearly to its rim.
+    Faded,
+    /// Thin ring with a highlight.
+    Bubble,
+    /// Four-point star.
+    Star,
+    /// Rotated square (angle in `rot`).
+    Square,
+    /// Triangle (angle in `rot`).
+    Tri,
+    /// Segment from (x, y) by (dx, dy), half-width `r`.
+    Line { dx: f32, dy: f32 },
+}
+
+/// A particle sprite in buffer pixels; `c` is straight colour + opacity.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Sprite {
+    pub x: f32,
+    pub y: f32,
+    pub r: f32,
+    pub c: [f32; 4],
+    pub shape: Shape,
+    pub rot: f32,
+}
+
+impl Sprite {
+    pub(crate) fn new(x: f32, y: f32, r: f32, c: [f32; 4], shape: Shape) -> Sprite {
+        Sprite { x, y, r, c, shape, rot: 0.0 }
+    }
+}
+
+fn sprite_bbox(s: &Sprite) -> Option<[f32; 4]> {
+    if s.c[3] <= 1e-5 || s.r <= 0.0 {
+        return None;
+    }
+    let r = s.r.max(0.5) + 1.0;
+    Some(match s.shape {
+        Shape::Line { dx, dy } => [s.x.min(s.x + dx) - r, s.y.min(s.y + dy) - r, s.x.max(s.x + dx) + r, s.y.max(s.y + dy) + r],
+        Shape::Star => [s.x - r * 2.0, s.y - r * 2.0, s.x + r * 2.0, s.y + r * 2.0],
+        _ => [s.x - r, s.y - r, s.x + r, s.y + r],
+    })
+}
+
+#[inline]
+fn aa(edge: f32) -> f32 {
+    (edge + 0.5).clamp(0.0, 1.0)
+}
+
+fn sprite_shade(s: &Sprite, x: f32, y: f32) -> Option<Px> {
+    // Sub-pixel sprites keep their energy: draw at radius 0.5 with reduced opacity.
+    let (r, fade) = if s.r < 0.5 { (0.5, s.r / 0.5) } else { (s.r, 1.0) };
+    let (dx, dy) = (x - s.x, y - s.y);
+    let mut rgb = [s.c[0], s.c[1], s.c[2]];
+    let cov = match s.shape {
+        Shape::Soft => {
+            let d2 = (dx * dx + dy * dy) / (r * r);
+            if d2 >= 1.0 {
+                return None;
+            }
+            let q = 1.0 - d2;
+            q * q
+        }
+        Shape::Disc => aa(r - (dx * dx + dy * dy).sqrt()),
+        Shape::Faded => {
+            let d = (dx * dx + dy * dy).sqrt() / r;
+            (1.0 - d).max(0.0).powf(1.5)
+        }
+        Shape::Sphere => {
+            let d = (dx * dx + dy * dy).sqrt();
+            let cv = aa(r - d);
+            if cv <= 0.0 {
+                return None;
+            }
+            let (nx, ny) = (dx / r, dy / r);
+            let nz = (1.0 - nx * nx - ny * ny).max(0.0).sqrt();
+            let (lx, ly, lz) = (-0.48, -0.58, 0.66);
+            let diff = (nx * lx + ny * ly + nz * lz).max(0.0);
+            let rz = 2.0 * diff * nz - lz;
+            let spec = rz.max(0.0).powi(20) * 0.6;
+            let k = 0.2 + 0.8 * diff;
+            rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
+            cv
+        }
+        Shape::Bubble => {
+            let d = (dx * dx + dy * dy).sqrt() / r;
+            if d > 1.0 + 1.0 / r {
+                return None;
+            }
+            let ring = (1.0 - ((d - 0.9) / 0.12).powi(2)).max(0.0);
+            let hl = (1.0 - (((dx / r) + 0.4).powi(2) + ((dy / r) + 0.4).powi(2)) / 0.04).max(0.0);
+            (0.12 * (d <= 1.0) as u8 as f32 + ring * 0.8 + hl).min(1.0)
+        }
+        Shape::Star => {
+            let (sn, cs) = s.rot.sin_cos();
+            let (ux, uy) = ((dx * cs + dy * sn) / r, (-dx * sn + dy * cs) / r);
+            let d = (ux * ux + uy * uy).sqrt();
+            let core = (1.0 - d).max(0.0).powi(2);
+            let sx = (1.0 - ux.abs() / 2.0).max(0.0) * (1.0 - (uy.abs() * 6.0)).max(0.0);
+            let sy = (1.0 - uy.abs() / 2.0).max(0.0) * (1.0 - (ux.abs() * 6.0)).max(0.0);
+            (core + sx + sy).min(1.0)
+        }
+        Shape::Square => {
+            let (sn, cs) = s.rot.sin_cos();
+            let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
+            let e = r * 0.75;
+            aa(e - ux.abs()) * aa(e - uy.abs())
+        }
+        Shape::Tri => {
+            let (sn, cs) = s.rot.sin_cos();
+            let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
+            // Equilateral triangle with circumradius r: three half-planes.
+            let e = r * 0.5;
+            let mut m = f32::INFINITY;
+            for k in 0..3 {
+                let a = std::f32::consts::FRAC_PI_2 + k as f32 * std::f32::consts::TAU / 3.0;
+                let (ns, nc) = a.sin_cos();
+                m = m.min(e - (ux * nc + uy * ns));
+            }
+            aa(m)
+        }
+        Shape::Line { dx: lx, dy: ly } => {
+            let l2 = lx * lx + ly * ly;
+            let t = if l2 > 0.0 { ((dx * lx + dy * ly) / l2).clamp(0.0, 1.0) } else { 0.0 };
+            let (px, py) = (dx - lx * t, dy - ly * t);
+            aa(r - (px * px + py * py).sqrt())
+        }
+    };
+    let a = cov * s.c[3] * fade;
+    if a <= 1e-6 {
+        return None;
+    }
+    Some([rgb[0] * a, rgb[1] * a, rgb[2] * a, a])
+}
+
+/// Draw sprites into a new transparent image of `w`×`h`.
+pub(crate) fn splat(w: u32, hgt: u32, sprites: &[Sprite], acc: Acc) -> Image {
+    let mut img = Image::new(w, hgt);
+    raster(&mut img, sprites, sprite_bbox, sprite_shade, acc);
+    img
+}
+
+/// Combine an effect layer `fx` with the original `src` (both premultiplied, same size):
+/// 0 Composite (fx over src), 1 Screen, 2 Add, 3 Lighten, 4 Darken, 5 fx only.
+pub(crate) fn combine(src: &Image, fx: &Image, mode: u32) -> Image {
+    let mut out = fx.clone();
+    out.data.par_iter_mut().zip(src.data.par_iter()).for_each(|(o, s)| {
+        let f = *o;
+        *o = match mode {
+            0 => {
+                let k = 1.0 - f[3];
+                [f[0] + s[0] * k, f[1] + s[1] * k, f[2] + s[2] * k, f[3] + s[3] * k]
+            }
+            1 => [s[0] + f[0] - s[0] * f[0], s[1] + f[1] - s[1] * f[1], s[2] + f[2] - s[2] * f[2], s[3] + f[3] - s[3] * f[3]],
+            2 => [s[0] + f[0], s[1] + f[1], s[2] + f[2], (s[3] + f[3]).min(1.0)],
+            3 => [s[0].max(f[0]), s[1].max(f[1]), s[2].max(f[2]), s[3] + f[3] - s[3] * f[3]],
+            4 => {
+                let (fc, fa) = unpremul(f);
+                let m = |c: f32, k: usize| c - (c - c.min(fc[k] * s[3])) * fa;
+                [m(s[0], 0), m(s[1], 1), m(s[2], 2), s[3]]
+            }
+            _ => f,
+        };
+    });
+    out
+}
+
+// ------------------------------------------------------------------ CC Rainfall / CC Snowfall
+
+/// Shared weather layout: per-item depth factor `k` in (0, 1] (1 = nearest) from Scene Depth.
+#[inline]
+fn depth_k(z: f32, scene_depth: f32) -> f32 {
+    1.0 / (1.0 + z * scene_depth / 2500.0)
+}
+
+/// Wrap `v` into `[lo, lo + span)`.
+#[inline]
+fn wrap(v: f32, lo: f32, span: f32) -> f32 {
+    if span <= 0.0 { v } else { lo + (v - lo).rem_euclid(span) }
+}
+
+fn rainfall(ctx: &EffectCtx, b: Buf) -> Buf {
+    let pr = ctx.params;
+    let n = pr.f("drops").clamp(0.0, 100_000.0) as u32;
+    let size = pr.f("size").max(0.0) as f32;
+    let depth = pr.f("sceneDepth").max(0.0) as f32;
+    let speed = pr.f("speed") as f32;
+    let wind = pr.f("wind") as f32;
+    let wvar = pr.f("windVariation") as f32 / 100.0;
+    let spread = pr.f("spread") as f32;
+    let color = pr.color("color");
+    let opacity = pr.f("opacity") as f32 / 100.0;
+    let mode = pr.e("transferMode");
+    let with_orig = pr.b("compositeWithOriginal");
+    let refract = pr.e("appearance") == 0;
+    let off = pr.v2("offset");
+    let seed = pr.f("randomSeed") as u32 ^ ctx.seed.wrapping_mul(0x9e37);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let src = &b.img;
+    let (ox, oy) = (off[0] as f32 - lw * 0.5, off[1] as f32 - lh * 0.5);
+    let sprites: Vec<Sprite> = (0..n)
+        .into_par_iter()
+        .filter_map(|i| {
+            let z = h(i, 1, seed);
+            let k = depth_k(z, depth);
+            let vy = speed / 4000.0 * lh * 2.2 * k;
+            let w = wind / 1000.0 * lh * (1.0 + wvar * hs(i, 2, seed)) * k + spread * hs(i, 7, seed) * k;
+            let len = (vy * 0.04 * size.max(0.2)).max(1.0);
+            let lenx = w * 0.04 * size.max(0.2);
+            let margin = len + lenx.abs() + 4.0;
+            let y = wrap(h(i, 3, seed) * (lh + 2.0 * margin) + vy * t + oy, -margin, lh + 2.0 * margin);
+            let x = wrap(h(i, 4, seed) * (lw + 2.0 * margin) + w * t + ox, -margin, lw + 2.0 * margin);
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let mut c = [color[0], color[1], color[2], opacity * (0.35 + 0.65 * k)];
+            if refract {
+                // Refracting drops show the scene behind them, brightened and offset.
+                let (sc, sa) = unpremul(src.sample_bilinear(bx + 2.0 * s as f64, by));
+                let m = |a: f32, cc: f32| (a * 0.6 + 0.5) * cc;
+                if sa > 0.0 {
+                    c = [m(sc[0], color[0]), m(sc[1], color[1]), m(sc[2], color[2]), c[3]];
+                }
+            }
+            let r = (size * 0.6 * k * s).max(0.25);
+            Some(Sprite::new(bx as f32, by as f32, r, c, Shape::Line { dx: -lenx * s, dy: -len * s }))
+        })
+        .collect();
+    weather_out(b, &sprites, mode, with_orig)
+}
+
+fn weather_out(mut b: Buf, sprites: &[Sprite], mode: u32, with_orig: bool) -> Buf {
+    let fx = splat(b.img.width, b.img.height, sprites, Acc::Over);
+    b.img = if with_orig { combine(&b.img, &fx, if mode == 1 { 3 } else { 0 }) } else { fx };
+    b
+}
+
+fn snowfall(ctx: &EffectCtx, b: Buf) -> Buf {
+    let pr = ctx.params;
+    let n = pr.f("flakes").clamp(0.0, 200_000.0) as u32;
+    let size = pr.f("size").max(0.0) as f32;
+    let svar = pr.f("sizeVariation") as f32 / 100.0;
+    let depth = pr.f("sceneDepth").max(0.0) as f32;
+    let speed = pr.f("speed") as f32;
+    let spvar = pr.f("speedVariation") as f32 / 100.0;
+    let wind = pr.f("wind") as f32;
+    let wvar = pr.f("windVariation") as f32 / 100.0;
+    let spread = pr.f("spread") as f32;
+    let wig = pr.f("wiggleAmount") as f32;
+    let wigvar = pr.f("wiggleAmountVariation") as f32 / 100.0;
+    let wfreq = pr.f("wiggleFrequency") as f32;
+    let wfvar = pr.f("wiggleFrequencyVariation") as f32 / 100.0;
+    let color = pr.color("color");
+    let opacity = pr.f("opacity") as f32 / 100.0;
+    let mode = pr.e("transferMode");
+    let with_orig = pr.b("compositeWithOriginal");
+    let off = pr.v2("offset");
+    let seed = pr.f("randomSeed") as u32 ^ ctx.seed.wrapping_mul(0x85eb);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let (ox, oy) = (off[0] as f32 - lw * 0.5, off[1] as f32 - lh * 0.5);
+    let sprites: Vec<Sprite> = (0..n)
+        .into_par_iter()
+        .map(|i| {
+            let z = h(i, 1, seed);
+            let k = depth_k(z, depth);
+            let r = (size * 0.5 * k * (1.0 + svar * hs(i, 2, seed))).max(0.05);
+            let vy = speed * (lh / 600.0) * k * (1.0 + spvar * hs(i, 3, seed));
+            let vx = wind * (lh / 1200.0) * k * (1.0 + wvar * hs(i, 4, seed)) + spread * hs(i, 8, seed) * k;
+            let amp = wig * 2.0 * k * (1.0 + wigvar * hs(i, 5, seed));
+            let fr = wfreq * (1.0 + wfvar * hs(i, 6, seed));
+            let ph = h(i, 9, seed) * std::f32::consts::TAU;
+            let margin = r + amp.abs() + 2.0;
+            let y = wrap(h(i, 10, seed) * (lh + 2.0 * margin) + vy * t + oy, -margin, lh + 2.0 * margin);
+            let x = wrap(h(i, 11, seed) * (lw + 2.0 * margin) + vx * t + ox, -margin, lw + 2.0 * margin) + amp * (fr * t * std::f32::consts::TAU + ph).sin();
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            Sprite::new(bx as f32, by as f32, r * s, [color[0], color[1], color[2], opacity * (0.4 + 0.6 * k)], Shape::Soft)
+        })
+        .collect();
+    weather_out(b, &sprites, mode, with_orig)
+}
+
+// ------------------------------------------------------------------ CC Bubbles
+
+struct Bubble {
+    x: f32,
+    y: f32,
+    r: f32,
+    /// Source sample centre (buffer px).
+    sx: f32,
+    sy: f32,
+}
+
+fn bubbles(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let n = pr.f("bubbleAmount").clamp(0.0, 10_000.0) as u32;
+    let speed = pr.f("bubbleSpeed") as f32;
+    let wamp = pr.f("wobbleAmplitude") as f32;
+    let wfreq = pr.f("wobbleFrequency") as f32;
+    let bsize = pr.f("bubbleSize").max(0.0) as f32;
+    let metal = pr.e("reflectionType") == 1;
+    let shading = pr.e("shadingType");
+    let seed = ctx.seed.wrapping_mul(0x27d4);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let base = lw.min(lh) * 0.035 * bsize;
+    let list: Vec<Bubble> = (0..n)
+        .map(|i| {
+            let r = base * (0.5 + h(i, 1, seed));
+            let travel = lh + 2.0 * r;
+            let v = speed * lh * 0.3 * (0.6 + 0.8 * h(i, 2, seed));
+            let y = lh + r - (h(i, 3, seed) * travel + v * t).rem_euclid(travel);
+            let x0 = h(i, 4, seed) * lw;
+            let x = x0 + wamp * (r / base.max(1e-3)) * (t * wfreq * std::f32::consts::TAU + h(i, 5, seed) * std::f32::consts::TAU).sin();
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let (sx, sy) = b.to_px([x0 as f64, y as f64]);
+            Bubble { x: bx as f32, y: by as f32, r: r * s, sx: sx as f32, sy: sy as f32 }
+        })
+        .collect();
+    let src = b.img.clone();
+    let mut out = Image::new(src.width, src.height);
+    raster(
+        &mut out,
+        &list,
+        |q| Some([q.x - q.r - 1.0, q.y - q.r - 1.0, q.x + q.r + 1.0, q.y + q.r + 1.0]),
+        |q, x, y| {
+            let (dx, dy) = ((x - q.x) / q.r.max(0.5), (y - q.y) / q.r.max(0.5));
+            let d2 = dx * dx + dy * dy;
+            let d = d2.sqrt();
+            let cov = aa((1.0 - d) * q.r);
+            if cov <= 0.0 {
+                return None;
+            }
+            // Liquid refracts (inverted, magnified), metal reflects (wide-angle mirror).
+            let k = if metal { 1.6 } else { -0.7 };
+            let nz = (1.0 - d2).max(0.0).sqrt();
+            let p = src.sample_bilinear((q.sx + dx * q.r * k) as f64, (q.sy + dy * q.r * k) as f64);
+            let (c, sa) = unpremul(p);
+            let mut c = if sa <= 0.0 { [0.6, 0.7, 0.8] } else { c };
+            let mut a = cov;
+            match shading {
+                1 => c = c.map(|v| v * 0.7 + 0.3 * (1.0 - nz)),
+                2 => c = c.map(|v| v * (0.5 + 0.5 * nz)),
+                3 => a *= nz.powf(0.5),
+                4 => a *= 1.0 - nz * 0.8,
+                _ => {}
+            }
+            let hl = (1.0 - ((dx + 0.35).powi(2) + (dy + 0.35).powi(2)) / 0.05).max(0.0) * 0.8;
+            let c = c.map(|v| v + hl);
+            Some([c[0] * a, c[1] * a, c[2] * a, a])
+        },
+        Acc::Over,
+    );
+    b.img = out;
+    b
+}
+
+// ------------------------------------------------------------------ CC Drizzle
+
+fn drizzle(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let rate = pr.f("dripRate").max(0.0);
+    let life = pr.f("longevity").max(0.01);
+    let rippling = (pr.f("rippling") / 360.0).max(0.05) as f32;
+    let disp = pr.f("displacement") as f32;
+    let height = pr.f("rippleHeight") as f32 / 100.0;
+    let spreading = pr.f("spreading") as f32;
+    let li = pr.f("lightIntensity") as f32 / 100.0;
+    let lc = pr.color("lightColor");
+    let lheight = pr.f("lightHeight") as f32 / 100.0;
+    let ldir = (pr.f("lightDirection") as f32).to_radians();
+    let ambient = pr.f("ambient") as f32 / 100.0;
+    let diffuse = pr.f("diffuse") as f32 / 100.0;
+    let specular = pr.f("specular") as f32 / 100.0;
+    let rough = pr.f("roughness").max(0.001) as f32;
+    let seed = ctx.seed.wrapping_mul(0x165667b1);
+    let t = ctx.time;
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    if rate <= 0.0 || t < 0.0 {
+        return b;
+    }
+    // Drops born at k / rate with hashed positions; alive while younger than the longevity.
+    let k0 = ((t - life) * rate).floor().max(0.0) as u32;
+    let k1 = (t * rate).floor() as u32;
+    let mut drops = Vec::new();
+    for k in k0..=k1 {
+        let born = k as f64 / rate;
+        let age = (t - born) as f32;
+        if age < 0.0 || age as f64 >= life {
+            continue;
+        }
+        let (x, y) = b.to_px([(h(k, 1, seed) * lw) as f64, (h(k, 2, seed) * lh) as f64]);
+        let radius = spreading * age * lh / 400.0 * s;
+        let amp = height * (1.0 - age / life as f32) * (0.6 + 0.4 * h(k, 3, seed));
+        drops.push((x as f32, y as f32, radius, amp));
+    }
+    let wavelen = (lh * 0.04 * s).max(2.0) / rippling.clamp(0.25, 4.0);
+    let width = wavelen * (1.0 + rippling * 2.0);
+    let field = |x: f32, y: f32| -> f32 {
+        let mut v = 0.0;
+        for &(dx, dy, r, a) in &drops {
+            let d = ((x - dx).powi(2) + (y - dy).powi(2)).sqrt();
+            let u = (d - r) / width;
+            if u.abs() < 1.0 {
+                let env = 0.5 + 0.5 * (u * std::f32::consts::PI).cos();
+                v += a * env * ((d - r) / wavelen * std::f32::consts::TAU).cos();
+            }
+        }
+        v
+    };
+    let src = b.img.clone();
+    let (ls, lcs) = ldir.sin_cos();
+    let l = {
+        let v = [lcs, ls, lheight.max(0.05)];
+        let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+        [v[0] / n, v[1] / n, v[2] / n]
+    };
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let (fx, fy) = (x as f32 + 0.5, y as f32 + 0.5);
+            let gx = field(fx + 1.0, fy) - field(fx - 1.0, fy);
+            let gy = field(fx, fy + 1.0) - field(fx, fy - 1.0);
+            if gx == 0.0 && gy == 0.0 {
+                continue;
+            }
+            let p = src.sample_bilinear_clamped((fx - gx * disp * s * 4.0) as f64, (fy - gy * disp * s * 4.0) as f64);
+            let n = {
+                let v = [-gx * 6.0, -gy * 6.0, 1.0];
+                let m = (v[0] * v[0] + v[1] * v[1] + 1.0).sqrt();
+                [v[0] / m, v[1] / m, v[2] / m]
+            };
+            let nl = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]).max(0.0);
+            let hz = (l[2] + 1.0) * 0.5;
+            let hv = {
+                let v = [l[0] * 0.5, l[1] * 0.5, hz];
+                let m = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+                [v[0] / m, v[1] / m, v[2] / m]
+            };
+            let sp = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(1.0 / rough) * specular * li;
+            let shade = 1.0 + (ambient + diffuse * nl - diffuse * l[2]) * li;
+            let a = p[3];
+            *px = [p[0] * shade + sp * lc[0] * a, p[1] * shade + sp * lc[1] * a, p[2] * shade + sp * lc[2] * a, a];
+        }
+    });
+    b
+}
+
+// ------------------------------------------------------------------ CC Star Burst
+
+fn star_burst(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let scatter = pr.f("scatter") as f32;
+    let speed = pr.f("speed") as f32;
+    let phase = pr.f("phase") as f32 / 360.0;
+    let spacing = pr.f("gridSpacing").max(1.0) as f32;
+    let size = pr.f("size") as f32 / 100.0;
+    let blend = pr.f("blendWithOriginal") as f32 / 100.0;
+    let seed = ctx.seed.wrapping_mul(0x3c6e);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let nx = (lw / spacing).ceil().max(1.0) as u32;
+    let ny = (lh / spacing).ceil().max(1.0) as u32;
+    let src = b.img.clone();
+    let (cx, cy) = (lw * 0.5, lh * 0.5);
+    let mut list: Vec<(f32, Sprite)> = (0..nx * ny)
+        .into_par_iter()
+        .filter_map(|i| {
+            let (gx, gy) = ((i % nx) as f32 * spacing + spacing * 0.5, (i / nx) as f32 * spacing + spacing * 0.5);
+            let (sx, sy) = b.to_px([gx as f64, gy as f64]);
+            let (c, a) = unpremul(src.sample_bilinear(sx, sy));
+            if a <= 0.0 {
+                return None;
+            }
+            // Depth cycles towards the viewer: z in [0, 1), perspective 1 / (1 - 0.9 z).
+            let z = (h(i, 1, seed) + t * speed * 0.25 + phase).rem_euclid(1.0);
+            let persp = 1.0 / (1.0 - 0.9 * z);
+            let jx = hs(i, 2, seed) * scatter * 0.01 * lw * 0.5;
+            let jy = hs(i, 3, seed) * scatter * 0.01 * lh * 0.5;
+            let x = cx + (gx - cx + jx) * persp;
+            let y = cy + (gy - cy + jy) * persp;
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let r = spacing * 0.5 * size * persp * s;
+            let fade = (z * 8.0).min(1.0) * ((1.0 - z) * 6.0).min(1.0);
+            Some((z, Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a * fade], Shape::Disc)))
+        })
+        .collect();
+    list.sort_by(|a, b| a.0.total_cmp(&b.0));
+    let sprites: Vec<Sprite> = list.into_iter().map(|(_, s)| s).collect();
+    let fx = splat(src.width, src.height, &sprites, Acc::Over);
+    b.img = fx;
+    if blend > 0.0 {
+        b.img.data.par_iter_mut().zip(src.data.par_iter()).for_each(|(o, s0)| {
+            *o = crate::util::lerp4(*o, *s0, blend);
+        });
+    }
+    b
+}
+
+// ------------------------------------------------------------------ particle engine
+
+/// Steps per second of the stepped particle simulations.
+pub(crate) const SPS: f64 = 60.0;
+
+/// Number of whole steps reached at layer time `t`.
+pub(crate) fn steps_at(t: f64) -> u64 {
+    if t <= 0.0 { 0 } else { (t * SPS + 1e-6).floor() as u64 }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Particle {
+    pub p: [f32; 3],
+    pub v: [f32; 3],
+    pub age: f32,
+    pub life: f32,
+    /// Per-particle random in [0, 1) (size variation, colour jitter…).
+    pub rnd: f32,
+    pub id: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct PState {
+    pub parts: Vec<Particle>,
+    pub carry: f64,
+    pub next_id: u32,
+}
+
+/// Physics configuration (world units; y down).
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Phys {
+    /// Particles per second.
+    pub rate: f64,
+    pub life: f32,
+    pub producer: [f32; 3],
+    pub radius: [f32; 3],
+    pub anim: u32,
+    pub speed: f32,
+    pub gravity: [f32; 3],
+    pub resistance: f32,
+    pub axis: [f32; 3],
+    pub extra: f32,
+    pub extra_angle: f32,
+    pub seed: u32,
+    pub max: usize,
+    /// 2D systems keep z = 0.
+    pub flat: bool,
+}
+
+pub(crate) const PW_ANIMS: &[&str] =
+    &["Explosive", "Direction Axis", "Cone Axis", "Viscouse", "Twirly", "Vortex", "Fire", "Jet Sideways", "Fractal Omni", "Fractal Uni"];
+
+fn norm3(v: [f32; 3]) -> [f32; 3] {
+    let l = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+    if l > 1e-9 { [v[0] / l, v[1] / l, v[2] / l] } else { [0.0, -1.0, 0.0] }
+}
+
+fn rand_dir(i: u32, k: u32, seed: u32, flat: bool) -> [f32; 3] {
+    if flat {
+        let a = h(i, k, seed) * std::f32::consts::TAU;
+        return [a.cos(), a.sin(), 0.0];
+    }
+    let z = hs(i, k, seed);
+    let a = h(i, k + 1, seed) * std::f32::consts::TAU;
+    let r = (1.0 - z * z).max(0.0).sqrt();
+    [r * a.cos(), r * a.sin(), z]
+}
+
+impl Phys {
+    fn spawn(&self, id: u32) -> Particle {
+        let seed = self.seed;
+        let mut p = [0.0f32; 3];
+        // Uniform in the producer ellipsoid.
+        let u = rand_dir(id, 1, seed, self.flat);
+        let rr = h(id, 3, seed).powf(if self.flat { 0.5 } else { 1.0 / 3.0 });
+        for k in 0..3 {
+            p[k] = self.producer[k] + u[k] * self.radius[k] * rr;
+        }
+        if self.flat {
+            p[2] = 0.0;
+        }
+        let ax = norm3(self.axis);
+        let jitter = rand_dir(id, 5, seed, self.flat);
+        let dir = match self.anim {
+            1 | 9 => norm3([ax[0] + jitter[0] * 0.08, ax[1] + jitter[1] * 0.08, ax[2] + jitter[2] * 0.08]),
+            2 => {
+                let k = (self.extra_angle.to_radians() * 0.5).tan().abs().min(20.0);
+                norm3([ax[0] + jitter[0] * k * h(id, 8, seed), ax[1] + jitter[1] * k * h(id, 8, seed), ax[2] + jitter[2] * k * h(id, 8, seed)])
+            }
+            5 => [jitter[0], 0.0, if self.flat { 0.0 } else { jitter[2] }],
+            6 => norm3([jitter[0] * 0.25, -1.0, jitter[2] * 0.25]),
+            7 => norm3([1.0, jitter[1] * 0.05, jitter[2] * 0.05]),
+            _ => jitter,
+        };
+        let sp = self.speed * (0.5 + 0.5 * h(id, 9, seed));
+        let mut v = [dir[0] * sp, dir[1] * sp, dir[2] * sp];
+        if self.flat {
+            v[2] = 0.0;
+        }
+        let life = self.life * (0.8 + 0.4 * h(id, 10, seed));
+        Particle { p, v, age: 0.0, life, rnd: h(id, 11, seed), id }
+    }
+
+    pub(crate) fn step(&self, st: &mut PState, step: u64) {
+        let dt = (1.0 / SPS) as f32;
+        let t = step as f32 * dt;
+        let mut drag = self.resistance;
+        if self.anim == 3 {
+            drag += 3.0 * self.extra.max(0.1);
+        }
+        let damp = (-drag * dt).exp();
+        let seed = self.seed;
+        st.parts.par_iter_mut().for_each(|q| {
+            let mut a = self.gravity;
+            match self.anim {
+                4 => {
+                    // Twirly: swirl around the vertical axis through the producer.
+                    let (dx, dz) = (q.p[0] - self.producer[0], q.p[2] - self.producer[2]);
+                    let k = 4.0 * self.extra;
+                    a[0] += -dz * k;
+                    a[2] += dx * k;
+                    if self.flat {
+                        let dy = q.p[1] - self.producer[1];
+                        a[0] += -dy * k;
+                        a[1] += dx * k;
+                    }
+                }
+                5 => {
+                    // Vortex: strong tangential + inward pull.
+                    let (dx, dy) = (q.p[0] - self.producer[0], q.p[1] - self.producer[1]);
+                    let k = 6.0 * self.extra;
+                    a[0] += -dy * k - dx * 2.0;
+                    a[1] += dx * k - dy * 2.0;
+                }
+                6 => {
+                    // Fire: buoyant, flickering turbulence.
+                    let n = value_noise(q.p[0] * 8.0, q.p[1] * 8.0, t * 3.0, seed) - 0.5;
+                    a[0] += n * 4.0 * self.extra;
+                    a[1] -= self.gravity[1] * 1.5 + 0.3 * self.extra;
+                }
+                8 | 9 => {
+                    let f = 6.0 * self.extra;
+                    a[0] += (value_noise(q.p[0] * 5.0, q.p[1] * 5.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
+                    a[1] += (value_noise(q.p[0] * 5.0 + 17.0, q.p[1] * 5.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
+                    if !self.flat {
+                        a[2] += (value_noise(q.p[0] * 5.0, q.p[1] * 5.0 + 31.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
+                    }
+                }
+                _ => {}
+            }
+            for k in 0..3 {
+                q.v[k] = (q.v[k] + a[k] * dt) * damp;
+                q.p[k] += q.v[k] * dt;
+            }
+            if self.flat {
+                q.p[2] = 0.0;
+                q.v[2] = 0.0;
+            }
+            q.age += dt;
+        });
+        st.parts.retain(|q| q.age < q.life);
+        st.carry += self.rate / SPS;
+        let n = st.carry.floor() as u32;
+        st.carry -= n as f64;
+        for _ in 0..n {
+            if st.parts.len() >= self.max {
+                break;
+            }
+            let id = st.next_id;
+            st.next_id = st.next_id.wrapping_add(1);
+            // Sub-step birth offset keeps continuous streams smooth.
+            let mut q = self.spawn(id);
+            let frac = h(id, 12, seed) * dt;
+            for k in 0..3 {
+                q.p[k] += q.v[k] * frac;
+            }
+            q.age = frac;
+            st.parts.push(q);
+        }
+    }
+}
+
+/// Run a particle system to layer time `t` through `cache`.
+pub(crate) fn simulate(cache: &SimCache<PState>, key: u64, t: f64, phys: &Phys) -> std::sync::Arc<PState> {
+    cache.run(key, steps_at(t), PState::default, |st, i| phys.step(st, i))
+}
+
+pub(crate) const PARTICLE_TYPES: &[&str] =
+    &["Line", "Shaded Sphere", "Faded Sphere", "Bubble", "Star", "Motion Polygon", "Tri-Polygon", "Cube", "Textured Square"];
+
+/// Colour/size/opacity of a particle at its age.
+fn particle_look(q: &Particle, birth: [f32; 4], death: [f32; 4], bsize: f32, dsize: f32, svar: f32, max_op: f32) -> ([f32; 4], f32) {
+    let u = (q.age / q.life.max(1e-4)).clamp(0.0, 1.0);
+    let size = (bsize + (dsize - bsize) * u) * (1.0 + svar * (q.rnd * 2.0 - 1.0));
+    let fade = (u * 20.0).min(1.0) * ((1.0 - u) * 5.0).min(1.0);
+    let c = [birth[0] + (death[0] - birth[0]) * u, birth[1] + (death[1] - birth[1]) * u, birth[2] + (death[2] - birth[2]) * u, max_op * fade];
+    (c, size.max(0.0))
+}
+
+fn type_sprite(kind: u32, x: f32, y: f32, r: f32, c: [f32; 4], vx: f32, vy: f32, rot: f32) -> Sprite {
+    let vl = (vx * vx + vy * vy).sqrt().max(1e-6);
+    let shape = match kind {
+        0 => Shape::Line { dx: -vx / vl * r * 2.0, dy: -vy / vl * r * 2.0 },
+        1 => Shape::Sphere,
+        2 => Shape::Faded,
+        3 => Shape::Bubble,
+        4 => Shape::Star,
+        5 => Shape::Line { dx: -vx * 0.05, dy: -vy * 0.05 },
+        6 => Shape::Tri,
+        _ => Shape::Square,
+    };
+    let rr = match kind {
+        0 => (r * 0.08).max(0.5),
+        5 => r * 0.5,
+        _ => r,
+    };
+    Sprite { x, y, r: rr, c, shape, rot }
+}
+
+// ------------------------------------------------------------------ CC Particle World
+
+static PW_CACHE: SimCache<PState> = SimCache::new(6);
+
+fn particle_world(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let phys = Phys {
+        rate: pr.f("birthRate").max(0.0) * 120.0,
+        life: pr.f("longevity").max(0.0) as f32,
+        producer: [pr.f("producerX") as f32, pr.f("producerY") as f32, pr.f("producerZ") as f32],
+        radius: [pr.f("radiusX").max(0.0) as f32, pr.f("radiusY").max(0.0) as f32, pr.f("radiusZ").max(0.0) as f32],
+        anim: pr.e("animation"),
+        speed: pr.f("velocity") as f32 * 0.5,
+        gravity: {
+            let g = pr.f("gravity") as f32;
+            let gv = [pr.f("gravityX") as f32, pr.f("gravityY") as f32, pr.f("gravityZ") as f32];
+            [gv[0] * g, gv[1] * g, gv[2] * g]
+        },
+        resistance: pr.f("resistance").max(0.0) as f32,
+        axis: [pr.f("axisX") as f32, pr.f("axisY") as f32, pr.f("axisZ") as f32],
+        extra: pr.f("extra") as f32,
+        extra_angle: pr.f("extraAngle") as f32,
+        seed: (pr.f("randomSeed") as u32).wrapping_mul(0x9e3779b9) ^ ctx.seed,
+        max: 40_000,
+        flat: false,
+    };
+    if phys.rate <= 0.0 && ctx.time <= 0.0 {
+        return b;
+    }
+    let st = simulate(&PW_CACHE, params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 1), ctx.time, &phys);
+    let kind = pr.e("particleType");
+    let birth = pr.color("birthColor");
+    let death = pr.color("deathColor");
+    let (bs, ds) = (pr.f("birthSize") as f32, pr.f("deathSize") as f32);
+    let svar = pr.f("sizeVariation") as f32 / 100.0;
+    let max_op = pr.f("maxOpacity") as f32 / 100.0;
+    let s = b.scale as f32;
+    // Camera at distance 2 (world units = layer width) looking at the origin (layer centre).
+    let cam = 2.0f32;
+    let mut list: Vec<(f32, Sprite)> = st
+        .parts
+        .par_iter()
+        .filter_map(|q| {
+            let zc = cam + q.p[2];
+            if zc <= 0.05 {
+                return None;
+            }
+            let k = cam / zc;
+            let x = lw * 0.5 + q.p[0] * lw * k;
+            let y = lh * 0.5 + q.p[1] * lw * k;
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let (c, size) = particle_look(q, birth, death, bs, ds, svar, max_op);
+            let r = size * 0.5 * lw * k * s * 0.25;
+            let sp = type_sprite(kind, bx as f32, by as f32, r, c, q.v[0] * lw * k * s, q.v[1] * lw * k * s, (q.id % 628) as f32 * 0.01 + q.age * 2.0);
+            Some((zc, sp))
+        })
+        .collect();
+    list.sort_by(|a, b| b.0.total_cmp(&a.0));
+    let sprites: Vec<Sprite> = list.into_iter().map(|(_, s)| s).collect();
+    let mode = pr.e("transferMode");
+    let fx = splat(b.img.width, b.img.height, &sprites, if mode == 2 { Acc::Add } else { Acc::Over });
+    b.img = combine(
+        &b.img,
+        &fx,
+        match mode {
+            0 => 0,
+            1 => 1,
+            2 => 2,
+            3 => 5,
+            _ => 0,
+        },
+    );
+    b
+}
+
+// ------------------------------------------------------------------ CC Particle Systems II
+
+static PS2_CACHE: SimCache<PState> = SimCache::new(6);
+
+fn particle_systems2(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let lh = ctx.layer_size[1] as f32;
+    let unit = lh.max(1.0);
+    let pos = pr.v2("position");
+    let dir = (pr.f("direction") as f32).to_radians();
+    let phys = Phys {
+        rate: pr.f("birthRate").max(0.0) * 60.0,
+        life: pr.f("longevity").max(0.0) as f32,
+        producer: [pos[0] as f32 / unit, pos[1] as f32 / unit, 0.0],
+        radius: [pr.f("radiusX").max(0.0) as f32 / unit, pr.f("radiusY").max(0.0) as f32 / unit, 0.0],
+        anim: [0u32, 1, 2, 3, 4, 5, 6, 7, 8, 9][pr.e("animation").min(9) as usize],
+        speed: pr.f("velocity") as f32 * 0.25,
+        gravity: [0.0, pr.f("gravity") as f32 * 0.5, 0.0],
+        resistance: pr.f("resistance").max(0.0) as f32,
+        // AE angles: 0° = up, clockwise.
+        axis: [dir.sin(), -dir.cos(), 0.0],
+        extra: pr.f("extra") as f32,
+        extra_angle: 45.0 * pr.f("extra") as f32,
+        seed: (pr.f("randomSeed") as u32).wrapping_mul(0x85ebca6b) ^ ctx.seed,
+        max: 40_000,
+        flat: true,
+    };
+    let st = simulate(&PS2_CACHE, params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 2), ctx.time, &phys);
+    let kind = pr.e("particleType");
+    let birth = pr.color("birthColor");
+    let death = pr.color("deathColor");
+    let (bs, ds) = (pr.f("birthSize") as f32, pr.f("deathSize") as f32);
+    let svar = pr.f("sizeVariation") as f32 / 100.0;
+    let max_op = pr.f("maxOpacity") as f32 / 100.0;
+    let s = b.scale as f32;
+    let sprites: Vec<Sprite> = st
+        .parts
+        .iter()
+        .map(|q| {
+            let (bx, by) = b.to_px([(q.p[0] * unit) as f64, (q.p[1] * unit) as f64]);
+            let (c, size) = particle_look(q, birth, death, bs, ds, svar, max_op);
+            let r = size * unit * 0.02 * s;
+            type_sprite(kind, bx as f32, by as f32, r, c, q.v[0] * unit * s, q.v[1] * unit * s, (q.id % 628) as f32 * 0.01 + q.age * 2.0)
+        })
+        .collect();
+    let mode = pr.e("transferMode");
+    let fx = splat(b.img.width, b.img.height, &sprites, if mode == 2 { Acc::Add } else { Acc::Over });
+    b.img = combine(
+        &b.img,
+        &fx,
+        match mode {
+            0 => 0,
+            1 => 1,
+            2 => 2,
+            3 => 5,
+            _ => 0,
+        },
+    );
+    b
+}
+
+// ------------------------------------------------------------------ CC Mr. Mercury
+
+static MERCURY_CACHE: SimCache<PState> = SimCache::new(6);
+
+struct Blob {
+    x: f32,
+    y: f32,
+    r: f32,
+}
+
+fn mr_mercury(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let lh = ctx.layer_size[1] as f32;
+    let unit = lh.max(1.0);
+    let pos = pr.v2("producer");
+    let dir = (pr.f("direction") as f32).to_radians();
+    let phys = Phys {
+        rate: pr.f("birthRate").max(0.0) * 10.0,
+        life: pr.f("longevity").max(0.0) as f32,
+        producer: [pos[0] as f32 / unit, pos[1] as f32 / unit, 0.0],
+        radius: [pr.f("radiusX").max(0.0) as f32 / unit, pr.f("radiusY").max(0.0) as f32 / unit, 0.0],
+        anim: [0u32, 1, 2, 3, 4, 5, 6, 7, 8, 9][pr.e("animation").min(9) as usize],
+        speed: pr.f("velocity") as f32 * 0.3,
+        gravity: [0.0, pr.f("gravity") as f32 * 0.5, 0.0],
+        resistance: pr.f("resistance").max(0.0) as f32,
+        axis: [dir.sin(), -dir.cos(), 0.0],
+        extra: pr.f("extra") as f32,
+        extra_angle: 45.0 * pr.f("extra") as f32,
+        seed: ctx.seed.wrapping_mul(0xc2b2ae35),
+        max: 4_000,
+        flat: true,
+    };
+    let st = simulate(&MERCURY_CACHE, params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 3), ctx.time, &phys);
+    let (bs, ds) = (pr.f("blobBirthSize") as f32, pr.f("blobDeathSize") as f32);
+    let influence = pr.f("blobInfluence") as f32 / 100.0;
+    let s = b.scale as f32;
+    let blobs: Vec<Blob> = st
+        .parts
+        .iter()
+        .map(|q| {
+            let u = (q.age / q.life.max(1e-4)).clamp(0.0, 1.0);
+            let size = bs + (ds - bs) * u;
+            let (bx, by) = b.to_px([(q.p[0] * unit) as f64, (q.p[1] * unit) as f64]);
+            Blob { x: bx as f32, y: by as f32, r: (size * unit * 0.08 * s).max(0.0) }
+        })
+        .filter(|q| q.r > 0.1)
+        .collect();
+    let (w, hh) = (b.img.width, b.img.height);
+    // Field and gradient accumulate additively: [f, gx, gy, _].
+    let mut field = Image::new(w, hh);
+    let infl = 1.0 + influence;
+    raster(
+        &mut field,
+        &blobs,
+        |q| {
+            let e = q.r * 2.0 * infl;
+            Some([q.x - e, q.y - e, q.x + e, q.y + e])
+        },
+        |q, x, y| {
+            let (dx, dy) = (x - q.x, y - q.y);
+            let rr = q.r * 2.0 * infl;
+            let d2 = (dx * dx + dy * dy) / (rr * rr);
+            if d2 >= 1.0 {
+                return None;
+            }
+            let k = 1.0 - d2;
+            let f = k * k * k;
+            let g = -6.0 * k * k / (rr * rr);
+            Some([f, g * dx, g * dy, 0.0])
+        },
+        Acc::Add,
+    );
+    let thr = 0.35f32;
+    let ambient = pr.f("ambient") as f32 / 100.0;
+    let diffuse = pr.f("diffuse") as f32 / 100.0;
+    let specular = pr.f("specular") as f32 / 100.0;
+    let rough = pr.f("roughness").max(0.001) as f32;
+    let metal = pr.f("metal") as f32 / 100.0;
+    let li = pr.f("lightIntensity") as f32 / 100.0;
+    let lc = pr.color("lightColor");
+    let ldir = (pr.f("lightDirection") as f32).to_radians();
+    let lheight = pr.f("lightHeight") as f32 / 100.0;
+    let l = norm3([ldir.sin(), -ldir.cos(), lheight.max(0.05)]);
+    let src = b.img.clone();
+    let mut out = Image::new(w, hh);
+    out.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let fv = field.data[y * w as usize + x];
+            let f = fv[0];
+            if f <= thr * 0.8 {
+                continue;
+            }
+            let cov = ((f - thr * 0.8) / (thr * 0.4)).clamp(0.0, 1.0);
+            let n = norm3([fv[1] * 3.0, fv[2] * 3.0, 1.0 / (1.0 + f)]);
+            // Refract the layer through the blob.
+            let sp = src.sample_bilinear_clamped(x as f64 + 0.5 - n[0] as f64 * 12.0 * s as f64, y as f64 + 0.5 - n[1] as f64 * 12.0 * s as f64);
+            let (c, sa) = unpremul(sp);
+            let base = if sa > 0.0 { c } else { [0.7, 0.7, 0.75] };
+            let nl = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]).max(0.0);
+            let hv = norm3([l[0], l[1], l[2] + 1.0]);
+            let spec = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(1.0 / rough) * specular * li;
+            let shade = ambient + diffuse * nl * li;
+            let cc: [f32; 3] = std::array::from_fn(|k| base[k] * shade + spec * (lc[k] * (1.0 - metal) + base[k] * metal));
+            *px = [cc[0] * cov, cc[1] * cov, cc[2] * cov, cov];
+        }
+    });
+    b.img = out;
+    b
+}
+
+// ------------------------------------------------------------------ specs
 
 pub fn specs() -> Vec<EffectSpec> {
-    Vec::new()
+    let transfer = || popup(&["Composite", "Lighten"]);
+    vec![
+        spec(
+            "ec.sim.ccrainfall",
+            "CC Rainfall",
+            vec![
+                p("drops", "Drops", num(5000.0), slider(0.0, 100_000.0, 0.0, 20_000.0, 0)),
+                p("size", "Size", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 2)),
+                p("sceneDepth", "Scene Depth", num(5000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
+                p("speed", "Speed", num(4000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
+                p("wind", "Wind", num(0.0), slider(-10_000.0, 10_000.0, -2000.0, 2000.0, 1)),
+                p("windVariation", "Variation % (Wind)", num(0.0), pct()),
+                p("spread", "Spread", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+                p("color", "Color", col(0.8, 0.8, 0.8), ParamUi::Color),
+                p("opacity", "Opacity", num(25.0), pct()),
+                p("transferMode", "Transfer Mode", Value::Enum(1), transfer()),
+                p("compositeWithOriginal", "Composite With Original", Value::Bool(true), ParamUi::Checkbox),
+                p("appearance", "Appearance", Value::Enum(0), popup(&["Refracting", "Soft Solid"])),
+                p("offset", "Offset", pt(0.5, 0.5), ParamUi::Point),
+                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            rainfall,
+        ),
+        spec(
+            "ec.sim.ccsnowfall",
+            "CC Snowfall",
+            vec![
+                p("flakes", "Flakes", num(10_000.0), slider(0.0, 200_000.0, 0.0, 50_000.0, 0)),
+                p("size", "Size", num(3.0), slider(0.0, 50.0, 0.0, 20.0, 2)),
+                p("sizeVariation", "Variation % (Size)", num(50.0), pct()),
+                p("sceneDepth", "Scene Depth", num(5000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
+                p("speed", "Speed", num(100.0), slider(0.0, 5000.0, 0.0, 1000.0, 1)),
+                p("speedVariation", "Variation % (Speed)", num(50.0), pct()),
+                p("wind", "Wind", num(25.0), slider(-5000.0, 5000.0, -500.0, 500.0, 1)),
+                p("windVariation", "Variation % (Wind)", num(50.0), pct()),
+                p("spread", "Spread", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+                p("wiggleAmount", "Amount (Wiggle)", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("wiggleAmountVariation", "Variation % (Amount)", num(50.0), pct()),
+                p("wiggleFrequency", "Frequency (Wiggle)", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("wiggleFrequencyVariation", "Variation % (Frequency)", num(50.0), pct()),
+                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("opacity", "Opacity", num(100.0), pct()),
+                p("transferMode", "Transfer Mode", Value::Enum(0), transfer()),
+                p("compositeWithOriginal", "Composite With Original", Value::Bool(true), ParamUi::Checkbox),
+                p("offset", "Offset", pt(0.5, 0.5), ParamUi::Point),
+                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            snowfall,
+        ),
+        spec(
+            "ec.sim.ccbubbles",
+            "CC Bubbles",
+            vec![
+                p("bubbleAmount", "Bubble Amount", num(100.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+                p("bubbleSpeed", "Bubble Speed", num(0.5), slider(-10.0, 10.0, -2.0, 2.0, 2)),
+                p("wobbleAmplitude", "Wobble Amplitude", num(5.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
+                p("wobbleFrequency", "Wobble Frequency", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 2)),
+                p("bubbleSize", "Bubble Size", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("reflectionType", "Reflection Type", Value::Enum(0), popup(&["Liquid", "Metal"])),
+                p("shadingType", "Shading Type", Value::Enum(0), popup(&["None", "Lighten", "Darken", "Fade Inwards", "Fade Outwards"])),
+            ],
+            bubbles,
+        ),
+        spec(
+            "ec.sim.ccdrizzle",
+            "CC Drizzle",
+            vec![
+                p("dripRate", "Drip Rate", num(10.0), slider(0.0, 200.0, 0.0, 50.0, 2)),
+                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 30.0, 0.0, 5.0, 2)),
+                p("rippling", "Rippling", num(360.0), ParamUi::Angle),
+                p("displacement", "Displacement", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
+                p("rippleHeight", "Ripple Height", num(30.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("spreading", "Spreading", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
+                p("lightIntensity", "Light Intensity", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("lightHeight", "Light Height", num(25.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("lightDirection", "Light Direction", num(-45.0), ParamUi::Angle),
+                p("ambient", "Ambient", num(0.0), slider(-200.0, 200.0, -100.0, 100.0, 1)),
+                p("diffuse", "Diffuse", num(0.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("specular", "Specular", num(20.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("roughness", "Roughness", num(0.05), slider(0.001, 1.0, 0.001, 0.5, 3)),
+            ],
+            drizzle,
+        ),
+        spec(
+            "ec.sim.ccstarburst",
+            "CC Star Burst",
+            vec![
+                p("scatter", "Scatter", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
+                p("speed", "Speed", num(1.0), slider(-10.0, 10.0, -4.0, 4.0, 2)),
+                p("phase", "Phase", num(0.0), ParamUi::Angle),
+                p("gridSpacing", "Grid Spacing", num(2.0), slider(1.0, 100.0, 1.0, 20.0, 0)),
+                p("size", "Size", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
+                p("blendWithOriginal", "Blend w. Original", num(0.0), pct()),
+            ],
+            star_burst,
+        ),
+        spec(
+            "ec.sim.ccparticleworld",
+            "CC Particle World",
+            vec![
+                p("birthRate", "Birth Rate", num(0.5), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("producerX", "Position X", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
+                p("producerY", "Position Y", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
+                p("producerZ", "Position Z", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
+                p("radiusX", "Radius X", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("radiusY", "Radius Y", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("radiusZ", "Radius Z", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
+                p("velocity", "Velocity", num(1.0), slider(-10.0, 10.0, 0.0, 5.0, 2)),
+                p("inheritVelocity", "Inherit Velocity %", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("gravity", "Gravity", num(0.5), slider(-10.0, 10.0, -2.0, 2.0, 3)),
+                p("resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("extraAngle", "Extra Angle", num(360.0), ParamUi::Angle),
+                p("axisX", "Direction Axis X", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("axisY", "Direction Axis Y", num(-1.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("axisZ", "Direction Axis Z", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("gravityX", "Gravity Vector X", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("gravityY", "Gravity Vector Y", num(1.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("gravityZ", "Gravity Vector Z", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("particleType", "Particle Type", Value::Enum(0), popup(PARTICLE_TYPES)),
+                p("birthSize", "Birth Size", num(0.2), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("deathSize", "Death Size", num(0.2), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("sizeVariation", "Size Variation", num(0.0), pct()),
+                p("maxOpacity", "Max Opacity", num(75.0), pct()),
+                p("birthColor", "Birth Color", col(1.0, 1.0, 0.0), ParamUi::Color),
+                p("deathColor", "Death Color", col(0.6, 0.0, 0.0), ParamUi::Color),
+                p("transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Screen", "Add", "Black Matte"])),
+                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            particle_world,
+        ),
+        spec(
+            "ec.sim.ccparticlesystems2",
+            "CC Particle Systems II",
+            vec![
+                p("birthRate", "Birth Rate", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("position", "Position", pt(0.5, 0.5), ParamUi::Point),
+                p("radiusX", "Radius X", num(0.0), slider(0.0, 2000.0, 0.0, 200.0, 1)),
+                p("radiusY", "Radius Y", num(0.0), slider(0.0, 2000.0, 0.0, 200.0, 1)),
+                p("animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
+                p("velocity", "Velocity", num(2.0), slider(-20.0, 20.0, 0.0, 10.0, 2)),
+                p("inheritVelocity", "Inherit Velocity %", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("gravity", "Gravity", num(1.0), slider(-20.0, 20.0, -5.0, 5.0, 2)),
+                p("resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("direction", "Direction", num(0.0), ParamUi::Angle),
+                p("extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("particleType", "Particle Type", Value::Enum(0), popup(PARTICLE_TYPES)),
+                p("birthSize", "Birth Size", num(0.5), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("deathSize", "Death Size", num(1.5), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("sizeVariation", "Size Variation", num(0.0), pct()),
+                p("maxOpacity", "Max Opacity", num(75.0), pct()),
+                p("birthColor", "Birth Color", col(1.0, 1.0, 0.0), ParamUi::Color),
+                p("deathColor", "Death Color", col(0.6, 0.0, 0.0), ParamUi::Color),
+                p("transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Screen", "Add", "Black Matte"])),
+                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            particle_systems2,
+        ),
+        spec(
+            "ec.sim.ccmrmercury",
+            "CC Mr. Mercury",
+            vec![
+                p("radiusX", "Radius X", num(50.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
+                p("radiusY", "Radius Y", num(50.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
+                p("producer", "Producer", pt(0.5, 0.5), ParamUi::Point),
+                p("direction", "Direction", num(0.0), ParamUi::Angle),
+                p("velocity", "Velocity", num(1.0), slider(-20.0, 20.0, 0.0, 5.0, 2)),
+                p("birthRate", "Birth Rate", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("longevity", "Longevity (sec)", num(2.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("gravity", "Gravity", num(0.5), slider(-20.0, 20.0, -5.0, 5.0, 2)),
+                p("resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
+                p("blobInfluence", "Blob Influence", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("blobBirthSize", "Blob Birth Size", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("blobDeathSize", "Blob Death Size", num(0.25), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("lightIntensity", "Light Intensity", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("lightHeight", "Light Height", num(50.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("lightDirection", "Light Direction", num(-45.0), ParamUi::Angle),
+                p("ambient", "Ambient", num(0.0), slider(-200.0, 200.0, -100.0, 100.0, 1)),
+                p("diffuse", "Diffuse", num(75.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("specular", "Specular", num(50.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("roughness", "Roughness", num(0.05), slider(0.001, 1.0, 0.001, 0.5, 3)),
+                p("metal", "Metal", num(100.0), pct()),
+            ],
+            mr_mercury,
+        ),
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{EffectEnv, run_fx};
+
+    fn grey(w: u32, hh: u32) -> Image {
+        Image::filled(w, hh, [0.2, 0.2, 0.2, 1.0])
+    }
+
+    fn ramp(w: u32, hh: u32) -> Image {
+        let mut img = Image::new(w, hh);
+        for y in 0..hh {
+            for x in 0..w {
+                img.set(x, y, [x as f32 / w as f32, y as f32 / hh as f32, 0.4, 1.0]);
+            }
+        }
+        img
+    }
+
+    fn run(id: &str, vals: &[(&str, Value)], img: Image, t: f64) -> Image {
+        run_fx(id, vals, img, t, EffectEnv::default()).img
+    }
+
+    fn diff(a: &Image, b: &Image) -> f32 {
+        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>()).sum()
+    }
+
+    /// Centre of mass (luminance-weighted difference from `base`) in y.
+    fn mass_y(img: &Image, base: &Image) -> f32 {
+        let (mut m, mut sy) = (0.0, 0.0);
+        for y in 0..img.height {
+            for x in 0..img.width {
+                let i = img.idx(x, y);
+                let d: f32 = (0..3).map(|k| (img.data[i][k] - base.data[i][k]).abs()).sum();
+                m += d;
+                sy += d * y as f32;
+            }
+        }
+        if m > 0.0 { sy / m } else { -1.0 }
+    }
+
+    #[test]
+    fn rasteriser_over_and_add() {
+        let s = [Sprite::new(5.0, 5.0, 2.0, [1.0, 0.0, 0.0, 1.0], Shape::Disc)];
+        let img = splat(10, 40, &s, Acc::Over);
+        assert!(img.get(5, 5)[0] > 0.99 && img.get(9, 30)[3] == 0.0);
+        let two = [s[0], s[0]];
+        let add = splat(10, 40, &two, Acc::Add);
+        assert!(add.get(5, 5)[0] > 1.9);
+        // Items spanning band boundaries are drawn in every band.
+        let tall = [Sprite::new(5.0, 16.0, 6.0, [0.0, 1.0, 0.0, 1.0], Shape::Square)];
+        let t = splat(10, 40, &tall, Acc::Over);
+        assert!(t.get(5, 13)[1] > 0.9 && t.get(5, 18)[1] > 0.9);
+    }
+
+    #[test]
+    fn rainfall_deterministic_and_falls() {
+        let vals = [("drops", num(200.0)), ("opacity", num(100.0)), ("appearance", Value::Enum(1)), ("color", col(1.0, 1.0, 1.0))];
+        let a = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.5);
+        let b = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.5);
+        assert_eq!(a, b);
+        assert!(diff(&a, &grey(40, 40)) > 1.0, "drops visible");
+        let none = run("ec.sim.ccrainfall", &[("drops", num(0.0))], grey(40, 40), 0.5);
+        assert_eq!(none, grey(40, 40));
+        let later = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.52);
+        assert!(diff(&a, &later) > 0.1, "rain moves");
+    }
+
+    #[test]
+    fn snowfall_deterministic_and_moves() {
+        let vals = [("flakes", num(300.0))];
+        let a = run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.0);
+        assert_eq!(a, run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.0));
+        assert!(diff(&a, &grey(40, 40)) > 1.0);
+        assert!(diff(&a, &run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.2)) > 0.1);
+        let off = run("ec.sim.ccsnowfall", &[("flakes", num(300.0)), ("compositeWithOriginal", Value::Bool(false))], grey(40, 40), 1.0);
+        assert!(off.data.iter().any(|p| p[3] == 0.0), "without original the background is transparent");
+    }
+
+    #[test]
+    fn bubbles_rise() {
+        let vals = [("bubbleAmount", num(30.0)), ("bubbleSize", num(3.0))];
+        let a = run("ec.sim.ccbubbles", &vals, ramp(40, 40), 0.3);
+        assert_eq!(a, run("ec.sim.ccbubbles", &vals, ramp(40, 40), 0.3));
+        assert!(a.data.iter().any(|p| p[3] > 0.5));
+        let none = run("ec.sim.ccbubbles", &[("bubbleAmount", num(0.0))], ramp(40, 40), 0.3);
+        assert!(none.data.iter().all(|p| p[3] == 0.0), "bubbles replace the layer");
+        // A single slow bubble moves up over a short time.
+        let one = [("bubbleAmount", num(1.0)), ("bubbleSize", num(4.0)), ("wobbleAmplitude", num(0.0)), ("bubbleSpeed", num(0.2))];
+        let blank = Image::new(40, 40);
+        let y0 = mass_y(&run("ec.sim.ccbubbles", &one, ramp(40, 40), 0.0), &blank);
+        let y1 = mass_y(&run("ec.sim.ccbubbles", &one, ramp(40, 40), 0.1), &blank);
+        assert!(y0 >= 0.0 && y1 >= 0.0 && (y1 < y0 || y0 < 8.0), "{y0} -> {y1}");
+    }
+
+    #[test]
+    fn drizzle_ripples() {
+        let a = run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6);
+        assert_eq!(a, run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6));
+        assert!(diff(&a, &ramp(48, 48)) > 0.1);
+        let none = run("ec.sim.ccdrizzle", &[("dripRate", num(0.0))], ramp(48, 48), 0.6);
+        assert_eq!(none, ramp(48, 48));
+    }
+
+    #[test]
+    fn star_burst_moves_stars() {
+        let a = run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.5);
+        assert_eq!(a, run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.5));
+        assert!(a.data.iter().any(|p| p[3] > 0.0));
+        let b = run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.9);
+        assert!(diff(&a, &b) > 0.5);
+        let full = run("ec.sim.ccstarburst", &[("blendWithOriginal", num(100.0))], ramp(40, 40), 0.5);
+        assert!(diff(&full, &ramp(40, 40)) < 1e-3);
+    }
+
+    fn pw_vals(seed: f64) -> Vec<(&'static str, Value)> {
+        vec![("birthRate", num(1.0)), ("randomSeed", num(seed)), ("particleType", Value::Enum(2)), ("birthSize", num(0.3)), ("deathSize", num(0.3))]
+    }
+
+    #[test]
+    fn particle_world_seek_consistent() {
+        let v = pw_vals(11.0);
+        let direct = run("ec.sim.ccparticleworld", &v, Image::new(40, 40), 2.0);
+        let v2 = pw_vals(12.0);
+        let _ = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 1.0);
+        let stepped = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 2.0);
+        let direct2 = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 2.0);
+        assert_eq!(stepped, direct2);
+        assert!(direct.data.iter().any(|p| p[3] > 0.0), "particles alive");
+        // Before birth nothing is drawn.
+        let t0 = run("ec.sim.ccparticleworld", &v, Image::new(40, 40), 0.0);
+        assert!(t0.data.iter().all(|p| p[3] == 0.0));
+    }
+
+    #[test]
+    fn engine_resume_equals_from_scratch() {
+        for anim in 0..PW_ANIMS.len() as u32 {
+            let phys = Phys {
+                rate: 90.0,
+                life: 1.5,
+                producer: [0.0; 3],
+                radius: [0.05; 3],
+                anim,
+                speed: 0.5,
+                gravity: [0.0, 0.5, 0.0],
+                resistance: 0.2,
+                axis: [0.0, -1.0, 0.0],
+                extra: 1.0,
+                extra_angle: 60.0,
+                seed: 9,
+                max: 10_000,
+                flat: anim % 2 == 0,
+            };
+            let a: SimCache<PState> = SimCache::new(2);
+            let b: SimCache<PState> = SimCache::new(2);
+            let direct = simulate(&a, 1, 2.0, &phys);
+            let _ = simulate(&b, 1, 1.0, &phys);
+            let _ = simulate(&b, 1, 0.37, &phys);
+            let resumed = simulate(&b, 1, 2.0, &phys);
+            assert_eq!(direct.parts.len(), resumed.parts.len(), "anim {anim}");
+            assert!(direct.parts.iter().zip(&resumed.parts).all(|(p, q)| p.p == q.p && p.v == q.v && p.id == q.id), "anim {anim}");
+            assert!(!direct.parts.is_empty());
+        }
+    }
+
+    #[test]
+    fn particle_world_gravity_pulls_down() {
+        let base = |g: f64| {
+            vec![
+                ("birthRate", num(2.0)),
+                ("velocity", num(0.2)),
+                ("gravity", num(g)),
+                ("particleType", Value::Enum(2)),
+                ("birthSize", num(0.2)),
+                ("deathSize", num(0.2)),
+                ("longevity", num(3.0)),
+            ]
+        };
+        let blank = Image::new(48, 48);
+        let up = mass_y(&run("ec.sim.ccparticleworld", &base(0.0), blank.clone(), 1.0), &blank);
+        let down = mass_y(&run("ec.sim.ccparticleworld", &base(2.0), blank.clone(), 1.0), &blank);
+        assert!(down > up + 2.0, "{up} {down}");
+    }
+
+    #[test]
+    fn particle_systems2_seek_and_direction() {
+        let v = vec![("position", pt(24.0, 24.0)), ("birthRate", num(3.0)), ("gravity", num(0.0)), ("velocity", num(1.0)), ("animation", Value::Enum(1))];
+        let _ = run("ec.sim.ccparticlesystems2", &v, Image::new(48, 48), 0.5);
+        let a = run("ec.sim.ccparticlesystems2", &v, Image::new(48, 48), 1.0);
+        let mut v2 = v.clone();
+        v2.push(("randomSeed", num(0.0)));
+        assert_eq!(a, run("ec.sim.ccparticlesystems2", &v2, Image::new(48, 48), 1.0));
+        // Direction 0° (up): particles above the producer.
+        let blank = Image::new(48, 48);
+        let y = mass_y(&a, &blank);
+        assert!((0.0..24.0).contains(&y), "{y}");
+        let none = run("ec.sim.ccparticlesystems2", &[("birthRate", num(0.0))], grey(20, 20), 1.0);
+        assert_eq!(none, grey(20, 20));
+    }
+
+    #[test]
+    fn mercury_blobs_and_seek() {
+        let v = vec![("producer", pt(24.0, 16.0)), ("radiusX", num(5.0)), ("radiusY", num(5.0)), ("birthRate", num(3.0))];
+        let _ = run("ec.sim.ccmrmercury", &v, ramp(48, 48), 0.7);
+        let a = run("ec.sim.ccmrmercury", &v, ramp(48, 48), 1.4);
+        let mut v2 = v.clone();
+        v2.push(("metal", num(100.0)));
+        let b = run("ec.sim.ccmrmercury", &v2, ramp(48, 48), 1.4);
+        assert_eq!(a, b);
+        assert!(a.data.iter().any(|p| p[3] > 0.5), "blobs visible");
+        let none = run("ec.sim.ccmrmercury", &[("birthRate", num(0.0))], ramp(48, 48), 1.4);
+        assert!(none.data.iter().all(|p| p[3] == 0.0));
+    }
+
+    #[test]
+    fn half_resolution_scales_sprites() {
+        // Downsampled buffers render the same layout at half size.
+        let s = crate::find("ec.sim.ccsnowfall").unwrap();
+        let mut params = crate::Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+        params.values.insert("flakes".into(), num(50.0));
+        params.values.insert("offset".into(), pt(20.0, 20.0));
+        let ctx = EffectCtx { params: &params, time: 0.5, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: EffectEnv::default() };
+        let full = crate::apply(s, &ctx, Buf { img: grey(40, 40), offset: [0.0; 2], scale: 1.0 });
+        let half = crate::apply(s, &ctx, Buf { img: grey(20, 20), offset: [0.0; 2], scale: 0.5 });
+        let sum = |i: &Image| i.data.iter().map(|p| p[0]).sum::<f32>() / i.data.len() as f32;
+        assert!((sum(&full.img) - sum(&half.img)).abs() < 0.05, "{} {}", sum(&full.img), sum(&half.img));
+    }
 }
diff --git a/crates/effects/src/sim2.rs b/crates/effects/src/sim2.rs
index d8d6ce96..133dc87e 100644
--- a/crates/effects/src/sim2.rs
+++ b/crates/effects/src/sim2.rs
@@ -1,7 +1,1610 @@
-//! Simulation effects, part 2.
+//! Simulation effects, part 2: layer-shattering and surface simulations — CC Ball Action,
+//! CC Pixel Polly, CC Scatterize, Card Dance, Shatter (planar pieces in perspective), Caustics,
+//! Wave World (stepped 2D wave equation) and Foam (stepped bubble sim).
+//!
+//! Written from the public descriptions of the effects' behaviour. Pieces are textured convex
+//! polygons placed in 3D and drawn through a per-piece inverse homography, far to near.
 
-use crate::EffectSpec;
+use effectcraft_keyframe::Value;
+use effectcraft_project::ParamUi;
+use effectcraft_raster::{Image, Px};
+use rayon::prelude::*;
+
+use crate::generate::value_noise;
+use crate::sim::{Acc, Shape, Sprite, h, hs, pct, pt, raster, spec, splat};
+use crate::util::{Plane, SimCache, gauss_plane, layer_or_self, params_key, unpremul};
+use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider};
+
+// ------------------------------------------------------------------ 3D pieces
+
+type M3 = [[f64; 3]; 3];
+
+fn mat_mul(a: &M3, b: &M3) -> M3 {
+    std::array::from_fn(|i| std::array::from_fn(|j| (0..3).map(|k| a[i][k] * b[k][j]).sum()))
+}
+
+/// Rotation from Euler angles (radians), applied X then Y then Z.
+fn rot_xyz(x: f64, y: f64, z: f64) -> M3 {
+    let (sx, cx) = x.sin_cos();
+    let (sy, cy) = y.sin_cos();
+    let (sz, cz) = z.sin_cos();
+    let rx = [[1.0, 0.0, 0.0], [0.0, cx, -sx], [0.0, sx, cx]];
+    let ry = [[cy, 0.0, sy], [0.0, 1.0, 0.0], [-sy, 0.0, cy]];
+    let rz = [[cz, -sz, 0.0], [sz, cz, 0.0], [0.0, 0.0, 1.0]];
+    mat_mul(&rz, &mat_mul(&ry, &rx))
+}
+
+/// Rotation by `angle` about unit `axis` (Rodrigues).
+fn rot_axis(axis: [f64; 3], angle: f64) -> M3 {
+    let l = (axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]).sqrt();
+    if l < 1e-12 || angle == 0.0 {
+        return [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
+    }
+    let (x, y, z) = (axis[0] / l, axis[1] / l, axis[2] / l);
+    let (s, c) = angle.sin_cos();
+    let t = 1.0 - c;
+    [
+        [t * x * x + c, t * x * y - s * z, t * x * z + s * y],
+        [t * x * y + s * z, t * y * y + c, t * y * z - s * x],
+        [t * x * z - s * y, t * y * z + s * x, t * z * z + c],
+    ]
+}
+
+fn inv3(m: &M3) -> Option<M3> {
+    let det = m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+        + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+    if det.abs() < 1e-12 {
+        return None;
+    }
+    let d = 1.0 / det;
+    Some([
+        [(m[1][1] * m[2][2] - m[1][2] * m[2][1]) * d, (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * d, (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * d],
+        [(m[1][2] * m[2][0] - m[1][0] * m[2][2]) * d, (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * d, (m[0][2] * m[1][0] - m[0][0] * m[1][2]) * d],
+        [(m[1][0] * m[2][1] - m[1][1] * m[2][0]) * d, (m[0][1] * m[2][0] - m[0][0] * m[2][1]) * d, (m[0][0] * m[1][1] - m[0][1] * m[1][0]) * d],
+    ])
+}
+
+/// Perspective camera looking down +z at the layer plane z = 0, `d` pixels away, centred on
+/// `c` (buffer pixels): screen = c + (P - c) · d / (d + z).
+#[derive(Clone, Copy)]
+struct Cam {
+    c: [f64; 2],
+    d: f64,
+}
+
+/// A planar textured piece ready to draw.
+#[derive(Clone, Copy)]
+struct Piece {
+    /// Screen (buffer px, homogeneous) → piece-local (a, b, w).
+    inv: M3,
+    /// Rest centre of the piece in texture pixels.
+    c0: [f32; 2],
+    /// Convex polygon (texture pixels), counter-clockwise in y-down space.
+    poly: [[f32; 2]; 6],
+    n: u8,
+    bbox: [f32; 4],
+    shade: f32,
+    alpha: f32,
+    /// Flat straight colour instead of the texture.
+    flat: Option<[f32; 3]>,
+    /// Facing away from the camera (draw the back texture).
+    back: bool,
+    depth: f64,
+}
+
+impl Piece {
+    /// Place polygon `poly` (texture px, around rest centre `c0`) with rotation `r` and its
+    /// centre at 3D `pos` (buffer px; z away from the camera).
+    fn new(poly: &[[f32; 2]], c0: [f32; 2], r: &M3, pos: [f64; 3], cam: Cam) -> Option<Piece> {
+        let n = poly.len().min(6);
+        if n < 3 {
+            return None;
+        }
+        let (cx, cy, d) = (cam.c[0], cam.c[1], cam.d);
+        let zc = pos[2];
+        let hm: M3 = [
+            [cx * r[2][0] + d * r[0][0], cx * r[2][1] + d * r[0][1], cx * (d + zc) + d * (pos[0] - cx)],
+            [cy * r[2][0] + d * r[1][0], cy * r[2][1] + d * r[1][1], cy * (d + zc) + d * (pos[1] - cy)],
+            [r[2][0], r[2][1], d + zc],
+        ];
+        let mut bb = [f32::INFINITY, f32::INFINITY, f32::NEG_INFINITY, f32::NEG_INFINITY];
+        for v in &poly[..n] {
+            let (a, b) = ((v[0] - c0[0]) as f64, (v[1] - c0[1]) as f64);
+            let w = hm[2][0] * a + hm[2][1] * b + hm[2][2];
+            if w < d * 0.05 {
+                return None;
+            }
+            let sx = ((hm[0][0] * a + hm[0][1] * b + hm[0][2]) / w) as f32;
+            let sy = ((hm[1][0] * a + hm[1][1] * b + hm[1][2]) / w) as f32;
+            bb = [bb[0].min(sx), bb[1].min(sy), bb[2].max(sx), bb[3].max(sy)];
+        }
+        let inv = inv3(&hm)?;
+        let mut pp = [[0.0f32; 2]; 6];
+        pp[..n].copy_from_slice(&poly[..n]);
+        // Normalise winding so "inside" is cross >= 0 for every edge.
+        let area: f32 = (0..n).map(|i| pp[i][0] * pp[(i + 1) % n][1] - pp[(i + 1) % n][0] * pp[i][1]).sum();
+        if area < 0.0 {
+            pp[..n].reverse();
+        }
+        // Front normal (0, 0, -1) rotated; facing the camera when its z is negative.
+        let nz = -r[2][2];
+        Some(Piece {
+            inv,
+            c0,
+            poly: pp,
+            n: n as u8,
+            bbox: [bb[0] - 1.0, bb[1] - 1.0, bb[2] + 1.0, bb[3] + 1.0],
+            shade: 1.0,
+            alpha: 1.0,
+            flat: None,
+            back: nz > 0.0,
+            depth: zc,
+        })
+    }
+
+    /// Lambert factor of the piece normal against a light shining along +z.
+    fn facing(r: &M3) -> f32 {
+        r[2][2].abs() as f32
+    }
+}
+
+/// Draw pieces (already sorted far → near) over `out`.
+fn draw_pieces(out: &mut Image, pieces: &[Piece], front: &Image, back: Option<&Image>) {
+    raster(
+        out,
+        pieces,
+        |q| Some(q.bbox),
+        |q, x, y| {
+            let (xf, yf) = (x as f64, y as f64);
+            let m = &q.inv;
+            let w = m[2][0] * xf + m[2][1] * yf + m[2][2];
+            if w.abs() < 1e-12 {
+                return None;
+            }
+            let u = ((m[0][0] * xf + m[0][1] * yf + m[0][2]) / w) as f32 + q.c0[0];
+            let v = ((m[1][0] * xf + m[1][1] * yf + m[1][2]) / w) as f32 + q.c0[1];
+            let n = q.n as usize;
+            let mut md = f32::INFINITY;
+            for i in 0..n {
+                let a = q.poly[i];
+                let b = q.poly[(i + 1) % n];
+                let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
+                let l = (ex * ex + ey * ey).sqrt().max(1e-6);
+                md = md.min((ex * (v - a[1]) - ey * (u - a[0])) / l);
+            }
+            // Coverage extends half a pixel past the edge so abutting pieces leave no seams.
+            let cov = (md + 1.0).clamp(0.0, 1.0);
+            if cov <= 0.0 {
+                return None;
+            }
+            let (c, a) = match q.flat {
+                Some(c) => (c, 1.0),
+                None => {
+                    let tex = if q.back { back.unwrap_or(front) } else { front };
+                    unpremul(tex.sample_bilinear(u as f64, v as f64))
+                }
+            };
+            let a = a * cov * q.alpha;
+            if a <= 1e-6 {
+                return None;
+            }
+            let k = q.shade;
+            Some([c[0] * k * a, c[1] * k * a, c[2] * k * a, a])
+        },
+        Acc::Over,
+    );
+}
+
+fn sort_far_first(pieces: &mut [Piece]) {
+    pieces.sort_by(|a, b| b.depth.total_cmp(&a.depth));
+}
+
+// ------------------------------------------------------------------ CC Ball Action
+
+fn ball_action(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let scatter = pr.f("scatter") as f32;
+    let axis = pr.e("rotationAxis");
+    let rot = pr.f("rotation").to_radians();
+    let twist_prop = pr.e("twistProperty");
+    let twist = pr.f("twistAngle").to_radians();
+    let spacing = pr.f("gridSpacing").max(1.0) as f32;
+    let size = pr.f("ballSize") as f32 / 100.0;
+    let instab = pr.f("instabilityState").to_radians() as f32;
+    let seed = ctx.seed.wrapping_mul(0x2545f491);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let nx = (lw / spacing).ceil().max(1.0) as u32;
+    let ny = (lh / spacing).ceil().max(1.0) as u32;
+    let d = 2.0 * lw.max(lh) as f64;
+    let (cx, cy) = (lw as f64 * 0.5, lh as f64 * 0.5);
+    let src = b.img.clone();
+    let ax: [f64; 3] = match axis {
+        0 => [1.0, 0.0, 0.0],
+        1 => [0.0, 1.0, 0.0],
+        2 => [0.0, 0.0, 1.0],
+        3 => [1.0, 1.0, 0.0],
+        4 => [1.0, 0.0, 1.0],
+        5 => [0.0, 1.0, 1.0],
+        _ => [1.0, 1.0, 1.0],
+    };
+    let maxr = ((lw * lw + lh * lh).sqrt() * 0.5).max(1.0);
+    let mut balls: Vec<(f64, Sprite)> = (0..nx * ny)
+        .into_par_iter()
+        .filter_map(|i| {
+            let gx = (i % nx) as f32 * spacing + spacing * 0.5;
+            let gy = (i / nx) as f32 * spacing + spacing * 0.5;
+            let (sx, sy) = b.to_px([gx as f64, gy as f64]);
+            let (c, a) = unpremul(src.sample_bilinear(sx, sy));
+            if a <= 0.0 || size <= 0.0 {
+                return None;
+            }
+            let tp = match twist_prop {
+                0 => gx / lw.max(1.0),
+                1 => gy / lh.max(1.0),
+                2 => ((gx - cx as f32).hypot(gy - cy as f32)) / maxr,
+                _ => crate::util::rgb3([c[0], c[1], c[2], 0.0]).iter().sum::<f32>() / 3.0,
+            } as f64;
+            let ang = rot + twist * tp;
+            // Scatter: random 3D offsets whose direction drifts with the instability state.
+            let ph = h(i, 1, seed) * std::f32::consts::TAU + instab;
+            let sc = scatter * h(i, 2, seed);
+            let off = [(sc * ph.cos()) as f64, (sc * ph.sin()) as f64, (scatter * hs(i, 3, seed)) as f64];
+            let p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
+            let m = rot_axis(ax, ang);
+            let q: [f64; 3] = std::array::from_fn(|k| m[k][0] * p0[0] + m[k][1] * p0[1] + m[k][2] * p0[2]);
+            if d + q[2] <= d * 0.05 {
+                return None;
+            }
+            let persp = d / (d + q[2]);
+            let (bx, by) = b.to_px([cx + q[0] * persp, cy + q[1] * persp]);
+            let r = spacing * 0.5 * size * persp as f32 * s;
+            Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], Shape::Sphere)))
+        })
+        .collect();
+    balls.sort_by(|a, b| b.0.total_cmp(&a.0));
+    let sprites: Vec<Sprite> = balls.into_iter().map(|(_, s)| s).collect();
+    b.img = splat(src.width, src.height, &sprites, Acc::Over);
+    b
+}
+
+// ------------------------------------------------------------------ CC Pixel Polly
+
+fn pixel_polly(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let t = ctx.time - pr.f("startTime");
+    if t <= 0.0 {
+        return b;
+    }
+    let force = pr.f("force");
+    let gravity = pr.f("gravity");
+    let spin = pr.f("spinning").to_radians();
+    let fc = pr.v2("forceCenter");
+    let dir_rand = pr.f("directionRandomness") / 100.0;
+    let spd_rand = pr.f("speedRandomness") / 100.0;
+    let g = pr.f("gridSpacing").max(1.0);
+    let object = pr.e("object");
+    let depth_sort = pr.b("enableDepthSort");
+    let seed = ctx.seed.wrapping_mul(0x632be5ab);
+    let [lw, lh] = ctx.layer_size;
+    let s = b.scale;
+    let cam = Cam { c: [b.offset[0] + lw * 0.5 * s, b.offset[1] + lh * 0.5 * s], d: 2.0 * lw.max(lh) * s };
+    let nx = (lw / g).ceil().max(1.0) as u32;
+    let ny = (lh / g).ceil().max(1.0) as u32;
+    let tri = object <= 1;
+    let textured = object == 1 || object == 3;
+    let maxd = lw.max(lh);
+    let src = b.img.clone();
+    let per = if tri { 2 } else { 1 };
+    let mut pieces: Vec<Piece> = (0..nx * ny * per)
+        .into_par_iter()
+        .filter_map(|i| {
+            let cell = i / per;
+            let (x0, y0) = ((cell % nx) as f64 * g, (cell / nx) as f64 * g);
+            let poly: Vec<[f64; 2]> = if !tri {
+                vec![[x0, y0], [x0 + g, y0], [x0 + g, y0 + g], [x0, y0 + g]]
+            } else if i % 2 == 0 {
+                vec![[x0, y0], [x0 + g, y0], [x0, y0 + g]]
+            } else {
+                vec![[x0 + g, y0], [x0 + g, y0 + g], [x0, y0 + g]]
+            };
+            let c = [poly.iter().map(|v| v[0]).sum::<f64>() / poly.len() as f64, poly.iter().map(|v| v[1]).sum::<f64>() / poly.len() as f64];
+            let (dx, dy) = (c[0] - fc[0], c[1] - fc[1]);
+            let dist = (dx * dx + dy * dy).sqrt().max(1e-6);
+            let ang = dy.atan2(dx) + dir_rand * std::f64::consts::PI * hs(i, 1, seed) as f64;
+            let speed = force / 100.0 * 0.6 * maxd / (1.0 + dist / (0.5 * maxd)) * (1.0 + spd_rand * hs(i, 2, seed) as f64);
+            let vz = -speed * 0.5 * h(i, 3, seed) as f64;
+            let pos = [c[0] + ang.cos() * speed * t, c[1] + ang.sin() * speed * t + 0.5 * gravity * 0.5 * lh * t * t, vz * t];
+            let axis = [hs(i, 4, seed) as f64, hs(i, 5, seed) as f64, hs(i, 6, seed) as f64];
+            let r = rot_axis(axis, t * (std::f64::consts::PI * h(i, 7, seed) as f64 + spin));
+            let tex: Vec<[f32; 2]> = poly.iter().map(|v| [(v[0] * s + b.offset[0]) as f32, (v[1] * s + b.offset[1]) as f32]).collect();
+            let c0 = [(c[0] * s + b.offset[0]) as f32, (c[1] * s + b.offset[1]) as f32];
+            let posb = [pos[0] * s + b.offset[0], pos[1] * s + b.offset[1], pos[2] * s];
+            let mut pc = Piece::new(&tex, c0, &r, posb, cam)?;
+            pc.shade = 0.35 + 0.65 * Piece::facing(&r);
+            if !textured {
+                let (cc, a) = unpremul(src.sample_bilinear(c0[0] as f64, c0[1] as f64));
+                if a <= 0.0 {
+                    return None;
+                }
+                pc.flat = Some(cc);
+                pc.alpha = a;
+            }
+            Some(pc)
+        })
+        .collect();
+    if depth_sort {
+        sort_far_first(&mut pieces);
+    }
+    let mut out = Image::new(src.width, src.height);
+    draw_pieces(&mut out, &pieces, &src, None);
+    b.img = out;
+    b
+}
+
+// ------------------------------------------------------------------ CC Scatterize
+
+fn scatterize(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let scatter = pr.f("scatter") as f32;
+    let right = pr.f("rightTwist").to_radians();
+    let left = pr.f("leftTwist").to_radians();
+    if scatter == 0.0 && right == 0.0 && left == 0.0 {
+        return b;
+    }
+    let add = pr.e("transferMode") == 1;
+    let seed = ctx.seed.wrapping_mul(0x7feb352d);
+    let s = b.scale;
+    let (w, hh) = (b.img.width, b.img.height);
+    let (cx, cy) = (b.offset[0] + ctx.layer_size[0] * 0.5 * s, b.offset[1] + ctx.layer_size[1] * 0.5 * s);
+    let half = (ctx.layer_size[0] * 0.5 * s).max(1.0);
+    let d = 2.0 * ctx.layer_size[0].max(ctx.layer_size[1]) * s;
+    let src = &b.img;
+    let sprites: Vec<Sprite> = (0..w * hh)
+        .into_par_iter()
+        .filter_map(|i| {
+            let px = src.data[i as usize];
+            if px[3] <= 0.0 {
+                return None;
+            }
+            let (x, y) = ((i % w) as f64 + 0.5, (i / w) as f64 + 0.5);
+            // Twist about the horizontal axis through the centre, growing towards each side.
+            let k = ((x - cx) / half).abs().min(1.0);
+            let ang = if x < cx { left } else { right } * k;
+            let (sa, ca) = ang.sin_cos();
+            let (yy, zz) = ((y - cy) * ca, (y - cy) * sa);
+            let persp = d / (d + zz).max(d * 0.05);
+            let jx = hs(i, 1, seed) * scatter * s as f32;
+            let jy = hs(i, 2, seed) * scatter * s as f32;
+            let sx = cx + (x - cx) * persp + jx as f64;
+            let sy = cy + yy * persp + jy as f64;
+            let (c, a) = unpremul(px);
+            Some(Sprite::new(sx as f32, sy as f32, 0.6 * persp as f32, [c[0], c[1], c[2], a], Shape::Disc))
+        })
+        .collect();
+    b.img = splat(w, hh, &sprites, if add { Acc::Add } else { Acc::Over });
+    b
+}
+
+// ------------------------------------------------------------------ Card Dance
+
+const CD_SOURCES: &[&str] = &["None", "Intensity 1", "Red 1", "Green 1", "Blue 1", "Alpha 1", "Intensity 2", "Red 2", "Green 2", "Blue 2", "Alpha 2"];
+const CD_PROPS: [(&str, &str); 8] = [
+    ("xPos", "X Position"),
+    ("yPos", "Y Position"),
+    ("zPos", "Z Position"),
+    ("xRot", "X Rotation"),
+    ("yRot", "Y Rotation"),
+    ("zRot", "Z Rotation"),
+    ("xScale", "X Scale"),
+    ("yScale", "Y Scale"),
+];
+
+fn card_source(src: u32, g1: [f32; 4], g2: [f32; 4]) -> f32 {
+    let (c1, a1) = unpremul(g1);
+    let (c2, a2) = unpremul(g2);
+    let lum = |c: [f32; 3]| effectcraft_color::luminance(c[0], c[1], c[2]);
+    match src {
+        1 => lum(c1),
+        2 => c1[0],
+        3 => c1[1],
+        4 => c1[2],
+        5 => a1,
+        6 => lum(c2),
+        7 => c2[0],
+        8 => c2[1],
+        9 => c2[2],
+        10 => a2,
+        _ => 0.0,
+    }
+}
+
+fn card_dance(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let rows = pr.f("rows").clamp(1.0, 1000.0) as u32;
+    let cols = if pr.e("rowsColumns") == 1 { rows } else { pr.f("columns").clamp(1.0, 1000.0) as u32 };
+    let g1 = layer_or_self(ctx, &b, "gradientLayer1", true, true);
+    let g2 = layer_or_self(ctx, &b, "gradientLayer2", true, true);
+    let back = ctx.layer_param("backLayer", true).map(|o| crate::util::fit_layer(ctx, &b, &o, true));
+    let [lw, lh] = ctx.layer_size;
+    let s = b.scale;
+    let (cw, ch) = (lw / cols as f64, lh / rows as f64);
+    let zpos = pr.f("cameraZ").max(0.05);
+    let focal = pr.f("focalLength").max(1.0);
+    let cam = Cam { c: [b.offset[0] + lw * 0.5 * s, b.offset[1] + lh * 0.5 * s], d: lw.max(lh) * s * zpos * focal / 140.0 };
+    let ambient = pr.f("ambientLight") as f32;
+    let diffuse = pr.f("diffuse") as f32;
+    let intensity = pr.f("lightIntensity") as f32;
+    let props: Vec<(u32, f64, f64)> =
+        CD_PROPS.iter().map(|(id, _)| (pr.e(&format!("{id}Source")), pr.f(&format!("{id}Multiplier")), pr.f(&format!("{id}Offset")))).collect();
+    let src = b.img.clone();
+    let mut pieces: Vec<Piece> = (0..rows * cols)
+        .into_par_iter()
+        .filter_map(|i| {
+            let (cx0, cy0) = ((i % cols) as f64 * cw, (i / cols) as f64 * ch);
+            let c = [cx0 + cw * 0.5, cy0 + ch * 0.5];
+            let (bx, by) = (c[0] * s + b.offset[0], c[1] * s + b.offset[1]);
+            let (gp1, gp2) = (g1.sample_bilinear(bx, by), g2.sample_bilinear(bx, by));
+            let val = |k: usize| {
+                let (sr, m, o) = props[k];
+                o + m * card_source(sr, gp1, gp2) as f64
+            };
+            let (sx, sy) = (val(6), val(7));
+            let r = rot_xyz(val(3).to_radians(), val(4).to_radians(), val(5).to_radians());
+            let rs: M3 = std::array::from_fn(|k| [r[k][0] * sx, r[k][1] * sy, r[k][2]]);
+            let pos = [bx + val(0) * cw * s, by + val(1) * ch * s, val(2) * cw.max(ch) * s];
+            let (tx0, ty0) = ((cx0 * s + b.offset[0]) as f32, (cy0 * s + b.offset[1]) as f32);
+            let (tw, th) = ((cw * s) as f32, (ch * s) as f32);
+            let poly = [[tx0, ty0], [tx0 + tw, ty0], [tx0 + tw, ty0 + th], [tx0, ty0 + th]];
+            let mut pc = Piece::new(&poly, [bx as f32, by as f32], &rs, pos, cam)?;
+            pc.shade = ambient + diffuse * intensity * Piece::facing(&r);
+            Some(pc)
+        })
+        .collect();
+    sort_far_first(&mut pieces);
+    let mut out = Image::new(src.width, src.height);
+    draw_pieces(&mut out, &pieces, &src, back.as_ref());
+    b.img = out;
+    b
+}
+
+// ------------------------------------------------------------------ Shatter
+
+const SHATTER_PATTERNS: &[&str] = &["Bricks", "Glass", "Hexagons", "Squares", "Triangles"];
+
+/// Pattern cells (polygons in pattern space, before rotation) covering `[x0, x1]×[y0, y1]`.
+fn pattern_cells(kind: u32, cell: f64, x0: f64, y0: f64, x1: f64, y1: f64, seed: u32) -> Vec<Vec<[f64; 2]>> {
+    let mut out = Vec::new();
+    let i0 = (x0 / cell).floor() as i64 - 1;
+    let i1 = (x1 / cell).ceil() as i64 + 1;
+    let j0 = (y0 / cell).floor() as i64 - 1;
+    let j1 = (y1 / cell).ceil() as i64 + 1;
+    match kind {
+        0 => {
+            let bh = cell * 0.5;
+            let r0 = (y0 / bh).floor() as i64 - 1;
+            let r1 = (y1 / bh).ceil() as i64 + 1;
+            for r in r0..=r1 {
+                let sh = if r.rem_euclid(2) == 1 { cell * 0.5 } else { 0.0 };
+                for i in i0..=i1 {
+                    let (x, y) = (i as f64 * cell + sh, r as f64 * bh);
+                    out.push(vec![[x, y], [x + cell, y], [x + cell, y + bh], [x, y + bh]]);
+                }
+            }
+        }
+        1 => {
+            // Jittered lattice split into triangles along a random diagonal.
+            let jit = |i: i64, j: i64| -> [f64; 2] {
+                let (a, b) = (i as u32, j as u32);
+                [i as f64 * cell + hs(a, b.wrapping_add(17), seed) as f64 * cell * 0.35, j as f64 * cell + hs(a, b.wrapping_add(91), seed) as f64 * cell * 0.35]
+            };
+            for j in j0..=j1 {
+                for i in i0..=i1 {
+                    let (p00, p10, p11, p01) = (jit(i, j), jit(i + 1, j), jit(i + 1, j + 1), jit(i, j + 1));
+                    if h(i as u32, j as u32, seed ^ 0x55) < 0.5 {
+                        out.push(vec![p00, p10, p11]);
+                        out.push(vec![p00, p11, p01]);
+                    } else {
+                        out.push(vec![p00, p10, p01]);
+                        out.push(vec![p10, p11, p01]);
+                    }
+                }
+            }
+        }
+        2 => {
+            let r = cell / 3f64.sqrt();
+            let dx = 1.5 * r;
+            let dy = 3f64.sqrt() * r;
+            let c0 = (x0 / dx).floor() as i64 - 1;
+            let c1 = (x1 / dx).ceil() as i64 + 1;
+            let rr0 = (y0 / dy).floor() as i64 - 1;
+            let rr1 = (y1 / dy).ceil() as i64 + 1;
+            for ci in c0..=c1 {
+                for rj in rr0..=rr1 {
+                    let cx = ci as f64 * dx;
+                    let cy = (rj as f64 + if ci.rem_euclid(2) == 1 { 0.5 } else { 0.0 }) * dy;
+                    out.push(
+                        (0..6)
+                            .map(|k| {
+                                let a = k as f64 * std::f64::consts::PI / 3.0;
+                                [cx + r * a.cos(), cy + r * a.sin()]
+                            })
+                            .collect(),
+                    );
+                }
+            }
+        }
+        3 => {
+            for j in j0..=j1 {
+                for i in i0..=i1 {
+                    let (x, y) = (i as f64 * cell, j as f64 * cell);
+                    out.push(vec![[x, y], [x + cell, y], [x + cell, y + cell], [x, y + cell]]);
+                }
+            }
+        }
+        _ => {
+            for j in j0..=j1 {
+                for i in i0..=i1 {
+                    let (x, y) = (i as f64 * cell, j as f64 * cell);
+                    if (i + j).rem_euclid(2) == 0 {
+                        out.push(vec![[x, y], [x + cell, y], [x, y + cell]]);
+                        out.push(vec![[x + cell, y], [x + cell, y + cell], [x, y + cell]]);
+                    } else {
+                        out.push(vec![[x, y], [x + cell, y], [x + cell, y + cell]]);
+                        out.push(vec![[x, y], [x + cell, y + cell], [x, y + cell]]);
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
+/// `∫0^t e^{-ks} ds` and `∫0^t ∫0^u e^{-ks} ds du` (drag-damped ballistic factors).
+fn drag_factors(k: f64, t: f64) -> (f64, f64) {
+    if k < 1e-6 {
+        (t, 0.5 * t * t)
+    } else {
+        let e = (-k * t).exp();
+        ((1.0 - e) / k, t / k - (1.0 - e) / (k * k))
+    }
+}
+
+fn shatter(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let view = pr.e("view");
+    let render = pr.e("render");
+    let kind = pr.e("pattern");
+    let reps = pr.f("repetitions").clamp(1.0, 500.0);
+    let dir = pr.f("direction").to_radians();
+    let origin = pr.v2("origin");
+    let forces = [
+        (pr.v2("force1Position"), pr.f("force1Depth"), pr.f("force1Radius"), pr.f("force1Strength")),
+        (pr.v2("force2Position"), pr.f("force2Depth"), pr.f("force2Radius"), pr.f("force2Strength")),
+    ];
+    let rot_speed = pr.f("rotationSpeed");
+    let tumble = pr.e("tumbleAxis");
+    let randomness = pr.f("randomness");
+    let k = pr.f("viscosity").max(0.0) * 5.0;
+    let mass_var = pr.f("massVariance") / 100.0;
+    let gravity = pr.f("gravity");
+    let gdir = pr.f("gravityDirection").to_radians();
+    let ginc = pr.f("gravityInclination").to_radians();
+    let ambient = pr.f("ambientLight") as f32;
+    let intensity = pr.f("lightIntensity") as f32;
+    let seed = (pr.f("randomSeed") as u32).wrapping_mul(0x9e3779b1) ^ ctx.seed;
+    let [lw, lh] = ctx.layer_size;
+    let s = b.scale;
+    let t = ctx.time.max(0.0);
+    let unit = lw * 0.1;
+    let cell = lw / reps;
+    let cam = Cam { c: [b.offset[0] + lw * 0.5 * s, b.offset[1] + lh * 0.5 * s], d: 2.0 * lw.max(lh) * s };
+    let (sd, cd) = dir.sin_cos();
+    let to_layer = |q: [f64; 2]| [origin[0] + q[0] * cd - q[1] * sd, origin[1] + q[0] * sd + q[1] * cd];
+    // Pattern-space bounds of the layer rectangle.
+    let corners = [[0.0, 0.0], [lw, 0.0], [lw, lh], [0.0, lh]].map(|c: [f64; 2]| {
+        let (dx, dy) = (c[0] - origin[0], c[1] - origin[1]);
+        [dx * cd + dy * sd, -dx * sd + dy * cd]
+    });
+    let (px0, px1) = (corners.iter().map(|c| c[0]).fold(f64::INFINITY, f64::min), corners.iter().map(|c| c[0]).fold(f64::NEG_INFINITY, f64::max));
+    let (py0, py1) = (corners.iter().map(|c| c[1]).fold(f64::INFINITY, f64::min), corners.iter().map(|c| c[1]).fold(f64::NEG_INFINITY, f64::max));
+    let cells = pattern_cells(kind, cell, px0, py0, px1, py1, seed);
+    let g3 = [gdir.sin() * ginc.cos() * gravity * unit, -gdir.cos() * ginc.cos() * gravity * unit, ginc.sin() * gravity * unit];
+    let src = b.img.clone();
+    let mut pieces: Vec<Piece> = cells
+        .par_iter()
+        .enumerate()
+        .filter_map(|(i, poly)| {
+            let i = i as u32;
+            let lp: Vec<[f64; 2]> = poly.iter().map(|&q| to_layer(q)).collect();
+            let (mnx, mxx) = (lp.iter().map(|v| v[0]).fold(f64::INFINITY, f64::min), lp.iter().map(|v| v[0]).fold(f64::NEG_INFINITY, f64::max));
+            let (mny, mxy) = (lp.iter().map(|v| v[1]).fold(f64::INFINITY, f64::min), lp.iter().map(|v| v[1]).fold(f64::NEG_INFINITY, f64::max));
+            if mxx < 0.0 || mxy < 0.0 || mnx > lw || mny > lh {
+                return None;
+            }
+            let c = [lp.iter().map(|v| v[0]).sum::<f64>() / lp.len() as f64, lp.iter().map(|v| v[1]).sum::<f64>() / lp.len() as f64];
+            // Broken when inside a force sphere (centred `depth` in front of the layer).
+            let mut v = [0.0f64; 3];
+            let mut broken = false;
+            for (fp, fd, fr, fs) in forces {
+                let rad = fr * lw;
+                if rad <= 0.0 {
+                    continue;
+                }
+                let dv = [c[0] - fp[0], c[1] - fp[1], fd * lw];
+                let dist = (dv[0] * dv[0] + dv[1] * dv[1] + dv[2] * dv[2]).sqrt();
+                if dist < rad {
+                    broken = true;
+                    let f = fs * (1.0 - dist / rad) * unit / dist.max(1e-6);
+                    for q in 0..3 {
+                        v[q] += dv[q] * f;
+                    }
+                }
+            }
+            if (broken && render == 1) || (!broken && render == 2) {
+                return None;
+            }
+            let mut pos = [c[0], c[1], 0.0];
+            let mut r = rot_axis([1.0, 0.0, 0.0], 0.0);
+            if broken && t > 0.0 {
+                let mass = 1.0 + mass_var * hs(i, 1, seed) as f64;
+                for q in 0..3 {
+                    v[q] = v[q] / mass + randomness * unit * hs(i, 2 + q as u32, seed) as f64 * 2.0;
+                }
+                let (f1, f2) = drag_factors(k, t);
+                for q in 0..3 {
+                    pos[q] += v[q] * f1 + g3[q] * f2;
+                }
+                let axis = match tumble {
+                    1 => [0.0, 0.0, 0.0],
+                    2 => [1.0, 0.0, 0.0],
+                    3 => [0.0, 1.0, 0.0],
+                    4 => [0.0, 0.0, 1.0],
+                    5 => [hs(i, 6, seed) as f64, hs(i, 7, seed) as f64, 0.0],
+                    6 => [hs(i, 6, seed) as f64, 0.0, hs(i, 8, seed) as f64],
+                    7 => [0.0, hs(i, 7, seed) as f64, hs(i, 8, seed) as f64],
+                    _ => [hs(i, 6, seed) as f64, hs(i, 7, seed) as f64, hs(i, 8, seed) as f64],
+                };
+                let speed = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt() / unit;
+                let omega = rot_speed * std::f64::consts::TAU * (0.5 + h(i, 9, seed) as f64) * speed.min(10.0);
+                r = rot_axis(axis, omega * f1);
+            }
+            let tex: Vec<[f32; 2]> = lp.iter().map(|v| [(v[0] * s + b.offset[0]) as f32, (v[1] * s + b.offset[1]) as f32]).collect();
+            let c0 = [(c[0] * s + b.offset[0]) as f32, (c[1] * s + b.offset[1]) as f32];
+            let posb = [pos[0] * s + b.offset[0], pos[1] * s + b.offset[1], pos[2] * s];
+            let mut pc = Piece::new(&tex, c0, &r, posb, cam)?;
+            pc.shade = ambient + (1.0 - ambient) * intensity * Piece::facing(&r);
+            Some(pc)
+        })
+        .collect();
+    sort_far_first(&mut pieces);
+    let mut out = Image::new(src.width, src.height);
+    if view == 0 {
+        draw_pieces(&mut out, &pieces, &src, None);
+    } else {
+        // Wireframes: piece outlines (front view: at rest; otherwise animated), plus forces.
+        let animated = view == 2 || view == 4;
+        let mut lines = Vec::new();
+        for pc in &pieces {
+            let n = pc.n as usize;
+            let pts: Vec<[f32; 2]> = if animated {
+                let fw = inv3(&pc.inv);
+                match fw {
+                    Some(m) => pc.poly[..n]
+                        .iter()
+                        .map(|v| {
+                            let (a, bb) = ((v[0] - pc.c0[0]) as f64, (v[1] - pc.c0[1]) as f64);
+                            let w = m[2][0] * a + m[2][1] * bb + m[2][2];
+                            [((m[0][0] * a + m[0][1] * bb + m[0][2]) / w) as f32, ((m[1][0] * a + m[1][1] * bb + m[1][2]) / w) as f32]
+                        })
+                        .collect(),
+                    None => continue,
+                }
+            } else {
+                pc.poly[..n].to_vec()
+            };
+            for e in 0..n {
+                let (a, c) = (pts[e], pts[(e + 1) % n]);
+                lines.push(Sprite::new(a[0], a[1], 0.5, [0.75, 0.85, 1.0, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
+            }
+        }
+        if view >= 3 {
+            for (fp, _, fr, _) in forces {
+                let (fx, fy) = b.to_px(fp);
+                let rad = fr * lw * s;
+                for k in 0..64 {
+                    let (a0, a1) = (k as f64 / 64.0 * std::f64::consts::TAU, (k + 1) as f64 / 64.0 * std::f64::consts::TAU);
+                    let (x0, y0) = (fx + rad * a0.cos(), fy + rad * a0.sin());
+                    let (x1, y1) = (fx + rad * a1.cos(), fy + rad * a1.sin());
+                    lines.push(Sprite::new(x0 as f32, y0 as f32, 0.5, [1.0, 0.3, 0.3, 1.0], Shape::Line { dx: (x1 - x0) as f32, dy: (y1 - y0) as f32 }));
+                }
+            }
+        }
+        out = splat(src.width, src.height, &lines, Acc::Over);
+    }
+    b.img = out;
+    b
+}
+
+// ------------------------------------------------------------------ Caustics
+
+/// Sample with repeat mode: 0 Once (transparent outside), 1 Tiled, 2 Reflected.
+fn sample_repeat(img: &Image, x: f64, y: f64, mode: u32) -> Px {
+    let (w, hh) = (img.width as f64, img.height as f64);
+    match mode {
+        1 => img.sample_bilinear_clamped(x.rem_euclid(w), y.rem_euclid(hh)),
+        2 => {
+            let m = |v: f64, n: f64| {
+                let r = v.rem_euclid(2.0 * n);
+                if r > n { 2.0 * n - r } else { r }
+            };
+            img.sample_bilinear_clamped(m(x, w), m(y, hh))
+        }
+        _ => img.sample_bilinear(x, y),
+    }
+}
+
+fn caustics(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let s = b.scale;
+    let mut bottom = layer_or_self(ctx, &b, "bottom", true, pr.e("bottomSizeDiffers") == 1);
+    let blur = pr.f("blur") * s;
+    if blur > 0.05 {
+        bottom = effectcraft_raster::gaussian_blur(&bottom, blur * 0.5, blur * 0.5, false);
+    }
+    let scaling = pr.f("scaling").max(0.01);
+    let repeat = pr.e("repeatMode");
+    let wave_h = pr.f("waveHeight");
+    let smoothing = pr.f("smoothing") * s;
+    let depth = pr.f("waterDepth");
+    let ior = pr.f("refractiveIndex").max(1.0);
+    let surf = pr.color("surfaceColor");
+    let surf_op = pr.f("surfaceOpacity") as f32;
+    let cstr = pr.f("causticsStrength") as f32;
+    let li = pr.f("lightIntensity") as f32;
+    let lc = pr.color("lightColor");
+    let lpos = pr.v2("lightPosition");
+    let lheight = pr.f("lightHeight").max(0.01);
+    let ambient = pr.f("ambientLight") as f32;
+    let diffuse = pr.f("diffuse") as f32;
+    let specular = pr.f("specular") as f32;
+    let sharp = pr.f("highlightSharpness").max(1.0) as f32;
+    let (w, hh) = (b.img.width as usize, b.img.height as usize);
+    // Height field of the water surface (luminance of the chosen layer; none = flat).
+    let height = ctx.layer_param("waterSurface", true).map(|o| {
+        let img = crate::util::fit_layer(ctx, &b, &o, true);
+        let pl = Plane::luma(&img);
+        if smoothing > 0.05 { gauss_plane(&pl, smoothing * 0.5, smoothing * 0.5) } else { pl }
+    });
+    let lw = ctx.layer_size[0] * s;
+    let k = wave_h * depth * (1.0 - 1.0 / ior) * lw * 2.0;
+    let (cx, cy) = (b.offset[0] + ctx.layer_size[0] * 0.5 * s, b.offset[1] + ctx.layer_size[1] * 0.5 * s);
+    let (lx, ly) = b.to_px(lpos);
+    let lv = {
+        let v = [(lx - cx) / lw.max(1.0), (ly - cy) / lw.max(1.0), lheight];
+        let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+        [(v[0] / n) as f32, (v[1] / n) as f32, (v[2] / n) as f32]
+    };
+    let grad = |x: usize, y: usize| -> (f64, f64) {
+        match &height {
+            Some(pl) => {
+                let gx = (pl.get_clamped(x as i64 + 1, y as i64) - pl.get_clamped(x as i64 - 1, y as i64)) as f64 * 0.5;
+                let gy = (pl.get_clamped(x as i64, y as i64 + 1) - pl.get_clamped(x as i64, y as i64 - 1)) as f64 * 0.5;
+                (gx, gy)
+            }
+            None => (0.0, 0.0),
+        }
+    };
+    // Displacement and its Jacobian (caustic focusing) per pixel.
+    let disp: Vec<(f64, f64)> = (0..w * hh)
+        .into_par_iter()
+        .map(|i| {
+            let (gx, gy) = grad(i % w, i / w);
+            (-gx * k, -gy * k)
+        })
+        .collect();
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let i = y * w + x;
+            let (dx, dy) = disp[i];
+            let d = |xx: usize, yy: usize| disp[yy.min(hh - 1) * w + xx.min(w - 1)];
+            let (dxr, _) = d(x + 1, y);
+            let (_, dyd) = d(x, y + 1);
+            let (dxl, _) = d(x.saturating_sub(1), y);
+            let (_, dyu) = d(x, y.saturating_sub(1));
+            let jac = (1.0 + (dxr - dxl) * 0.5) * (1.0 + (dyd - dyu) * 0.5);
+            let focus = ((1.0 / jac.abs().max(0.2)) as f32 - 1.0).clamp(-1.0, 4.0);
+            let sx = cx + (x as f64 + 0.5 + dx - cx) / scaling;
+            let sy = cy + (y as f64 + 0.5 + dy - cy) / scaling;
+            let p = sample_repeat(&bottom, sx, sy, repeat);
+            let (c, a) = unpremul(p);
+            let (gx, gy) = grad(x, y);
+            let n = {
+                let v = [-gx * wave_h * 20.0, -gy * wave_h * 20.0, 1.0];
+                let m = (v[0] * v[0] + v[1] * v[1] + 1.0).sqrt();
+                [(v[0] / m) as f32, (v[1] / m) as f32, (v[2] / m) as f32]
+            };
+            let nl = (n[0] * lv[0] + n[1] * lv[1] + n[2] * lv[2]).max(0.0);
+            let hv = {
+                let v = [lv[0], lv[1], lv[2] + 1.0];
+                let m = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+                [v[0] / m, v[1] / m, v[2] / m]
+            };
+            let spec = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(sharp) * specular * li;
+            let light = ambient + diffuse * li * nl + cstr * focus * li;
+            let cc: [f32; 3] = std::array::from_fn(|q| {
+                let base = c[q] * light * lc[q];
+                base * (1.0 - surf_op) + surf[q] * surf_op * (ambient + diffuse * li * nl) + spec * lc[q]
+            });
+            let a = (a + surf_op * (1.0 - a)).min(1.0);
+            *px = [cc[0] * a, cc[1] * a, cc[2] * a, a];
+        }
+    });
+    b
+}
+
+// ------------------------------------------------------------------ Wave World
+
+#[derive(Clone, Debug)]
+struct Waves {
+    nx: usize,
+    ny: usize,
+    u: Vec<f32>,
+    v: Vec<f32>,
+}
+
+struct Producer {
+    ring: bool,
+    pos: [f32; 2],
+    len: f32,
+    width: f32,
+    angle: f32,
+    amp: f32,
+    freq: f32,
+    phase: f32,
+}
+
+impl Producer {
+    /// Weight of a grid point (layer-fraction coordinates, x in widths, y in widths).
+    fn weight(&self, x: f32, y: f32) -> f32 {
+        let (dx, dy) = (x - self.pos[0], y - self.pos[1]);
+        let (sa, ca) = self.angle.sin_cos();
+        let (u, v) = (dx * ca + dy * sa, -dx * sa + dy * ca);
+        let d = if self.ring {
+            let (a, bb) = ((self.len * 0.5).max(1e-3), (self.width * 0.5).max(1e-3));
+            ((u / a).powi(2) + (v / bb).powi(2)).sqrt()
+        } else {
+            let l = (self.len * 0.5).max(1e-3);
+            let wd = (self.width * 0.5).max(1e-3);
+            (u.abs() / l).max(v.abs() / wd)
+        };
+        (1.0 - d).clamp(0.0, 1.0).min(1.0)
+    }
+}
+
+static WAVE_CACHE: SimCache<Waves> = SimCache::new(4);
+
+fn wave_world(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let [lw, lh] = ctx.layer_size;
+    let res = pr.f("gridResolution").clamp(1.0, 400.0) as usize;
+    let res = if pr.b("gridResDownsamples") { ((res as f64) * b.scale).round().max(1.0) as usize } else { res };
+    let nx = res.max(2) + 1;
+    let ny = ((res as f64 * lh / lw.max(1.0)).round() as usize).max(2) + 1;
+    let speed = pr.f("waveSpeed").max(0.0) as f32;
+    let damping = pr.f("damping").max(0.0) as f32;
+    let reflect = pr.e("reflectEdges");
+    let preroll = pr.f("preRoll").max(0.0);
+    let prods: Vec<Producer> = [1, 2]
+        .iter()
+        .map(|k| {
+            let pos = pr.v2(&format!("producer{k}Position"));
+            Producer {
+                ring: pr.e(&format!("producer{k}Type")) == 0,
+                pos: [(pos[0] / lw.max(1.0)) as f32, (pos[1] / lw.max(1.0)) as f32],
+                len: pr.f(&format!("producer{k}Length")) as f32,
+                width: pr.f(&format!("producer{k}Width")) as f32,
+                angle: (pr.f(&format!("producer{k}Angle")) as f32).to_radians(),
+                amp: pr.f(&format!("producer{k}Amplitude")) as f32,
+                freq: pr.f(&format!("producer{k}Frequency")) as f32,
+                phase: (pr.f(&format!("producer{k}Phase")) as f32).to_radians(),
+            }
+        })
+        .collect();
+    let sps = crate::sim::SPS as f32;
+    // Wave speed in layer widths per second → cells per second; sub-steps keep it stable.
+    let cps = speed * (nx - 1) as f32;
+    let sub = ((cps * 2.0 / sps).ceil() as usize).clamp(1, 64);
+    let dt = 1.0 / (sps * sub as f32);
+    let cell = 1.0 / (nx - 1) as f32;
+    let weights: Vec<Vec<f32>> = prods.iter().map(|p| (0..nx * ny).map(|i| p.weight((i % nx) as f32 * cell, (i / nx) as f32 * cell)).collect()).collect();
+    let key = params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: if pr.b("gridResDownsamples") { b.scale } else { 1.0 } }, 4);
+    let steps = crate::sim::steps_at(ctx.time + preroll);
+    let st = WAVE_CACHE.run(
+        key,
+        steps,
+        || Waves { nx, ny, u: vec![0.0; nx * ny], v: vec![0.0; nx * ny] },
+        |w, step| {
+            for k in 0..sub {
+                let t = (step as f32 + k as f32 / sub as f32) / sps - preroll as f32;
+                let c2 = cps * cps;
+                let mut acc = vec![0.0f32; nx * ny];
+                for y in 0..ny {
+                    for x in 0..nx {
+                        let i = y * nx + x;
+                        let g = |xx: usize, yy: usize| w.u[yy * nx + xx];
+                        let l = g(x.saturating_sub(1), y) + g((x + 1).min(nx - 1), y) + g(x, y.saturating_sub(1)) + g(x, (y + 1).min(ny - 1)) - 4.0 * w.u[i];
+                        acc[i] = c2 * l - damping * 4.0 * w.v[i];
+                    }
+                }
+                for i in 0..nx * ny {
+                    w.v[i] += acc[i] * dt;
+                    w.u[i] += w.v[i] * dt;
+                }
+                // Producers drive the surface.
+                for (p, wt) in prods.iter().zip(&weights) {
+                    if p.amp == 0.0 {
+                        continue;
+                    }
+                    let target = p.amp * (std::f32::consts::TAU * p.freq * t + p.phase).sin();
+                    for i in 0..nx * ny {
+                        if wt[i] > 0.0 {
+                            w.u[i] += (target - w.u[i]) * wt[i];
+                            w.v[i] *= 1.0 - wt[i];
+                        }
+                    }
+                }
+                // Edges: reflective ones mirror; the others absorb in a thin sponge layer.
+                let refl = |side: u32| reflect == 5 || reflect == side;
+                let sponge = 4usize.min(nx / 4).max(1);
+                for y in 0..ny {
+                    for x in 0..nx {
+                        let i = y * nx + x;
+                        let mut f = 1.0f32;
+                        if !refl(1) && x < sponge {
+                            f = f.min(x as f32 / sponge as f32);
+                        }
+                        if !refl(3) && nx - 1 - x < sponge {
+                            f = f.min((nx - 1 - x) as f32 / sponge as f32);
+                        }
+                        if !refl(2) && y < sponge {
+                            f = f.min(y as f32 / sponge as f32);
+                        }
+                        if !refl(4) && ny - 1 - y < sponge {
+                            f = f.min((ny - 1 - y) as f32 / sponge as f32);
+                        }
+                        if f < 1.0 {
+                            let k = 0.85 + 0.15 * f;
+                            w.u[i] *= k;
+                            w.v[i] *= k;
+                        }
+                    }
+                }
+            }
+        },
+    );
+    let s = b.scale;
+    let (bw, bh) = (b.img.width, b.img.height);
+    let sample = |x: f64, y: f64| -> f32 {
+        let gx = (x / lw.max(1.0) * (st.nx - 1) as f64).clamp(0.0, (st.nx - 1) as f64);
+        let gy = (y / lw.max(1.0) * (st.nx - 1) as f64).clamp(0.0, (st.ny - 1) as f64);
+        let (x0, y0) = (gx.floor() as usize, gy.floor() as usize);
+        let (x1, y1) = ((x0 + 1).min(st.nx - 1), (y0 + 1).min(st.ny - 1));
+        let (tx, ty) = ((gx - x0 as f64) as f32, (gy - y0 as f64) as f32);
+        let g = |xx: usize, yy: usize| st.u[yy * st.nx + xx];
+        let a = g(x0, y0) + (g(x1, y0) - g(x0, y0)) * tx;
+        let c = g(x0, y1) + (g(x1, y1) - g(x0, y1)) * tx;
+        a + (c - a) * ty
+    };
+    if pr.e("view") == 1 {
+        let bright = pr.f("brightness") as f32;
+        let contrast = pr.f("contrast") as f32;
+        let gamma = pr.f("gamma").max(0.01) as f32;
+        let alpha = 1.0 - pr.f("transparency") as f32;
+        b.img.rows_mut().for_each(|(y, row)| {
+            for (x, px) in row.iter_mut().enumerate() {
+                let lx = (x as f64 + 0.5 - b.offset[0]) / s;
+                let ly = (y as f64 + 0.5 - b.offset[1]) / s;
+                let v = (bright + contrast * sample(lx, ly)).clamp(0.0, 1.0).powf(1.0 / gamma);
+                *px = [v * alpha, v * alpha, v * alpha, alpha];
+            }
+        });
+    } else {
+        // Wireframe preview: the grid seen at an angle, heights lifting the lines.
+        let lift = lh as f32 * 0.25;
+        let to = |x: usize, y: usize| -> [f32; 2] {
+            let lx = x as f64 / (st.nx - 1) as f64 * lw;
+            let ly = y as f64 / (st.nx - 1) as f64 * lw;
+            let (px, py) = b.to_px([lx, lh * 0.25 + ly * 0.6]);
+            [px as f32, py as f32 - st.u[y * st.nx + x] * lift * s as f32]
+        };
+        let mut lines = Vec::new();
+        for y in 0..st.ny {
+            for x in 0..st.nx {
+                let a = to(x, y);
+                if x + 1 < st.nx {
+                    let c = to(x + 1, y);
+                    lines.push(Sprite::new(a[0], a[1], 0.4, [0.4, 0.9, 0.4, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
+                }
+                if y + 1 < st.ny {
+                    let c = to(x, y + 1);
+                    lines.push(Sprite::new(a[0], a[1], 0.4, [0.4, 0.9, 0.4, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
+                }
+            }
+        }
+        let wire = splat(bw, bh, &lines, Acc::Over);
+        b.img = crate::sim::combine(&Image::filled(bw, bh, [0.0, 0.0, 0.0, 1.0]), &wire, 0);
+    }
+    b
+}
+
+// ------------------------------------------------------------------ Foam
+
+#[derive(Clone, Debug)]
+struct FoamBubble {
+    p: [f32; 2],
+    v: [f32; 2],
+    age: f32,
+    size: f32,
+    id: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+struct FoamState {
+    b: Vec<FoamBubble>,
+    carry: f32,
+    next: u32,
+}
+
+static FOAM_CACHE: SimCache<FoamState> = SimCache::new(4);
+
+/// Foam steps once per frame at 30 frames per second.
+const FOAM_FPS: f64 = 30.0;
+
+fn foam(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let unit = lw * 0.01;
+    let prod = pr.v2("producerPoint");
+    let (psx, psy) = (pr.f("producerXSize") as f32 * lw, pr.f("producerYSize") as f32 * lh);
+    let porient = (pr.f("producerOrientation") as f32).to_radians();
+    let rate = pr.f("productionRate").max(0.0) as f32;
+    let size = pr.f("size").max(0.0) as f32;
+    let size_var = pr.f("sizeVariance") as f32;
+    let lifespan = pr.f("lifespan").max(1.0) as f32;
+    let growth = pr.f("growthSpeed").max(0.0001) as f32;
+    let init_speed = pr.f("initialSpeed") as f32;
+    let init_dir = (pr.f("initialDirection") as f32).to_radians();
+    let wind = pr.f("windSpeed") as f32;
+    let wind_dir = (pr.f("windDirection") as f32).to_radians();
+    let turb = pr.f("turbulence") as f32;
+    let repulsion = pr.f("repulsion") as f32;
+    let viscosity = pr.f("viscosity").clamp(0.0, 1.0) as f32;
+    let sticky = pr.f("stickiness").clamp(0.0, 1.0) as f32;
+    let universe = pr.f("universeSize").max(0.01) as f32;
+    let seed = (pr.f("randomSeed") as u32).wrapping_mul(0x68e31da4) ^ ctx.seed;
+    let wvec = [wind_dir.sin() * wind * unit, -wind_dir.cos() * wind * unit];
+    let key = params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 5);
+    let steps = if ctx.time <= 0.0 { 0 } else { (ctx.time * FOAM_FPS + 1e-6).floor() as u64 };
+    let st = FOAM_CACHE.run(key, steps, FoamState::default, |st, step| {
+        let t = step as f32 / FOAM_FPS as f32;
+        // Births.
+        st.carry += rate;
+        let n = st.carry.floor() as u32;
+        st.carry -= n as f32;
+        for _ in 0..n {
+            if st.b.len() >= 3000 {
+                break;
+            }
+            let id = st.next;
+            st.next = st.next.wrapping_add(1);
+            let (ux, uy) = (hs(id, 1, seed) * 0.5 * psx, hs(id, 2, seed) * 0.5 * psy);
+            let (so, co) = porient.sin_cos();
+            let p = [prod[0] as f32 + ux * co - uy * so, prod[1] as f32 + ux * so + uy * co];
+            let v = [init_dir.sin() * init_speed * unit, -init_dir.cos() * init_speed * unit];
+            let sz = (size * (1.0 + size_var * hs(id, 3, seed))).max(0.01);
+            st.b.push(FoamBubble { p, v, age: 0.0, size: sz, id });
+        }
+        // Forces: drift towards the wind, turbulence, viscosity.
+        for q in st.b.iter_mut() {
+            let n1 = value_noise(q.p[0] / (lw * 0.15), q.p[1] / (lw * 0.15), t * 0.5, seed) - 0.5;
+            let n2 = value_noise(q.p[0] / (lw * 0.15) + 19.0, q.p[1] / (lw * 0.15), t * 0.5, seed) - 0.5;
+            for k in 0..2 {
+                q.v[k] += (wvec[k] - q.v[k]) * 0.1;
+                q.v[k] *= 1.0 - viscosity * 0.5;
+            }
+            q.v[0] += n1 * turb * unit;
+            q.v[1] += n2 * turb * unit;
+        }
+        // Repulsion between overlapping bubbles (grid hashed, deterministic order).
+        let rad = |q: &FoamBubble| q.size * unit * 3.0 * (q.age * growth).min(1.0);
+        if repulsion > 0.0 && st.b.len() > 1 {
+            let maxr = st.b.iter().map(rad).fold(0.0f32, f32::max).max(1.0);
+            let cs = maxr * 2.0;
+            let mut grid: std::collections::HashMap<(i32, i32), Vec<usize>> = std::collections::HashMap::new();
+            for (i, q) in st.b.iter().enumerate() {
+                grid.entry(((q.p[0] / cs).floor() as i32, (q.p[1] / cs).floor() as i32)).or_default().push(i);
+            }
+            let mut push = vec![[0.0f32; 2]; st.b.len()];
+            for (i, q) in st.b.iter().enumerate() {
+                let (gx, gy) = ((q.p[0] / cs).floor() as i32, (q.p[1] / cs).floor() as i32);
+                for dy in -1..=1 {
+                    for dx in -1..=1 {
+                        let Some(list) = grid.get(&(gx + dx, gy + dy)) else { continue };
+                        for &j in list {
+                            if j <= i {
+                                continue;
+                            }
+                            let o = &st.b[j];
+                            let (ddx, ddy) = (o.p[0] - q.p[0], o.p[1] - q.p[1]);
+                            let d = (ddx * ddx + ddy * ddy).sqrt().max(1e-4);
+                            let overlap = rad(q) + rad(o) - d;
+                            if overlap > 0.0 {
+                                let f = overlap * 0.5 * repulsion.min(4.0) * (1.0 - sticky * 0.5) / d;
+                                push[i][0] -= ddx * f;
+                                push[i][1] -= ddy * f;
+                                push[j][0] += ddx * f;
+                                push[j][1] += ddy * f;
+                            }
+                        }
+                    }
+                }
+            }
+            for (q, d) in st.b.iter_mut().zip(&push) {
+                q.p[0] += d[0].clamp(-maxr, maxr);
+                q.p[1] += d[1].clamp(-maxr, maxr);
+            }
+        }
+        let (ux0, uy0) = (-(universe - 1.0) * 0.5 * lw, -(universe - 1.0) * 0.5 * lh);
+        let (ux1, uy1) = (lw - ux0, lh - uy0);
+        for q in st.b.iter_mut() {
+            q.p[0] += q.v[0];
+            q.p[1] += q.v[1];
+            q.age += 1.0;
+        }
+        st.b.retain(|q| q.age < lifespan && q.p[0] > ux0 && q.p[0] < ux1 && q.p[1] > uy0 && q.p[1] < uy1);
+    });
+    let view = pr.e("view");
+    let zoom = pr.f("zoom").max(0.01) as f32;
+    let texture = pr.e("bubbleTexture");
+    let blend = pr.e("blendMode");
+    let s = b.scale as f32;
+    let (cx, cy) = (lw * 0.5, lh * 0.5);
+    let mut order: Vec<&FoamBubble> = st.b.iter().collect();
+    if blend == 2 {
+        // Solid New on Top: oldest first.
+        order.sort_by(|a, c| c.age.total_cmp(&a.age).then(a.id.cmp(&c.id)));
+    } else if blend == 1 {
+        order.sort_by(|a, c| a.age.total_cmp(&c.age).then(a.id.cmp(&c.id)));
+    }
+    let sprites: Vec<Sprite> = order
+        .iter()
+        .map(|q| {
+            let r = q.size * unit * 3.0 * (q.age * growth).min(1.0) * zoom * s;
+            let (bx, by) = b.to_px([(cx + (q.p[0] - cx) * zoom) as f64, (cy + (q.p[1] - cy) * zoom) as f64]);
+            let fade = ((lifespan - q.age) / 5.0).clamp(0.0, 1.0);
+            if view == 0 {
+                Sprite::new(bx as f32, by as f32, r, [0.55, 0.75, 1.0, fade], Shape::Bubble)
+            } else {
+                let (c, shape) = match texture {
+                    1 => ([0.95, 0.95, 0.92], Shape::Faded),
+                    2 => ([1.0, 0.6, 0.8], Shape::Bubble),
+                    3 => ([0.8, 0.85, 0.75], Shape::Bubble),
+                    4 => ([0.97, 0.97, 0.95], Shape::Sphere),
+                    _ => ([1.0, 1.0, 1.0], Shape::Bubble),
+                };
+                Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], fade], shape)
+            }
+        })
+        .collect();
+    b.img = splat(b.img.width, b.img.height, &sprites, if blend == 0 && view != 0 { Acc::Add } else { Acc::Over });
+    b
+}
+
+// ------------------------------------------------------------------ specs
+
+fn producer_params(k: u32, amp: f64, pos: (f64, f64)) -> Vec<crate::ParamSpec> {
+    let ids: [&'static str; 8] = match k {
+        1 => [
+            "producer1Type",
+            "producer1Position",
+            "producer1Length",
+            "producer1Width",
+            "producer1Angle",
+            "producer1Amplitude",
+            "producer1Frequency",
+            "producer1Phase",
+        ],
+        _ => [
+            "producer2Type",
+            "producer2Position",
+            "producer2Length",
+            "producer2Width",
+            "producer2Angle",
+            "producer2Amplitude",
+            "producer2Frequency",
+            "producer2Phase",
+        ],
+    };
+    vec![
+        p(ids[0], "Type", Value::Enum(0), popup(&["Ring", "Line"])),
+        p(ids[1], "Position", pt(pos.0, pos.1), ParamUi::Point),
+        p(ids[2], "Height/Length", num(0.1), slider(0.0, 2.0, 0.0, 1.0, 3)),
+        p(ids[3], "Width", num(0.1), slider(0.0, 2.0, 0.0, 1.0, 3)),
+        p(ids[4], "Angle", num(0.0), ParamUi::Angle),
+        p(ids[5], "Amplitude", num(amp), slider(-5.0, 5.0, -1.0, 1.0, 3)),
+        p(ids[6], "Frequency", num(1.0), slider(0.0, 30.0, 0.0, 5.0, 3)),
+        p(ids[7], "Phase", num(0.0), ParamUi::Angle),
+    ]
+}
+
+fn card_dance_params() -> Vec<crate::ParamSpec> {
+    let mut v = vec![
+        p("rowsColumns", "Rows & Columns", Value::Enum(0), popup(&["Independent", "Columns Follow Rows"])),
+        p("rows", "Rows", num(10.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
+        p("columns", "Columns", num(10.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
+        p("backLayer", "Back Layer", Value::Layer(None), ParamUi::Layer),
+        p("gradientLayer1", "Gradient Layer 1", Value::Layer(None), ParamUi::Layer),
+        p("gradientLayer2", "Gradient Layer 2", Value::Layer(None), ParamUi::Layer),
+    ];
+    let names: [[&'static str; 4]; 8] = [
+        ["xPosSource", "xPosMultiplier", "xPosOffset", "X Position"],
+        ["yPosSource", "yPosMultiplier", "yPosOffset", "Y Position"],
+        ["zPosSource", "zPosMultiplier", "zPosOffset", "Z Position"],
+        ["xRotSource", "xRotMultiplier", "xRotOffset", "X Rotation"],
+        ["yRotSource", "yRotMultiplier", "yRotOffset", "Y Rotation"],
+        ["zRotSource", "zRotMultiplier", "zRotOffset", "Z Rotation"],
+        ["xScaleSource", "xScaleMultiplier", "xScaleOffset", "X Scale"],
+        ["yScaleSource", "yScaleMultiplier", "yScaleOffset", "Y Scale"],
+    ];
+    debug_assert_eq!(names.len(), CD_PROPS.len());
+    for (i, n) in names.iter().enumerate() {
+        let rot = (3..6).contains(&i);
+        let scale = i >= 6;
+        let (lo, hi) = if rot { (-3600.0, 3600.0) } else { (-100.0, 100.0) };
+        v.push(p(n[0], "Source", Value::Enum(0), popup(CD_SOURCES)));
+        v.push(p(n[1], "Multiplier", num(0.0), slider(lo, hi, if rot { -360.0 } else { -10.0 }, if rot { 360.0 } else { 10.0 }, 2)));
+        v.push(p(n[2], "Offset", num(if scale { 1.0 } else { 0.0 }), slider(lo, hi, if rot { -360.0 } else { -10.0 }, if rot { 360.0 } else { 10.0 }, 2)));
+    }
+    v.extend([
+        p("cameraZ", "Z Position", num(2.0), slider(0.05, 10.0, 0.5, 5.0, 2)),
+        p("focalLength", "Focal Length", num(70.0), slider(1.0, 500.0, 10.0, 200.0, 1)),
+        p("lightIntensity", "Light Intensity", num(1.0), slider(0.0, 4.0, 0.0, 2.0, 2)),
+        p("ambientLight", "Ambient Light", num(0.25), slider(0.0, 2.0, 0.0, 1.0, 2)),
+        p("diffuse", "Diffuse Reflection", num(0.75), slider(0.0, 2.0, 0.0, 1.0, 2)),
+    ]);
+    v
+}
 
 pub fn specs() -> Vec<EffectSpec> {
-    Vec::new()
+    vec![
+        spec(
+            "ec.sim.ccballaction",
+            "CC Ball Action",
+            vec![
+                p("scatter", "Scatter", num(0.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
+                p("rotationAxis", "Rotation Axis", Value::Enum(0), popup(&["X Axis", "Y Axis", "Z Axis", "XY Axis", "XZ Axis", "YZ Axis", "XYZ Axis"])),
+                p("rotation", "Rotation", num(0.0), ParamUi::Angle),
+                p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
+                p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
+                p("gridSpacing", "Grid Spacing", num(4.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
+                p("ballSize", "Ball Size", num(40.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("instabilityState", "Instability State", num(0.0), ParamUi::Angle),
+            ],
+            ball_action,
+        ),
+        spec(
+            "ec.sim.ccpixelpolly",
+            "CC Pixel Polly",
+            vec![
+                p("force", "Force", num(100.0), slider(-1000.0, 1000.0, -300.0, 300.0, 1)),
+                p("gravity", "Gravity", num(1.0), slider(-20.0, 20.0, -5.0, 5.0, 2)),
+                p("spinning", "Spinning", num(0.0), ParamUi::Angle),
+                p("forceCenter", "Force Center", pt(0.5, 0.5), ParamUi::Point),
+                p("directionRandomness", "Direction Randomness", num(10.0), pct()),
+                p("speedRandomness", "Speed Randomness", num(10.0), pct()),
+                p("gridSpacing", "Grid Spacing", num(10.0), slider(1.0, 500.0, 2.0, 100.0, 0)),
+                p("object", "Object", Value::Enum(0), popup(&["Polygon", "Textured Polygon", "Square", "Textured Square"])),
+                p("enableDepthSort", "Enable Depth Sort", Value::Bool(true), ParamUi::Checkbox),
+                p("startTime", "Start Time (sec)", num(0.0), slider(-1000.0, 1000.0, 0.0, 10.0, 2)),
+            ],
+            pixel_polly,
+        ),
+        spec(
+            "ec.sim.ccscatterize",
+            "CC Scatterize",
+            vec![
+                p("scatter", "Scatter", num(0.0), slider(0.0, 1000.0, 0.0, 200.0, 1)),
+                p("rightTwist", "Right Twist", num(0.0), ParamUi::Angle),
+                p("leftTwist", "Left Twist", num(0.0), ParamUi::Angle),
+                p("transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Add"])),
+            ],
+            scatterize,
+        ),
+        spec("ec.sim.carddance", "Card Dance", card_dance_params(), card_dance),
+        spec(
+            "ec.sim.caustics",
+            "Caustics",
+            vec![
+                p("bottom", "Bottom", Value::Layer(None), ParamUi::Layer),
+                p("scaling", "Scaling", num(1.0), slider(0.01, 10.0, 0.1, 3.0, 3)),
+                p("repeatMode", "Repeat Mode", Value::Enum(2), popup(&["Once", "Tiled", "Reflected"])),
+                p("bottomSizeDiffers", "If Layer Size Differs", Value::Enum(1), popup(&["Center", "Stretch to Fit"])),
+                p("blur", "Blur", num(0.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+                p("waterSurface", "Water Surface", Value::Layer(None), ParamUi::Layer),
+                p("waveHeight", "Wave Height", num(0.2), slider(-1.0, 1.0, -1.0, 1.0, 3)),
+                p("smoothing", "Smoothing", num(5.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
+                p("waterDepth", "Water Depth", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("refractiveIndex", "Refractive Index", num(1.2), slider(1.0, 3.0, 1.0, 2.0, 3)),
+                p("surfaceColor", "Surface Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("surfaceOpacity", "Surface Opacity", num(0.3), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("causticsStrength", "Caustics Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("lightIntensity", "Light Intensity", num(1.0), slider(0.0, 4.0, 0.0, 2.0, 2)),
+                p("lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("lightPosition", "Light Position", pt(0.0, 0.0), ParamUi::Point),
+                p("lightHeight", "Light Height", num(1.0), slider(0.0, 10.0, 0.0, 4.0, 2)),
+                p("ambientLight", "Ambient Light", num(0.35), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("diffuse", "Diffuse Reflection", num(0.75), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("specular", "Specular Reflection", num(0.2), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("highlightSharpness", "Highlight Sharpness", num(15.0), slider(1.0, 100.0, 1.0, 100.0, 1)),
+            ],
+            caustics,
+        ),
+        spec(
+            "ec.sim.waveworld",
+            "Wave World",
+            {
+                let mut v = vec![
+                    p("view", "View", Value::Enum(0), popup(&["Wireframe Preview", "Height Map"])),
+                    p("brightness", "Brightness", num(0.5), slider(-1.0, 2.0, 0.0, 1.0, 3)),
+                    p("contrast", "Contrast", num(0.75), slider(0.0, 4.0, 0.0, 2.0, 3)),
+                    p("gamma", "Gamma Adjustment", num(1.0), slider(0.01, 10.0, 0.2, 5.0, 3)),
+                    p("transparency", "Transparency", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                    p("gridResolution", "Grid Resolution", num(60.0), slider(1.0, 400.0, 1.0, 200.0, 0)),
+                    p("gridResDownsamples", "Grid Res Downsamples", Value::Bool(false), ParamUi::Checkbox),
+                    p("waveSpeed", "Wave Speed", num(0.2), slider(0.0, 5.0, 0.0, 1.0, 3)),
+                    p("damping", "Damping", num(0.05), slider(0.0, 5.0, 0.0, 1.0, 3)),
+                    p("reflectEdges", "Reflect Edges", Value::Enum(0), popup(&["None", "Left", "Top", "Right", "Bottom", "All"])),
+                    p("preRoll", "Pre-roll (seconds)", num(0.0), slider(0.0, 30.0, 0.0, 10.0, 2)),
+                ];
+                v.extend(producer_params(1, 0.5, (0.5, 0.5)));
+                v.extend(producer_params(2, 0.0, (0.25, 0.25)));
+                v
+            },
+            wave_world,
+        ),
+        spec(
+            "ec.sim.shatter",
+            "Shatter",
+            vec![
+                p(
+                    "view",
+                    "View",
+                    Value::Enum(1),
+                    popup(&["Rendered", "Wireframe Front View", "Wireframe", "Wireframe Front View + Forces", "Wireframe + Forces"]),
+                ),
+                p("render", "Render", Value::Enum(0), popup(&["All", "Layer", "Pieces"])),
+                p("pattern", "Pattern", Value::Enum(0), popup(SHATTER_PATTERNS)),
+                p("repetitions", "Repetitions", num(10.0), slider(1.0, 500.0, 1.0, 100.0, 2)),
+                p("direction", "Direction", num(0.0), ParamUi::Angle),
+                p("origin", "Origin", pt(0.5, 0.5), ParamUi::Point),
+                p("extrusionDepth", "Extrusion Depth", num(0.05), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("force1Position", "Force 1 Position", pt(0.5, 0.5), ParamUi::Point),
+                p("force1Depth", "Force 1 Depth", num(0.1), slider(-1.0, 1.0, -1.0, 1.0, 3)),
+                p("force1Radius", "Force 1 Radius", num(0.4), slider(0.0, 4.0, 0.0, 2.0, 3)),
+                p("force1Strength", "Force 1 Strength", num(5.0), slider(-20.0, 20.0, -10.0, 10.0, 2)),
+                p("force2Position", "Force 2 Position", pt(0.25, 0.25), ParamUi::Point),
+                p("force2Depth", "Force 2 Depth", num(0.1), slider(-1.0, 1.0, -1.0, 1.0, 3)),
+                p("force2Radius", "Force 2 Radius", num(0.0), slider(0.0, 4.0, 0.0, 2.0, 3)),
+                p("force2Strength", "Force 2 Strength", num(5.0), slider(-20.0, 20.0, -10.0, 10.0, 2)),
+                p("rotationSpeed", "Rotation Speed", num(0.2), slider(0.0, 5.0, 0.0, 1.0, 3)),
+                p("tumbleAxis", "Tumble Axis", Value::Enum(0), popup(&["Free", "None", "X", "Y", "Z", "XY", "XZ", "YZ"])),
+                p("randomness", "Randomness", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("viscosity", "Viscosity", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("massVariance", "Mass Variance", num(30.0), pct()),
+                p("gravity", "Gravity", num(3.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("gravityDirection", "Gravity Direction", num(180.0), ParamUi::Angle),
+                p("gravityInclination", "Gravity Inclination", num(0.0), slider(-90.0, 90.0, -90.0, 90.0, 1)),
+                p("lightIntensity", "Light Intensity", num(1.0), slider(0.0, 4.0, 0.0, 2.0, 2)),
+                p("ambientLight", "Ambient Light", num(0.25), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            shatter,
+        ),
+        spec(
+            "ec.sim.foam",
+            "Foam",
+            vec![
+                p("view", "View", Value::Enum(0), popup(&["Draft", "Rendered"])),
+                p("producerPoint", "Producer Point", pt(0.5, 0.5), ParamUi::Point),
+                p("producerXSize", "Producer X Size", num(0.05), slider(0.0, 2.0, 0.0, 1.0, 3)),
+                p("producerYSize", "Producer Y Size", num(0.05), slider(0.0, 2.0, 0.0, 1.0, 3)),
+                p("producerOrientation", "Producer Orientation", num(0.0), ParamUi::Angle),
+                p("productionRate", "Production Rate", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 3)),
+                p("size", "Size", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("sizeVariance", "Size Variance", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("lifespan", "Lifespan", num(300.0), slider(1.0, 30_000.0, 1.0, 1000.0, 1)),
+                p("growthSpeed", "Bubble Growth Speed", num(0.1), slider(0.0001, 10.0, 0.0, 1.0, 3)),
+                p("strength", "Strength", num(10.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("initialSpeed", "Initial Speed", num(0.0), slider(-100.0, 100.0, -10.0, 10.0, 3)),
+                p("initialDirection", "Initial Direction", num(0.0), ParamUi::Angle),
+                p("windSpeed", "Wind Speed", num(0.5), slider(-100.0, 100.0, -10.0, 10.0, 3)),
+                p("windDirection", "Wind Direction", num(90.0), ParamUi::Angle),
+                p("turbulence", "Turbulence", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("repulsion", "Repulsion", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("viscosity", "Viscosity", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("stickiness", "Stickiness", num(0.75), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("zoom", "Zoom", num(1.0), slider(0.01, 50.0, 0.1, 5.0, 3)),
+                p("universeSize", "Universe Size", num(1.0), slider(0.01, 10.0, 0.5, 3.0, 3)),
+                p("blendMode", "Blend Mode", Value::Enum(0), popup(&["Transparent", "Solid Old on Top", "Solid New on Top"])),
+                p("bubbleTexture", "Bubble Texture", Value::Enum(0), popup(&["Default Bubble", "Spit", "Bubblegum", "Dishwater", "Milky"])),
+                p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            foam,
+        ),
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{EffectEnv, run_fx};
+
+    fn ramp(w: u32, hh: u32) -> Image {
+        let mut img = Image::new(w, hh);
+        for y in 0..hh {
+            for x in 0..w {
+                img.set(x, y, [x as f32 / w as f32, y as f32 / hh as f32, 0.4, 1.0]);
+            }
+        }
+        img
+    }
+
+    fn run(id: &str, vals: &[(&str, Value)], img: Image, t: f64) -> Image {
+        run_fx(id, vals, img, t, EffectEnv::default()).img
+    }
+
+    fn max_diff(a: &Image, b: &Image) -> f32 {
+        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
+    }
+
+    fn sum_diff(a: &Image, b: &Image) -> f32 {
+        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>()).sum()
+    }
+
+    #[test]
+    fn piece_at_rest_is_identity() {
+        let src = ramp(16, 16);
+        let cam = Cam { c: [8.0, 8.0], d: 64.0 };
+        let id = rot_axis([1.0, 0.0, 0.0], 0.0);
+        let pc = Piece::new(&[[0.0, 0.0], [16.0, 0.0], [16.0, 16.0], [0.0, 16.0]], [8.0, 8.0], &id, [8.0, 8.0, 0.0], cam).unwrap();
+        let mut out = Image::new(16, 16);
+        draw_pieces(&mut out, &[pc], &src, None);
+        assert!(max_diff(&out, &src) < 1e-4);
+    }
+
+    #[test]
+    fn ball_action_draws_balls() {
+        let v = [("ballSize", num(80.0))];
+        let a = run("ec.sim.ccballaction", &v, ramp(32, 32), 0.0);
+        assert_eq!(a, run("ec.sim.ccballaction", &v, ramp(32, 32), 0.0));
+        assert!(a.data.iter().any(|p| p[3] > 0.9) && a.data.iter().any(|p| p[3] == 0.0), "balls with gaps");
+        let none = run("ec.sim.ccballaction", &[("ballSize", num(0.0))], ramp(32, 32), 0.0);
+        assert!(none.data.iter().all(|p| p[3] == 0.0));
+        let sc = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("scatter", num(20.0))], ramp(32, 32), 0.0);
+        assert!(sum_diff(&a, &sc) > 1.0);
+    }
+
+    #[test]
+    fn pixel_polly_breaks_after_start() {
+        let v = [("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0))];
+        let before = run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.0);
+        assert_eq!(before, ramp(32, 32), "intact before the start time");
+        let a = run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.5);
+        assert_eq!(a, run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.5));
+        assert!(sum_diff(&a, &ramp(32, 32)) > 10.0);
+        let tex = run("ec.sim.ccpixelpolly", &[("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0)), ("object", Value::Enum(3))], ramp(32, 32), 0.5);
+        assert!(sum_diff(&a, &tex) > 0.1);
+    }
+
+    #[test]
+    fn scatterize_identity_and_scatter() {
+        assert_eq!(run("ec.sim.ccscatterize", &[], ramp(24, 24), 0.0), ramp(24, 24));
+        let a = run("ec.sim.ccscatterize", &[("scatter", num(5.0))], ramp(24, 24), 0.0);
+        assert_eq!(a, run("ec.sim.ccscatterize", &[("scatter", num(5.0))], ramp(24, 24), 0.0));
+        assert!(sum_diff(&a, &ramp(24, 24)) > 1.0);
+        let tw = run("ec.sim.ccscatterize", &[("leftTwist", num(80.0)), ("rightTwist", num(80.0))], ramp(24, 24), 0.0);
+        assert!(sum_diff(&tw, &ramp(24, 24)) > 1.0);
+    }
+
+    #[test]
+    fn card_dance_identity_and_rotation() {
+        let src = ramp(30, 20);
+        let a = run("ec.sim.carddance", &[], src.clone(), 0.0);
+        assert!(max_diff(&a, &src) < 0.02, "flat cards reproduce the layer: {}", max_diff(&a, &src));
+        let r = run("ec.sim.carddance", &[("yRotSource", Value::Enum(1)), ("yRotMultiplier", num(90.0))], src.clone(), 0.0);
+        assert_eq!(r, run("ec.sim.carddance", &[("yRotSource", Value::Enum(1)), ("yRotMultiplier", num(90.0))], src.clone(), 0.0));
+        assert!(sum_diff(&r, &src) > 5.0);
+        let z = run("ec.sim.carddance", &[("zPosOffset", num(-1.0))], src.clone(), 0.0);
+        assert!(sum_diff(&z, &src) > 5.0, "cards pulled towards the camera grow");
+    }
+
+    #[test]
+    fn shatter_at_rest_then_breaks() {
+        let v = [("view", Value::Enum(0)), ("force1Position", pt(16.0, 16.0)), ("origin", pt(16.0, 16.0))];
+        let src = ramp(32, 32);
+        let t0 = run("ec.sim.shatter", &v, src.clone(), 0.0);
+        assert!(max_diff(&t0, &src) < 0.03, "{}", max_diff(&t0, &src));
+        let t1 = run("ec.sim.shatter", &v, src.clone(), 0.5);
+        assert_eq!(t1, run("ec.sim.shatter", &v, src.clone(), 0.5));
+        assert!(sum_diff(&t1, &src) > 10.0);
+        for pat in 0..SHATTER_PATTERNS.len() as u32 {
+            let vv = [("view", Value::Enum(0)), ("pattern", Value::Enum(pat)), ("force1Position", pt(16.0, 16.0)), ("origin", pt(16.0, 16.0))];
+            let r = run("ec.sim.shatter", &vv, src.clone(), 0.0);
+            assert!(max_diff(&r, &src) < 0.05, "pattern {pat} tiles the layer: {}", max_diff(&r, &src));
+        }
+        let wire = run("ec.sim.shatter", &[("repetitions", num(3.0))], src.clone(), 0.0);
+        assert!(wire.data.iter().any(|p| p[3] > 0.5) && wire.data.iter().any(|p| p[3] == 0.0));
+        let layer_only = run("ec.sim.shatter", &[("view", Value::Enum(0)), ("render", Value::Enum(1)), ("force1Position", pt(16.0, 16.0))], src.clone(), 0.5);
+        assert!(layer_only.get(16, 16)[3] == 0.0, "broken centre removed");
+    }
+
+    #[test]
+    fn caustics_flat_water() {
+        let src = ramp(24, 24);
+        let a = run(
+            "ec.sim.caustics",
+            &[("surfaceOpacity", num(0.0)), ("ambientLight", num(0.0)), ("diffuse", num(1.0)), ("lightHeight", num(1000.0)), ("specular", num(0.0))],
+            src.clone(),
+            0.0,
+        );
+        assert!(max_diff(&a, &src) < 0.01, "flat water, light overhead = bottom: {}", max_diff(&a, &src));
+        let b = run("ec.sim.caustics", &[], src.clone(), 0.0);
+        assert_eq!(b, run("ec.sim.caustics", &[], src.clone(), 0.0));
+        assert!(sum_diff(&b, &src) > 0.1);
+    }
+
+    #[test]
+    fn wave_world_seek_and_waves() {
+        let v = vec![("view", Value::Enum(1)), ("producer1Position", pt(16.0, 16.0)), ("gridResolution", num(24.0))];
+        let _ = run("ec.sim.waveworld", &v, Image::new(32, 32), 0.5);
+        let a = run("ec.sim.waveworld", &v, Image::new(32, 32), 1.0);
+        let mut v2 = v.clone();
+        v2.push(("transparency", num(0.0)));
+        assert_eq!(a, run("ec.sim.waveworld", &v2, Image::new(32, 32), 1.0));
+        // Waves spread: some pixels differ from the flat-water grey.
+        assert!(a.data.iter().any(|p| (p[0] - 0.5).abs() > 0.05), "waves");
+        let flat = run("ec.sim.waveworld", &[("view", Value::Enum(1)), ("producer1Amplitude", num(0.0))], Image::new(32, 32), 1.0);
+        assert!(flat.data.iter().all(|p| (p[0] - 0.5).abs() < 1e-5));
+        let wire = run("ec.sim.waveworld", &[("producer1Position", pt(16.0, 16.0)), ("gridResolution", num(10.0))], Image::new(32, 32), 0.3);
+        assert!(wire.data.iter().any(|p| p[1] > 0.3));
+    }
+
+    #[test]
+    fn wave_world_steps_match_direct() {
+        // Fresh caches: resumed simulation equals simulation from scratch.
+        let v = vec![("view", Value::Enum(1)), ("producer1Position", pt(16.0, 16.0)), ("gridResolution", num(20.0)), ("damping", num(0.07))];
+        let a = run("ec.sim.waveworld", &v, Image::new(32, 32), 1.3);
+        let mut v2 = v.clone();
+        v2.push(("damping", num(0.07000001)));
+        // Different key: computed from scratch at 1.3 directly vs via 0.4 (both fresh keys).
+        let _ = run("ec.sim.waveworld", &v2, Image::new(32, 32), 0.4);
+        let b = run("ec.sim.waveworld", &v2, Image::new(32, 32), 1.3);
+        assert!(max_diff(&a, &b) < 1e-3, "{}", max_diff(&a, &b));
+    }
+
+    #[test]
+    fn foam_bubbles_drift_and_seek() {
+        let v = vec![("producerPoint", pt(16.0, 16.0)), ("view", Value::Enum(1)), ("productionRate", num(2.0))];
+        let none = run("ec.sim.foam", &v, Image::new(32, 32), 0.0);
+        assert!(none.data.iter().all(|p| p[3] == 0.0));
+        let _ = run("ec.sim.foam", &v, Image::new(32, 32), 0.6);
+        let a = run("ec.sim.foam", &v, Image::new(32, 32), 1.2);
+        let mut v2 = v.clone();
+        v2.push(("randomSeed", num(1.0)));
+        assert_eq!(a, run("ec.sim.foam", &v2, Image::new(32, 32), 1.2));
+        assert!(a.data.iter().any(|p| p[3] > 0.05), "bubbles");
+        let draft = run("ec.sim.foam", &[("producerPoint", pt(16.0, 16.0)), ("productionRate", num(2.0))], Image::new(32, 32), 1.0);
+        assert!(draft.data.iter().any(|p| p[3] > 0.05));
+    }
 }