From 695b87ab698525e11b829555cbd01a841be5a6f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 11 Aug 2026 15:02:37 -0700
Subject: [PATCH 01/14] .

---
 Cargo.toml                     |  44 +++++++
 examples/combine_mix_test.rs   | 121 +++++++++++++++++++
 examples/field_falloff_test.rs | 100 +++++++++++++++
 examples/flock_grid_test.rs    | 215 +++++++++++++++++++++++++++++++++
 examples/glue_test.rs          | 117 ++++++++++++++++++
 examples/grid_test.rs          | 128 ++++++++++++++++++++
 examples/group_compact_test.rs |  84 +++++++++++++
 examples/lookup_test.rs        | 110 +++++++++++++++++
 examples/map_test.rs           |  85 +++++++++++++
 examples/reduce_test.rs        |  79 ++++++++++++
 examples/scan_test.rs          |  76 ++++++++++++
 examples/sort_test.rs          |  92 ++++++++++++++
 12 files changed, 1251 insertions(+)
 create mode 100644 examples/combine_mix_test.rs
 create mode 100644 examples/field_falloff_test.rs
 create mode 100644 examples/flock_grid_test.rs
 create mode 100644 examples/glue_test.rs
 create mode 100644 examples/grid_test.rs
 create mode 100644 examples/group_compact_test.rs
 create mode 100644 examples/lookup_test.rs
 create mode 100644 examples/map_test.rs
 create mode 100644 examples/reduce_test.rs
 create mode 100644 examples/scan_test.rs
 create mode 100644 examples/sort_test.rs

diff --git a/Cargo.toml b/Cargo.toml
index 2bae50b6..633ca8d9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -212,10 +212,54 @@ path = "examples/camera_controllers.rs"
 name = "compute_readback"
 path = "examples/compute_readback.rs"
 
+[[example]]
+name = "scan_test"
+path = "examples/scan_test.rs"
+
+[[example]]
+name = "grid_test"
+path = "examples/grid_test.rs"
+
+[[example]]
+name = "flock_grid_test"
+path = "examples/flock_grid_test.rs"
+
 [[example]]
 name = "alias_spike"
 path = "examples/alias_spike.rs"
 
+[[example]]
+name = "map_test"
+path = "examples/map_test.rs"
+
+[[example]]
+name = "combine_mix_test"
+path = "examples/combine_mix_test.rs"
+
+[[example]]
+name = "lookup_test"
+path = "examples/lookup_test.rs"
+
+[[example]]
+name = "glue_test"
+path = "examples/glue_test.rs"
+
+[[example]]
+name = "sort_test"
+path = "examples/sort_test.rs"
+
+[[example]]
+name = "field_falloff_test"
+path = "examples/field_falloff_test.rs"
+
+[[example]]
+name = "group_compact_test"
+path = "examples/group_compact_test.rs"
+
+[[example]]
+name = "reduce_test"
+path = "examples/reduce_test.rs"
+
 [[example]]
 name = "particles_basic"
 path = "examples/particles_basic.rs"
diff --git a/examples/combine_mix_test.rs b/examples/combine_mix_test.rs
new file mode 100644
index 00000000..f16d20d5
--- /dev/null
+++ b/examples/combine_mix_test.rs
@@ -0,0 +1,121 @@
+//! Validation harness for the `combine` and `mix` algebra verbs (task #5),
+//! including the alias guard (a `dst` that aliases a read-only operand must be
+//! rejected in Rust, NOT reach wgpu — where it would be a fatal validation
+//! error, see `examples/alias_spike.rs`).
+//!
+//! Run: `cargo run --example combine_mix_test`. Exits non-zero on mismatch.
+
+use processing::prelude::*;
+
+fn f32s(bytes: &[u8]) -> Vec<f32> {
+    bytes
+        .chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn to_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+fn approx(a: &[f32], b: &[f32]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let mut ok = true;
+
+    // --- combine in-place: a += b (Float3, 4 particles) ---
+    let av: Vec<f32> = (0..12).map(|i| i as f32).collect();
+    let bv: Vec<f32> = (0..12).map(|i| (i * 10) as f32).collect();
+    let a = buffer_create_with_data(to_bytes(&av))?;
+    let b = buffer_create_with_data(to_bytes(&bv))?;
+    combine(a, a, b, 3, COMBINE_ADD, 1.0, 0.0)?;
+    let got = f32s(&buffer_read(a)?);
+    let want: Vec<f32> = av.iter().zip(&bv).map(|(x, y)| x + y).collect();
+    if approx(&got, &want) {
+        println!("  PASS combine in-place a+=b");
+    } else {
+        ok = false;
+        println!("  FAIL combine in-place: got {got:?}, want {want:?}");
+    }
+
+    // --- combine out-of-place: dst = a * b, inputs preserved ---
+    let dst = buffer_create_with_data(to_bytes(&vec![0.0; 12]))?;
+    combine(dst, a, b, 3, COMBINE_MUL, 1.0, 0.0)?;
+    let got_dst = f32s(&buffer_read(dst)?);
+    let cur_a = f32s(&buffer_read(a)?);
+    let want_dst: Vec<f32> = want.iter().zip(&bv).map(|(x, y)| x * y).collect();
+    if approx(&got_dst, &want_dst) && approx(&cur_a, &want) {
+        println!("  PASS combine out-of-place dst=a*b (inputs preserved)");
+    } else {
+        ok = false;
+        println!("  FAIL combine out-of-place: dst={got_dst:?} want {want_dst:?}");
+    }
+
+    // --- alias guard: combine(dst=b, a, b) must be rejected in Rust ---
+    match combine(b, a, b, 3, COMBINE_ADD, 1.0, 0.0) {
+        Err(_) => println!("  PASS combine alias guard (dst==b rejected before dispatch)"),
+        Ok(()) => {
+            ok = false;
+            println!("  FAIL combine alias guard: expected Err, got Ok");
+        }
+    }
+
+    buffer_destroy(a)?;
+    buffer_destroy(b)?;
+    buffer_destroy(dst)?;
+
+    // --- mix out-of-place: dst = lerp(a, b, t), t per-particle broadcast ---
+    // 3 particles x 4 components (color-like); t = [0, 0.5, 1].
+    let comps = 4u32;
+    let a2: Vec<f32> = vec![1.0; 12]; // all-ones
+    let b2: Vec<f32> = vec![3.0; 12]; // all-threes
+    let tv = vec![0.0f32, 0.5, 1.0];
+    let am = buffer_create_with_data(to_bytes(&a2))?;
+    let bm = buffer_create_with_data(to_bytes(&b2))?;
+    let tm = buffer_create_with_data(to_bytes(&tv))?;
+    let dm = buffer_create_with_data(to_bytes(&vec![0.0; 12]))?;
+    mix(dm, am, bm, tm, comps, 1.0, 0.0, true)?;
+    let got_mix = f32s(&buffer_read(dm)?);
+    // particle 0 -> a(1.0), particle 1 -> midpoint(2.0), particle 2 -> b(3.0)
+    let mut want_mix = vec![1.0f32; 4];
+    want_mix.extend([2.0f32; 4]);
+    want_mix.extend([3.0f32; 4]);
+    if approx(&got_mix, &want_mix) {
+        println!("  PASS mix out-of-place (per-particle t broadcast across components)");
+    } else {
+        ok = false;
+        println!("  FAIL mix out-of-place: got {got_mix:?}, want {want_mix:?}");
+    }
+
+    // --- mix in-place: a = lerp(a, b, t) ---
+    mix(am, am, bm, tm, comps, 1.0, 0.0, true)?;
+    let got_mix_ip = f32s(&buffer_read(am)?);
+    if approx(&got_mix_ip, &want_mix) {
+        println!("  PASS mix in-place");
+    } else {
+        ok = false;
+        println!("  FAIL mix in-place: got {got_mix_ip:?}, want {want_mix:?}");
+    }
+
+    buffer_destroy(am)?;
+    buffer_destroy(bm)?;
+    buffer_destroy(tm)?;
+    buffer_destroy(dm)?;
+
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("combine_mix_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("combine_mix_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/field_falloff_test.rs b/examples/field_falloff_test.rs
new file mode 100644
index 00000000..4f73beb4
--- /dev/null
+++ b/examples/field_falloff_test.rs
@@ -0,0 +1,100 @@
+//! Validates the shared `falloff` WESL helper (task #10) end-to-end: dispatches
+//! the `field` kernel (which now `import`s `processing::particles::falloff`) over
+//! particles at known distances and checks the weights against CPU falloff.
+//!
+//! Run: `cargo run --example field_falloff_test`. Exits non-zero on mismatch.
+
+use bevy::prelude::Entity;
+use processing::prelude::*;
+
+const RADIUS: f32 = 2.0;
+
+fn f32s(b: &[u8]) -> Vec<f32> {
+    b.chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn to_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+fn approx(a: &[f32], b: &[f32]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5)
+}
+
+// Particles along +x at distances 0, 0.5, 1.0, 1.5 from the origin.
+const DISTS: [f32; 4] = [0.0, 0.5, 1.0, 1.5];
+
+fn cpu_falloff(d: f32, mode: u32) -> f32 {
+    let n = 1.0 - d / RADIUS;
+    match mode {
+        1 => n,
+        2 => n * n * (3.0 - 2.0 * n),
+        3 => n * n,
+        4 => n * n * n,
+        5 => RADIUS / (d + RADIUS),
+        _ => 1.0,
+    }
+}
+
+fn run_mode(field: Entity, pos: Entity, weight: Entity, mode: u32) -> error::Result<bool> {
+    compute_set(field, "falloff_mode", shader_value::ShaderValue::UInt(mode))?;
+    compute_dispatch(field, 1, 1, 1)?;
+    let got = f32s(&buffer_read(weight)?);
+    let want: Vec<f32> = DISTS.iter().map(|&d| cpu_falloff(d, mode)).collect();
+    if approx(&got, &want) {
+        println!("  PASS falloff mode {mode}: {got:?}");
+        Ok(true)
+    } else {
+        println!("  FAIL falloff mode {mode}: got {got:?}, want {want:?}");
+        Ok(false)
+    }
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let positions: Vec<f32> = DISTS.iter().flat_map(|&d| [d, 0.0, 0.0]).collect();
+    let pos = buffer_create_with_data(to_bytes(&positions))?;
+    let weight = buffer_create_with_data(to_bytes(&vec![0.0; DISTS.len()]))?;
+
+    let field = particles_kernel_field()?;
+    compute_set(field, "position", shader_value::ShaderValue::Buffer(pos))?;
+    compute_set(field, "weight", shader_value::ShaderValue::Buffer(weight))?;
+    compute_set(field, "center", shader_value::ShaderValue::Float3([0.0, 0.0, 0.0]))?;
+    compute_set(field, "radius", shader_value::ShaderValue::Float(RADIUS))?;
+
+    let mut ok = true;
+    for mode in [0u32, 1, 2, 3, 4, 5] {
+        ok &= run_mode(field, pos, weight, mode)?;
+    }
+
+    // The other falloff users share the same import — instantiate them so their
+    // WESL actually compiles (compute_create errors if the import is broken).
+    for (name, r) in [
+        ("attract", particles_kernel_attract()),
+        ("vortex", particles_kernel_vortex()),
+        ("impulse", particles_kernel_impulse()),
+    ] {
+        match r {
+            Ok(_) => println!("  PASS {name} compiles (falloff import)"),
+            Err(e) => {
+                ok = false;
+                println!("  FAIL {name} compile: {e}");
+            }
+        }
+    }
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("field_falloff_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("field_falloff_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/flock_grid_test.rs b/examples/flock_grid_test.rs
new file mode 100644
index 00000000..365c7a56
--- /dev/null
+++ b/examples/flock_grid_test.rs
@@ -0,0 +1,215 @@
+//! Validation harness for the grid-accelerated flock kernel.
+//!
+//! The boids steering math in `flock.wgsl` is a verbatim port of the previous
+//! brute-force kernel; the only new logic is sourcing neighbours from the
+//! spatial hash. So this test isolates and proves *that*: an inline `count_grid`
+//! kernel that walks the same 3x3x3 cell block as `flock` must find exactly the
+//! same neighbour set (within RADIUS) as an all-pairs `count_brute` — compared
+//! as exact integer counts (no float-order ambiguity). Then it runs the real
+//! flock kernel once as a smoke test (finite output, velocities actually change).
+//!
+//! Run: `cargo run --example flock_grid_test`. Exits non-zero on any mismatch.
+
+use processing::prelude::*;
+
+const N: u32 = 300;
+const CELL: f32 = 2.5; // grid cell size == neighbour radius (the flock invariant)
+const DIMS: [u32; 3] = [4, 4, 4]; // domain [0, 10)^3
+const MIN: [f32; 3] = [0.0, 0.0, 0.0];
+
+// Neighbour counter over the spatial hash; mirrors flock.wgsl's iteration.
+const COUNT_GRID_SRC: &str = r#"
+struct GridParams {
+    grid_min: vec3<f32>, cell_size: f32,
+    dims_x: u32, dims_y: u32, dims_z: u32, _pad: u32,
+}
+const RADIUS2: f32 = 6.25; // 2.5^2
+@group(0) @binding(0) var<storage, read>       position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> counts:   array<u32>;
+@group(0) @binding(2) var<storage, read>       offsets:  array<u32>;
+@group(0) @binding(3) var<storage, read>       sorted:   array<u32>;
+@group(0) @binding(4) var<uniform>             gp:       GridParams;
+
+fn load_pos(i: u32) -> vec3<f32> {
+    return vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let n = arrayLength(&position) / 3u;
+    if i >= n { return; }
+    let pos = load_pos(i);
+    let rel = (pos - gp.grid_min) / gp.cell_size;
+    let bx = clamp(i32(floor(rel.x)), 0, i32(gp.dims_x) - 1);
+    let by = clamp(i32(floor(rel.y)), 0, i32(gp.dims_y) - 1);
+    let bz = clamp(i32(floor(rel.z)), 0, i32(gp.dims_z) - 1);
+    var c = 0u;
+    for (var dz = -1; dz <= 1; dz++) {
+        let cz = bz + dz;
+        if cz < 0 || cz >= i32(gp.dims_z) { continue; }
+        for (var dy = -1; dy <= 1; dy++) {
+            let cy = by + dy;
+            if cy < 0 || cy >= i32(gp.dims_y) { continue; }
+            for (var dx = -1; dx <= 1; dx++) {
+                let cx = bx + dx;
+                if cx < 0 || cx >= i32(gp.dims_x) { continue; }
+                let cell = u32(cx) + u32(cy) * gp.dims_x + u32(cz) * gp.dims_x * gp.dims_y;
+                let start = offsets[cell];
+                let end = offsets[cell + 1u];
+                for (var s = start; s < end; s++) {
+                    let j = sorted[s];
+                    if j == i { continue; }
+                    let diff = pos - load_pos(j);
+                    if dot(diff, diff) < RADIUS2 { c += 1u; }
+                }
+            }
+        }
+    }
+    counts[i] = c;
+}
+"#;
+
+const COUNT_BRUTE_SRC: &str = r#"
+const RADIUS2: f32 = 6.25;
+@group(0) @binding(0) var<storage, read>       position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> counts:   array<u32>;
+
+fn load_pos(i: u32) -> vec3<f32> {
+    return vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let n = arrayLength(&position) / 3u;
+    if i >= n { return; }
+    let pos = load_pos(i);
+    var c = 0u;
+    for (var j = 0u; j < n; j++) {
+        if j == i { continue; }
+        let diff = pos - load_pos(j);
+        if dot(diff, diff) < RADIUS2 { c += 1u; }
+    }
+    counts[i] = c;
+}
+"#;
+
+fn bytes_to_u32s(b: &[u8]) -> Vec<u32> {
+    b.chunks_exact(4)
+        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn bytes_to_f32s(b: &[u8]) -> Vec<f32> {
+    b.chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+
+// Deterministic pseudo-random in [0,1) from a u32 seed.
+fn rnd(seed: u32) -> f32 {
+    let mut x = seed.wrapping_mul(747796405).wrapping_add(2891336453);
+    x = ((x >> ((x >> 28).wrapping_add(4))) ^ x).wrapping_mul(277803737);
+    x = (x >> 22) ^ x;
+    (x as f32) / (u32::MAX as f32)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    // Boids in [0.5, 9.5]^3 with small velocities; deterministic.
+    let mut pos = Vec::with_capacity((N * 3) as usize);
+    let mut vel = Vec::with_capacity((N * 3) as usize);
+    for i in 0..N {
+        for a in 0..3u32 {
+            pos.push(0.5 + 9.0 * rnd(i * 3 + a));
+            vel.push(0.1 * (rnd(1000 + i * 3 + a) - 0.5));
+        }
+    }
+    let pos_f32 = pos.clone();
+    let vel_f32 = vel.clone();
+
+    let f32s_to_bytes = |v: &[f32]| -> Vec<u8> { v.iter().flat_map(|f| f.to_le_bytes()).collect() };
+    let position = buffer_create_with_data(f32s_to_bytes(&pos))?;
+    let velocity = buffer_create_with_data(f32s_to_bytes(&vel))?;
+    let counts_grid = buffer_create((N as u64) * 4)?;
+    let counts_brute = buffer_create((N as u64) * 4)?;
+
+    let params = GridParams {
+        min: MIN,
+        cell_size: CELL,
+        dims: DIMS,
+    };
+    let grid = grid_create(params, N)?;
+    grid_build(&grid, position)?;
+
+    let mut ok = true;
+
+    // --- Neighbour-count equivalence (exact) ---
+    let cg = compute_create(shader_create(COUNT_GRID_SRC)?)?;
+    compute_set(cg, "position", shader_value::ShaderValue::Buffer(position))?;
+    compute_set(cg, "counts", shader_value::ShaderValue::Buffer(counts_grid))?;
+    grid_bind(&grid, cg)?;
+    compute_dispatch(cg, N.div_ceil(64), 1, 1)?;
+
+    let cb = compute_create(shader_create(COUNT_BRUTE_SRC)?)?;
+    compute_set(cb, "position", shader_value::ShaderValue::Buffer(position))?;
+    compute_set(cb, "counts", shader_value::ShaderValue::Buffer(counts_brute))?;
+    compute_dispatch(cb, N.div_ceil(64), 1, 1)?;
+
+    let g = bytes_to_u32s(&buffer_read(counts_grid)?);
+    let b = bytes_to_u32s(&buffer_read(counts_brute)?);
+    if g == b {
+        let total: u32 = b.iter().sum();
+        println!(
+            "  PASS neighbour counts match ({} particles, {} total neighbour pairs)",
+            N, total
+        );
+    } else {
+        ok = false;
+        let i = (0..N as usize).find(|&i| g[i] != b[i]).unwrap();
+        println!("  FAIL neighbour count at particle {i}: grid {}, brute {}", g[i], b[i]);
+    }
+
+    // --- Real flock kernel smoke test ---
+    let flock = particles_kernel_flock()?;
+    compute_set(flock, "position", shader_value::ShaderValue::Buffer(position))?;
+    compute_set(flock, "velocity", shader_value::ShaderValue::Buffer(velocity))?;
+    compute_set(flock, "neighbor_distance", shader_value::ShaderValue::Float(CELL))?;
+    grid_bind(&grid, flock)?;
+    compute_dispatch(flock, N.div_ceil(64), 1, 1)?;
+
+    let out_vel = bytes_to_f32s(&buffer_read(velocity)?);
+    let all_finite = out_vel.iter().all(|v| v.is_finite());
+    let changed = out_vel
+        .iter()
+        .zip(vel_f32.iter())
+        .filter(|(a, b)| (**a - **b).abs() > 1e-9)
+        .count();
+    if all_finite && changed > 0 {
+        println!("  PASS flock smoke test ({changed}/{} velocity components changed)", N * 3);
+    } else {
+        ok = false;
+        println!("  FAIL flock smoke test (all_finite={all_finite}, changed={changed})");
+    }
+
+    let _ = pos_f32;
+    buffer_destroy(position)?;
+    buffer_destroy(velocity)?;
+    buffer_destroy(counts_grid)?;
+    buffer_destroy(counts_brute)?;
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("flock_grid_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("flock_grid_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/glue_test.rs b/examples/glue_test.rs
new file mode 100644
index 00000000..aa4ea940
--- /dev/null
+++ b/examples/glue_test.rs
@@ -0,0 +1,117 @@
+//! Validation harness for the glue algebra verbs (task #7): `reduce_components`,
+//! `extract`, `pack`, `generate`.
+//!
+//! Run: `cargo run --example glue_test`. Exits non-zero on mismatch.
+
+use processing::prelude::*;
+
+fn f32s(bytes: &[u8]) -> Vec<f32> {
+    bytes
+        .chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn to_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+fn approx(a: &[f32], b: &[f32]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-4)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let mut ok = true;
+
+    // Float3 velocities for reduce/extract.
+    let vel = vec![3.0f32, 4.0, 0.0, 1.0, 2.0, 2.0, 0.0, 0.0, 7.0, 5.0, 0.0, 0.0];
+
+    // --- reduce_components LENGTH: speed = |velocity| ---
+    let v = buffer_create_with_data(to_bytes(&vel))?;
+    let speed = buffer_create_with_data(to_bytes(&vec![0.0; 4]))?;
+    reduce_components(speed, v, 3, REDUCE_LENGTH)?;
+    let got = f32s(&buffer_read(speed)?);
+    if approx(&got, &[5.0, 3.0, 7.0, 5.0]) {
+        println!("  PASS reduce_components LENGTH (speed=|velocity|): {got:?}");
+    } else {
+        ok = false;
+        println!("  FAIL reduce LENGTH: got {got:?}, want [5,3,7,5]");
+    }
+
+    // --- extract component 1 (.y) ---
+    let y = buffer_create_with_data(to_bytes(&vec![0.0; 4]))?;
+    extract(y, v, 3, 1)?;
+    let got_y = f32s(&buffer_read(y)?);
+    if approx(&got_y, &[4.0, 2.0, 0.0, 0.0]) {
+        println!("  PASS extract .y: {got_y:?}");
+    } else {
+        ok = false;
+        println!("  FAIL extract: got {got_y:?}, want [4,2,0,0]");
+    }
+    buffer_destroy(v)?;
+    buffer_destroy(speed)?;
+    buffer_destroy(y)?;
+
+    // --- pack 3 scalar buffers -> Float3 ---
+    let xs = buffer_create_with_data(to_bytes(&[1.0, 2.0, 3.0]))?;
+    let ys = buffer_create_with_data(to_bytes(&[10.0, 20.0, 30.0]))?;
+    let zs = buffer_create_with_data(to_bytes(&[100.0, 200.0, 300.0]))?;
+    let packed = buffer_create_with_data(to_bytes(&vec![0.0; 9]))?;
+    pack(packed, &[xs, ys, zs])?;
+    let got_p = f32s(&buffer_read(packed)?);
+    if approx(
+        &got_p,
+        &[1.0, 10.0, 100.0, 2.0, 20.0, 200.0, 3.0, 30.0, 300.0],
+    ) {
+        println!("  PASS pack x/y/z -> Float3: {got_p:?}");
+    } else {
+        ok = false;
+        println!("  FAIL pack: got {got_p:?}");
+    }
+    buffer_destroy(xs)?;
+    buffer_destroy(ys)?;
+    buffer_destroy(zs)?;
+    buffer_destroy(packed)?;
+
+    // --- generate: uniform in [0,1), deterministic in seed ---
+    let g1 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
+    let g2 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
+    let g3 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
+    generate(g1, 2, GEN_UNIFORM, 42, 1.0, 0.0)?;
+    generate(g2, 2, GEN_UNIFORM, 42, 1.0, 0.0)?; // same seed
+    generate(g3, 2, GEN_UNIFORM, 43, 1.0, 0.0)?; // different seed
+    let a = f32s(&buffer_read(g1)?);
+    let b = f32s(&buffer_read(g2)?);
+    let c = f32s(&buffer_read(g3)?);
+    let in_range = a.iter().all(|x| (0.0..1.0).contains(x));
+    let deterministic = approx(&a, &b);
+    let seed_varies = !approx(&a, &c);
+    // basic spread sanity: not all identical
+    let varied = a.windows(2).any(|w| (w[0] - w[1]).abs() > 1e-6);
+    if in_range && deterministic && seed_varies && varied {
+        println!("  PASS generate uniform (in-range, deterministic, seed-sensitive)");
+    } else {
+        ok = false;
+        println!(
+            "  FAIL generate: in_range={in_range}, deterministic={deterministic}, seed_varies={seed_varies}, varied={varied}"
+        );
+    }
+    buffer_destroy(g1)?;
+    buffer_destroy(g2)?;
+    buffer_destroy(g3)?;
+
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("glue_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("glue_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/grid_test.rs b/examples/grid_test.rs
new file mode 100644
index 00000000..bbd355ba
--- /dev/null
+++ b/examples/grid_test.rs
@@ -0,0 +1,128 @@
+//! Validation harness for the bounded uniform spatial hash grid
+//! (`grid_create` / `grid_build`). Places particles at known cell centres,
+//! builds the grid on the GPU, reads back the CSR `offsets` and `sorted`
+//! buffers, and checks them against a CPU reference: exact offsets, and each
+//! cell's bucket membership as a set (intra-cell order is atomic-nondeterministic).
+//!
+//! Run: `cargo run --example grid_test`. Exits non-zero on any mismatch.
+
+use std::collections::BTreeSet;
+
+use processing::prelude::*;
+
+const DIMS: [u32; 3] = [4, 4, 4];
+const CELL_SIZE: f32 = 1.0;
+const MIN: [f32; 3] = [0.0, 0.0, 0.0];
+
+fn bytes_to_u32s(b: &[u8]) -> Vec<u32> {
+    b.chunks_exact(4)
+        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+
+fn cpu_cell(p: [f32; 3]) -> u32 {
+    let rel = [
+        (p[0] - MIN[0]) / CELL_SIZE,
+        (p[1] - MIN[1]) / CELL_SIZE,
+        (p[2] - MIN[2]) / CELL_SIZE,
+    ];
+    let clampi = |v: f32, m: u32| (v.floor() as i32).clamp(0, m as i32 - 1) as u32;
+    let ix = clampi(rel[0], DIMS[0]);
+    let iy = clampi(rel[1], DIMS[1]);
+    let iz = clampi(rel[2], DIMS[2]);
+    ix + iy * DIMS[0] + iz * DIMS[0] * DIMS[1]
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let capacity: u32 = 40;
+    let num_cells = (DIMS[0] * DIMS[1] * DIMS[2]) as usize;
+
+    // Deterministic spread across cells with varying occupancy (incl. empties).
+    let cells: Vec<[u32; 3]> = (0..capacity)
+        .map(|i| [(i * 7) % 4, (i * 13) % 4, (i * 5) % 4])
+        .collect();
+    let positions: Vec<[f32; 3]> = cells
+        .iter()
+        .map(|c| [c[0] as f32 + 0.5, c[1] as f32 + 0.5, c[2] as f32 + 0.5])
+        .collect();
+
+    let pos_bytes: Vec<u8> = positions
+        .iter()
+        .flat_map(|p| p.iter().flat_map(|f| f.to_le_bytes()))
+        .collect();
+    let position = buffer_create_with_data(pos_bytes)?;
+
+    let params = GridParams {
+        min: MIN,
+        cell_size: CELL_SIZE,
+        dims: DIMS,
+    };
+    let grid = grid_create(params, capacity)?;
+    grid_build(&grid, position)?;
+
+    let offsets = bytes_to_u32s(&buffer_read(grid.offsets)?);
+    let sorted = bytes_to_u32s(&buffer_read(grid.sorted)?);
+
+    // CPU reference.
+    let mut counts = vec![0u32; num_cells];
+    for i in 0..capacity as usize {
+        counts[cpu_cell(positions[i]) as usize] += 1;
+    }
+    let mut expected_offsets = vec![0u32; num_cells + 1];
+    for c in 0..num_cells {
+        expected_offsets[c + 1] = expected_offsets[c] + counts[c];
+    }
+
+    let mut ok = true;
+
+    if offsets != expected_offsets {
+        ok = false;
+        let i = (0..offsets.len())
+            .find(|&i| offsets.get(i) != expected_offsets.get(i))
+            .unwrap_or(0);
+        println!(
+            "  FAIL offsets: first mismatch at cell {i}: got {:?}, want {:?}",
+            offsets.get(i),
+            expected_offsets.get(i)
+        );
+    } else {
+        println!("  PASS offsets (total={})", expected_offsets[num_cells]);
+    }
+
+    // Bucket membership per cell, compared as sets.
+    let mut buckets_ok = true;
+    for c in 0..num_cells {
+        let (s, e) = (expected_offsets[c] as usize, expected_offsets[c + 1] as usize);
+        let got: BTreeSet<u32> = sorted[s..e].iter().copied().collect();
+        let want: BTreeSet<u32> = (0..capacity)
+            .filter(|&i| cpu_cell(positions[i as usize]) as usize == c)
+            .collect();
+        if got != want {
+            buckets_ok = false;
+            println!("  FAIL cell {c}: got {got:?}, want {want:?}");
+        }
+    }
+    if buckets_ok {
+        println!("  PASS buckets ({num_cells} cells)");
+    } else {
+        ok = false;
+    }
+
+    buffer_destroy(position)?;
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("grid_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("grid_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/group_compact_test.rs b/examples/group_compact_test.rs
new file mode 100644
index 00000000..e4c7ce8c
--- /dev/null
+++ b/examples/group_compact_test.rs
@@ -0,0 +1,84 @@
+//! Validation harness for task #17: stream compaction (`compact`) and the group
+//! predicate (`map` comparison ops). Checks the compaction primitive directly,
+//! then the full chain: a `> threshold` predicate produces keep-flags which
+//! compact to the dense list of matching indices.
+//!
+//! Run: `cargo run --example group_compact_test`. Exits non-zero on mismatch.
+
+use bevy::prelude::Entity;
+use processing::prelude::*;
+
+fn u32s(b: &[u8]) -> Vec<u32> {
+    b.chunks_exact(4)
+        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn f32_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+
+fn check(label: &str, got_count: u32, got: &[u32], want: &[u32]) -> bool {
+    if got_count as usize == want.len() && &got[..want.len()] == want {
+        println!("  PASS {label}: count={got_count}, indices={:?}", &got[..want.len()]);
+        true
+    } else {
+        println!("  FAIL {label}: count={got_count} indices={got:?}, want {want:?}");
+        false
+    }
+}
+
+fn compact_flags(flags: &[f32]) -> error::Result<(u32, Vec<u32>)> {
+    let f = buffer_create_with_data(f32_bytes(flags))?;
+    let idx = buffer_create((flags.len().max(1) as u64) * 4)?;
+    let count = compact(f, idx)?;
+    let out = u32s(&buffer_read(idx)?);
+    buffer_destroy(f)?;
+    buffer_destroy(idx)?;
+    Ok((count, out))
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let mut ok = true;
+
+    // --- compaction primitive, directly ---
+    let (c, out) = compact_flags(&[0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0])?;
+    ok &= check("compact mixed", c, &out, &[1, 2, 4, 7]);
+
+    let (c, out) = compact_flags(&[0.0, 0.0, 0.0])?;
+    ok &= check("compact none", c, &out, &[]);
+
+    let (c, out) = compact_flags(&[1.0, 1.0, 1.0, 1.0])?;
+    ok &= check("compact all", c, &out, &[0, 1, 2, 3]);
+
+    // --- group predicate (map > threshold) -> compact ---
+    let src_vals = [0.1f32, 0.5, 0.9, 0.3, 0.7];
+    let src = buffer_create_with_data(f32_bytes(&src_vals))?;
+    let flags = buffer_create((src_vals.len() as u64) * 4)?;
+    let idx = buffer_create((src_vals.len() as u64) * 4)?;
+    // flags[i] = src[i] > 0.4 ? 1 : 0   → [0,1,1,0,1]
+    map(flags, src, 1, MAP_GREATER, 0.4, 0.0)?;
+    let count = compact(flags, idx)?;
+    let out = u32s(&buffer_read(idx)?);
+    ok &= check("group(>0.4)+compact", count, &out, &[1, 2, 4]);
+    for b in [src, flags, idx] {
+        let _: Entity = b;
+        buffer_destroy(b)?;
+    }
+
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("group_compact_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("group_compact_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/lookup_test.rs b/examples/lookup_test.rs
new file mode 100644
index 00000000..03843104
--- /dev/null
+++ b/examples/lookup_test.rs
@@ -0,0 +1,110 @@
+//! Validation harness for the `lookup` algebra verb (task #6): sample a texture
+//! by a per-particle coordinate into a flat RGBA `dst`. Exercises both the 1-D
+//! (in_components=1) and 2-D (in_components=2, interleaved uv) paths, plus the
+//! sampler-binding fix (a `Texture` value bound to a `sampler` param).
+//!
+//! Uses pure 0/1 primary colours + nearest sampling so texel reads are exact.
+//! Run: `cargo run --example lookup_test`. Exits non-zero on mismatch.
+
+use bevy::prelude::Entity;
+use bevy::render::render_resource::Extent3d;
+use processing::prelude::*;
+
+// R,G,B,W as RGBA8 bytes.
+const RED: [u8; 4] = [255, 0, 0, 255];
+const GREEN: [u8; 4] = [0, 255, 0, 255];
+const BLUE: [u8; 4] = [0, 0, 255, 255];
+const WHITE: [u8; 4] = [255, 255, 255, 255];
+
+fn f32s(bytes: &[u8]) -> Vec<f32> {
+    bytes
+        .chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn to_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+fn approx(a: &[f32], b: &[f32]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-4)
+}
+
+fn ramp_image(width: u32, height: u32, texels: &[[u8; 4]]) -> error::Result<Entity> {
+    let data: Vec<u8> = texels.iter().flatten().copied().collect();
+    let img = image_create(
+        Extent3d {
+            width,
+            height,
+            depth_or_array_layers: 1,
+        },
+        data,
+        TextureFormat::Rgba8Unorm,
+    )?;
+    image_set_sampler(img, 1, 0, 0)?; // nearest, clamp
+    Ok(img)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let mut ok = true;
+
+    // --- 1-D: 4-wide ramp, sample at texel centres ---
+    let ramp = ramp_image(4, 1, &[RED, GREEN, BLUE, WHITE])?;
+    let t = vec![0.125f32, 0.375, 0.625, 0.875];
+    let op_in = buffer_create_with_data(to_bytes(&t))?;
+    let dst = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
+    lookup(dst, op_in, ramp, 1, 1.0, 0.0, 1.0, 0.0, 1.0)?;
+    let got = f32s(&buffer_read(dst)?);
+    let want = vec![
+        1.0, 0.0, 0.0, 1.0, // red
+        0.0, 1.0, 0.0, 1.0, // green
+        0.0, 0.0, 1.0, 1.0, // blue
+        1.0, 1.0, 1.0, 1.0, // white
+    ];
+    if approx(&got, &want) {
+        println!("  PASS lookup 1-D ramp");
+    } else {
+        ok = false;
+        println!("  FAIL lookup 1-D: got {got:?}");
+    }
+    buffer_destroy(op_in)?;
+    buffer_destroy(dst)?;
+
+    // --- 2-D: 2x2 texture, sample at 4 texel centres ---
+    // row0 = [red, green], row1 = [blue, white]
+    let tex2 = ramp_image(2, 2, &[RED, GREEN, BLUE, WHITE])?;
+    let uv = vec![
+        0.25f32, 0.25, // red
+        0.75, 0.25, // green
+        0.25, 0.75, // blue
+        0.75, 0.75, // white
+    ];
+    let op_in2 = buffer_create_with_data(to_bytes(&uv))?;
+    let dst2 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
+    lookup(dst2, op_in2, tex2, 2, 1.0, 0.0, 1.0, 0.0, 1.0)?;
+    let got2 = f32s(&buffer_read(dst2)?);
+    if approx(&got2, &want) {
+        println!("  PASS lookup 2-D texture");
+    } else {
+        ok = false;
+        println!("  FAIL lookup 2-D: got {got2:?}");
+    }
+    buffer_destroy(op_in2)?;
+    buffer_destroy(dst2)?;
+
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("lookup_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("lookup_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/map_test.rs b/examples/map_test.rs
new file mode 100644
index 00000000..656c1856
--- /dev/null
+++ b/examples/map_test.rs
@@ -0,0 +1,85 @@
+//! Validation harness for the `map` algebra verb (task #5) and, underneath it,
+//! the WESL `@if(in_place)` specialization + `shader_create_with_features`
+//! infra (task #4's chosen approach).
+//!
+//! Checks:
+//!  - both pipelines (in-place / out-of-place) compile from one source;
+//!  - in-place `map` (dst == a) transforms EVERY component of a Float3 buffer
+//!    (the old scalar attr_* kernels left most of a wide attribute untouched);
+//!  - out-of-place `map` writes `dst = f(a)` and leaves `a` unchanged.
+//!
+//! Run: `cargo run --example map_test`. Exits non-zero on mismatch.
+
+use processing::prelude::*;
+
+fn f32s(bytes: &[u8]) -> Vec<f32> {
+    bytes
+        .chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn to_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+fn approx(a: &[f32], b: &[f32]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    // 5 particles x 3 components = 15 floats. The old bug would only touch the
+    // first 5 floats; component-generic map must touch all 15.
+    let n_particles = 5u32;
+    let components = 3u32;
+    let input: Vec<f32> = (0..(n_particles * components)).map(|i| i as f32).collect();
+
+    let mut ok = true;
+
+    // --- in-place: a *= 2 + 1 ---
+    let a = buffer_create_with_data(to_bytes(&input))?;
+    map(a, a, components, MAP_AFFINE, 2.0, 1.0)?;
+    let got = f32s(&buffer_read(a)?);
+    let want: Vec<f32> = input.iter().map(|x| x * 2.0 + 1.0).collect();
+    if approx(&got, &want) {
+        println!("  PASS map in-place, all {} components: {:?}", got.len(), got);
+    } else {
+        ok = false;
+        println!("  FAIL map in-place: got {got:?}, want {want:?}");
+    }
+    buffer_destroy(a)?;
+
+    // --- out-of-place: dst = |a|, a unchanged ---
+    let neg: Vec<f32> = (0..(n_particles * components))
+        .map(|i| -(i as f32) - 0.5)
+        .collect();
+    let a2 = buffer_create_with_data(to_bytes(&neg))?;
+    let dst = buffer_create_with_data(to_bytes(&vec![0.0; neg.len()]))?;
+    map(dst, a2, components, MAP_ABS, 0.0, 0.0)?;
+    let got_dst = f32s(&buffer_read(dst)?);
+    let got_a = f32s(&buffer_read(a2)?);
+    let want_dst: Vec<f32> = neg.iter().map(|x| x.abs()).collect();
+    if approx(&got_dst, &want_dst) && approx(&got_a, &neg) {
+        println!("  PASS map out-of-place: dst={got_dst:?}, a preserved");
+    } else {
+        ok = false;
+        println!("  FAIL map out-of-place: dst={got_dst:?} (want {want_dst:?}), a={got_a:?} (want {neg:?})");
+    }
+    buffer_destroy(a2)?;
+    buffer_destroy(dst)?;
+
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("map_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("map_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/reduce_test.rs b/examples/reduce_test.rs
new file mode 100644
index 00000000..a2cc938d
--- /dev/null
+++ b/examples/reduce_test.rs
@@ -0,0 +1,79 @@
+//! Validation harness for the GPU→CPU reduction (`reduce`): sum / min / max over
+//! an f32 buffer, read back to the host. Covers single- and multi-level (n>256)
+//! reductions. Values stay under 2^24 so f32 sums are exact.
+//!
+//! Run: `cargo run --example reduce_test`. Exits non-zero on mismatch.
+
+use bevy::prelude::Entity;
+use processing::prelude::*;
+
+fn to_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+
+fn check(label: &str, got: f32, want: f32) -> bool {
+    if (got - want).abs() <= 1e-3 * want.abs().max(1.0) {
+        println!("  PASS {label}: {got}");
+        true
+    } else {
+        println!("  FAIL {label}: got {got}, want {want}");
+        false
+    }
+}
+
+fn reduce_all(vals: &[f32]) -> error::Result<(f32, f32, f32)> {
+    let b = buffer_create_with_data(to_bytes(vals))?;
+    let sum = reduce(b, REDUCE_OP_SUM)?;
+    let mn = reduce(b, REDUCE_OP_MIN)?;
+    let mx = reduce(b, REDUCE_OP_MAX)?;
+    let _: Entity = b;
+    buffer_destroy(b)?;
+    Ok((sum, mn, mx))
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let mut ok = true;
+
+    // all-ones, single level
+    let (s, mn, mx) = reduce_all(&vec![1.0; 1000])?;
+    ok &= check("ones/1000 sum", s, 1000.0);
+    ok &= check("ones/1000 min", mn, 1.0);
+    ok &= check("ones/1000 max", mx, 1.0);
+
+    // ramp 0..300
+    let ramp: Vec<f32> = (0..300).map(|i| i as f32).collect();
+    let (s, mn, mx) = reduce_all(&ramp)?;
+    ok &= check("ramp/300 sum", s, 300.0 * 299.0 / 2.0);
+    ok &= check("ramp/300 min", mn, 0.0);
+    ok &= check("ramp/300 max", mx, 299.0);
+
+    // multi-level: all-ones n=70000
+    let (s, mn, mx) = reduce_all(&vec![1.0; 70_000])?;
+    ok &= check("ones/70k sum", s, 70_000.0);
+    ok &= check("ones/70k min", mn, 1.0);
+    ok &= check("ones/70k max", mx, 1.0);
+
+    // multi-level min/max: ramp 0..70000
+    let big: Vec<f32> = (0..70_000).map(|i| i as f32).collect();
+    let b = buffer_create_with_data(to_bytes(&big))?;
+    ok &= check("ramp/70k min", reduce(b, REDUCE_OP_MIN)?, 0.0);
+    ok &= check("ramp/70k max", reduce(b, REDUCE_OP_MAX)?, 69_999.0);
+    buffer_destroy(b)?;
+
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("reduce_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("reduce_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/scan_test.rs b/examples/scan_test.rs
new file mode 100644
index 00000000..a516bec0
--- /dev/null
+++ b/examples/scan_test.rs
@@ -0,0 +1,76 @@
+//! Validation harness for the GPU exclusive prefix-sum primitive
+//! (`prefix_sum_u32`). Boots an offscreen graphics context (to initialise the
+//! render device), scans several buffer sizes that exercise the single-block,
+//! block-boundary, and multi-level paths, and checks each against a CPU scan.
+//!
+//! Run: `cargo run --example scan_test`. Prints PASS/FAIL per case and exits
+//! non-zero if any case fails.
+
+use processing::prelude::*;
+
+fn u32s_to_bytes(v: &[u32]) -> Vec<u8> {
+    v.iter().flat_map(|x| x.to_le_bytes()).collect()
+}
+
+fn bytes_to_u32s(b: &[u8]) -> Vec<u32> {
+    b.chunks_exact(4)
+        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+
+fn run_case(n: usize) -> error::Result<bool> {
+    // Deterministic, non-trivial values (1..=7) so wrong strides/offsets show up.
+    let input: Vec<u32> = (0..n).map(|i| (i % 7 + 1) as u32).collect();
+
+    let buf = buffer_create_with_data(u32s_to_bytes(&input))?;
+    prefix_sum_u32(buf)?;
+    let out = bytes_to_u32s(&buffer_read(buf)?);
+    buffer_destroy(buf)?;
+
+    let mut expected = vec![0u32; n];
+    let mut acc = 0u32;
+    for i in 0..n {
+        expected[i] = acc;
+        acc += input[i];
+    }
+
+    if out.len() != expected.len() {
+        println!("  FAIL n={n}: length {} != {}", out.len(), expected.len());
+        return Ok(false);
+    }
+    if let Some(i) = (0..n).find(|&i| out[i] != expected[i]) {
+        println!(
+            "  FAIL n={n}: first mismatch at index {i}: got {}, want {}",
+            out[i], expected[i]
+        );
+        return Ok(false);
+    }
+    println!("  PASS n={n} (total={acc})");
+    Ok(true)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    // n values covering: empty, single, sub-block, exact block, block+1,
+    // multi-block single level, and two-level (> 256*256 = 65536).
+    let cases = [1usize, 5, 255, 256, 257, 1000, 65_536, 70_000, 300_000];
+    let mut all_ok = true;
+    for &n in &cases {
+        all_ok &= run_case(n)?;
+    }
+    Ok(all_ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("scan_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("scan_test: FAILURES");
+        exit(1).unwrap();
+    }
+}
diff --git a/examples/sort_test.rs b/examples/sort_test.rs
new file mode 100644
index 00000000..871c014c
--- /dev/null
+++ b/examples/sort_test.rs
@@ -0,0 +1,92 @@
+//! Validation harness for the GPU bitonic sort (`bitonic_sort_by_key`). Sorts a
+//! buffer of random f32 keys with `payload[i] = i`, then checks: keys come back
+//! ascending, payload is a permutation of 0..n, and each payload entry points at
+//! the original key now sitting in that slot (so the permutation is correct).
+//!
+//! Run: `cargo run --example sort_test`. Exits non-zero on any failure.
+
+use processing::prelude::*;
+
+fn u32s(b: &[u8]) -> Vec<u32> {
+    b.chunks_exact(4)
+        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn f32s(b: &[u8]) -> Vec<f32> {
+    b.chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect()
+}
+fn f32_bytes(v: &[f32]) -> Vec<u8> {
+    v.iter().flat_map(|f| f.to_le_bytes()).collect()
+}
+fn u32_bytes(v: &[u32]) -> Vec<u8> {
+    v.iter().flat_map(|x| x.to_le_bytes()).collect()
+}
+
+fn rnd(seed: u32) -> f32 {
+    let mut x = seed.wrapping_mul(747796405).wrapping_add(2891336453);
+    x = ((x >> ((x >> 28).wrapping_add(4))) ^ x).wrapping_mul(277803737);
+    x = (x >> 22) ^ x;
+    (x as f32) / (u32::MAX as f32)
+}
+
+fn run_case(n: u32) -> error::Result<bool> {
+    let orig_keys: Vec<f32> = (0..n)
+        .map(|i| rnd(i.wrapping_mul(2654435761).wrapping_add(7)))
+        .collect();
+    let idx: Vec<u32> = (0..n).collect();
+
+    let keys = buffer_create_with_data(f32_bytes(&orig_keys))?;
+    let payload = buffer_create_with_data(u32_bytes(&idx))?;
+    bitonic_sort_by_key(keys, payload)?;
+    let sorted_keys = f32s(&buffer_read(keys)?);
+    let perm = u32s(&buffer_read(payload)?);
+    buffer_destroy(keys)?;
+    buffer_destroy(payload)?;
+
+    // 1. ascending
+    if let Some(i) = (1..n as usize).find(|&i| sorted_keys[i] < sorted_keys[i - 1]) {
+        println!("  FAIL n={n}: not ascending at {i}: {} < {}", sorted_keys[i], sorted_keys[i - 1]);
+        return Ok(false);
+    }
+    // 2. permutation of 0..n
+    let mut seen = vec![false; n as usize];
+    for &p in &perm {
+        if p >= n || seen[p as usize] {
+            println!("  FAIL n={n}: payload not a permutation (bad/dup index {p})");
+            return Ok(false);
+        }
+        seen[p as usize] = true;
+    }
+    // 3. payload tracks the keys: original key at payload[i] equals sorted key i
+    if let Some(i) = (0..n as usize).find(|&i| orig_keys[perm[i] as usize] != sorted_keys[i]) {
+        println!("  FAIL n={n}: payload[{i}] mismatch: orig[{}]={} != {}", perm[i], orig_keys[perm[i] as usize], sorted_keys[i]);
+        return Ok(false);
+    }
+    println!("  PASS n={n}");
+    Ok(true)
+}
+
+fn sketch() -> error::Result<bool> {
+    init(Config::default())?;
+    let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
+    let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
+
+    let mut ok = true;
+    for &n in &[2u32, 8, 64, 1024, 4096, 65536] {
+        ok &= run_case(n)?;
+    }
+    Ok(ok)
+}
+
+fn main() {
+    let ok = sketch().unwrap();
+    if ok {
+        println!("sort_test: ALL PASS");
+        exit(0).unwrap();
+    } else {
+        println!("sort_test: FAILURES");
+        exit(1).unwrap();
+    }
+}

From d520c8050f2007be4d7c115c53ffc85e75f91d39 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 28 Apr 2026 14:50:24 -0700
Subject: [PATCH 02/14] Video.

---
 Cargo.toml                                |   8 +
 assets/video/file_example_MP4_640_3MG.mp4 | Bin 0 -> 454083 bytes
 crates/processing_core/src/error.rs       |   2 +
 crates/processing_input/src/state.rs      |   4 +-
 crates/processing_pyo3/Cargo.toml         |   2 +
 crates/processing_pyo3/examples/test.py   |   1 -
 crates/processing_pyo3/examples/video.py  |  38 +++++
 crates/processing_pyo3/src/lib.rs         |  13 ++
 crates/processing_pyo3/src/video.rs       |  70 ++++++++
 crates/processing_video/Cargo.toml        |  13 ++
 crates/processing_video/src/lib.rs        | 195 ++++++++++++++++++++++
 examples/video.rs                         |  50 ++++++
 src/lib.rs                                |   3 +
 13 files changed, 397 insertions(+), 2 deletions(-)
 create mode 100644 assets/video/file_example_MP4_640_3MG.mp4
 create mode 100644 crates/processing_pyo3/examples/video.py
 create mode 100644 crates/processing_pyo3/src/video.rs
 create mode 100644 crates/processing_video/Cargo.toml
 create mode 100644 crates/processing_video/src/lib.rs
 create mode 100644 examples/video.rs

diff --git a/Cargo.toml b/Cargo.toml
index 633ca8d9..26463fc7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,7 @@ default = ["wayland", "x11"]
 wayland = ["processing_render/wayland"]
 x11 = ["processing_render/x11"]
 webcam = ["dep:processing_webcam"]
+video = ["dep:processing_video"]
 cuda = ["dep:processing_cuda", "processing_cuda/cuda"]
 
 [workspace]
@@ -68,6 +69,7 @@ processing_midi = { path = "crates/processing_midi" }
 processing_audio = { path = "crates/processing_audio" }
 processing_input = { path = "crates/processing_input" }
 processing_glfw = { path = "crates/processing_glfw" }
+processing_video = { path = "crates/processing_video" }
 processing_webcam = { path = "crates/processing_webcam" }
 rand = "0.10"
 rand_distr = "0.6"
@@ -79,6 +81,7 @@ processing_render = { workspace = true }
 processing_midi = { workspace = true }
 processing_audio = { workspace = true }
 processing_input = { workspace = true }
+processing_video = { workspace = true, optional = true }
 processing_webcam = { workspace = true, optional = true }
 processing_cuda = { workspace = true, optional = true }
 tracing = "0.1"
@@ -163,6 +166,11 @@ path = "examples/midi.rs"
 name = "gltf_load"
 path = "examples/gltf_load.rs"
 
+[[example]]
+name = "video"
+path = "examples/video.rs"
+required-features = ["video"]
+
 [[example]]
 name = "webcam"
 path = "examples/webcam.rs"
diff --git a/assets/video/file_example_MP4_640_3MG.mp4 b/assets/video/file_example_MP4_640_3MG.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..61a12bca44ab027938aa1aa3d05334476b7bdf1f
GIT binary patch
literal 454083
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%0DQSC=_gOZku
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

literal 0
HcmV?d00001

diff --git a/crates/processing_core/src/error.rs b/crates/processing_core/src/error.rs
index 41510f34..b0fd3d13 100644
--- a/crates/processing_core/src/error.rs
+++ b/crates/processing_core/src/error.rs
@@ -38,6 +38,8 @@ pub enum ProcessingError {
     GltfLoadError(String),
     #[error("Webcam not connected")]
     WebcamNotConnected,
+    #[error("Video not loaded")]
+    VideoNotLoaded,
     #[error("Shader compilation error: {0}")]
     ShaderCompilationError(String),
     #[error("Shader not found")]
diff --git a/crates/processing_input/src/state.rs b/crates/processing_input/src/state.rs
index e63995aa..d64585f7 100644
--- a/crates/processing_input/src/state.rs
+++ b/crates/processing_input/src/state.rs
@@ -60,7 +60,9 @@ pub fn track_last_key(mut reader: MessageReader<KeyboardInput>, mut last: ResMut
     for event in reader.read() {
         match event.state {
             ButtonState::Pressed => {
-                last.code = Some(event.key_code);
+                if !matches!(event.key_code, KeyCode::Unidentified(_)) {
+                    last.code = Some(event.key_code);
+                }
                 last.character = event.text.as_ref().and_then(|t| t.chars().next());
                 last.just_pressed = true;
             }
diff --git a/crates/processing_pyo3/Cargo.toml b/crates/processing_pyo3/Cargo.toml
index 2eb65a94..91ab255d 100644
--- a/crates/processing_pyo3/Cargo.toml
+++ b/crates/processing_pyo3/Cargo.toml
@@ -15,6 +15,7 @@ default = ["wayland", "static-link"]
 wayland = ["processing/wayland", "processing_glfw/wayland"]
 static-link = ["processing_glfw/static-link"]
 x11 = ["processing/x11", "processing_glfw/x11"]
+video = ["processing/video", "dep:processing_video"]
 webcam = ["processing/webcam", "dep:processing_webcam"]
 cuda = ["dep:processing_cuda", "processing_cuda/cuda", "processing/cuda"]
 
@@ -22,6 +23,7 @@ cuda = ["dep:processing_cuda", "processing_cuda/cuda", "processing/cuda"]
 pyo3 = { workspace = true, features = ["experimental-inspect", "multiple-pymethods"] }
 processing = { workspace = true }
 processing_render = { workspace = true }
+processing_video = { workspace = true, optional = true }
 processing_webcam = { workspace = true, optional = true }
 processing_glfw = { workspace = true }
 bevy = { workspace = true, features = ["file_watcher"] }
diff --git a/crates/processing_pyo3/examples/test.py b/crates/processing_pyo3/examples/test.py
index 53671439..b9c1791b 100644
--- a/crates/processing_pyo3/examples/test.py
+++ b/crates/processing_pyo3/examples/test.py
@@ -3,7 +3,6 @@
 
 def setup():
     size(200, 200)
-    background(100, 0, 0)
     print(width)
 
 def draw():
diff --git a/crates/processing_pyo3/examples/video.py b/crates/processing_pyo3/examples/video.py
new file mode 100644
index 00000000..ed68b3d3
--- /dev/null
+++ b/crates/processing_pyo3/examples/video.py
@@ -0,0 +1,38 @@
+from mewnala import *
+
+def setup():
+    global vid, img, paused
+    size(640, 480)
+    vid = create_video("video/file_example_MP4_640_3MG.mp4", looping=True)
+    img = None
+    paused = False
+
+
+def draw():
+    global img
+    if img is None and vid.is_loaded():
+        img = vid.image()
+
+    if img is not None:
+        background(img)
+
+
+def key_pressed():
+    global paused
+    if key_code == SPACE:
+        paused = not paused
+        if paused:
+            vid.pause()
+        else:
+            vid.resume()
+    elif key_code == RIGHT_ARROW:
+        vid.seek(vid.position() + 1.0)
+    elif key_code == LEFT_ARROW:
+        vid.seek(max(0.0, vid.position() - 1.0))
+    elif key_code == UP:
+        vid.set_speed(2.0)
+    elif key_code == DOWN:
+        vid.set_speed(1.0)
+
+
+run()
diff --git a/crates/processing_pyo3/src/lib.rs b/crates/processing_pyo3/src/lib.rs
index f8378bbe..36c9221f 100644
--- a/crates/processing_pyo3/src/lib.rs
+++ b/crates/processing_pyo3/src/lib.rs
@@ -26,6 +26,8 @@ pub(crate) mod particles;
 pub(crate) mod shader;
 mod surface;
 mod time;
+#[cfg(feature = "video")]
+mod video;
 #[cfg(feature = "webcam")]
 mod webcam;
 
@@ -566,6 +568,9 @@ mod mewnala {
         PyColor::xyz(x, y, z, a)
     }
 
+    #[cfg(feature = "video")]
+    #[pymodule_export]
+    use super::video::Video;
     #[cfg(feature = "webcam")]
     #[pymodule_export]
     use super::webcam::Webcam;
@@ -929,6 +934,7 @@ mod mewnala {
                     }
                 }
 
+                sync_globals(module, &globals)?;
                 dispatch_event_callbacks(&locals)?;
 
                 let should_draw = first_frame
@@ -2227,6 +2233,13 @@ mod mewnala {
         graphics!(module).draw_tetrahedron(radius)
     }
 
+    #[cfg(feature = "video")]
+    #[pyfunction]
+    #[pyo3(signature = (path, looping=false))]
+    fn create_video(path: &str, looping: bool) -> PyResult<video::Video> {
+        video::Video::new(path, looping)
+    }
+
     #[cfg(feature = "webcam")]
     #[pyfunction]
     #[pyo3(signature = (width=None, height=None, framerate=None))]
diff --git a/crates/processing_pyo3/src/video.rs b/crates/processing_pyo3/src/video.rs
new file mode 100644
index 00000000..0fef1cf6
--- /dev/null
+++ b/crates/processing_pyo3/src/video.rs
@@ -0,0 +1,70 @@
+use bevy::prelude::Entity;
+use processing_video::{
+    PlaybackMode, video_create_with_mode, video_destroy, video_image, video_is_loaded, video_load,
+    video_position, video_resolution, video_seek, video_set_paused, video_set_speed,
+};
+use pyo3::{exceptions::PyRuntimeError, prelude::*};
+
+use crate::graphics::Image;
+
+#[pyclass(unsendable)]
+pub struct Video {
+    entity: Entity,
+}
+
+#[pymethods]
+impl Video {
+    #[new]
+    #[pyo3(signature = (path, looping=false))]
+    pub fn new(path: &str, looping: bool) -> PyResult<Self> {
+        let handle = video_load(path).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        let mode = if looping {
+            PlaybackMode::Loop
+        } else {
+            PlaybackMode::Once
+        };
+        let entity = video_create_with_mode(handle, mode)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Self { entity })
+    }
+
+    pub fn is_loaded(&self) -> PyResult<bool> {
+        video_is_loaded(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn resolution(&self) -> PyResult<(u32, u32)> {
+        video_resolution(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn image(&self) -> PyResult<Image> {
+        let entity =
+            video_image(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Image::from_entity(entity))
+    }
+
+    pub fn position(&self) -> PyResult<f64> {
+        video_position(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn seek(&self, seconds: f64) -> PyResult<()> {
+        video_seek(self.entity, seconds).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn pause(&self) -> PyResult<()> {
+        video_set_paused(self.entity, true).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn resume(&self) -> PyResult<()> {
+        video_set_paused(self.entity, false).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn set_speed(&self, speed: f32) -> PyResult<()> {
+        video_set_speed(self.entity, speed).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+}
+
+impl Drop for Video {
+    fn drop(&mut self) {
+        let _ = video_destroy(self.entity);
+    }
+}
diff --git a/crates/processing_video/Cargo.toml b/crates/processing_video/Cargo.toml
new file mode 100644
index 00000000..b01209e2
--- /dev/null
+++ b/crates/processing_video/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "processing_video"
+version = "0.0.1"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[dependencies]
+bevy = { workspace = true }
+nannou_video = { path = "../../../../nannou-org/nannou/nannou_video" }
+processing_core = { workspace = true }
+processing_render = { workspace = true }
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
new file mode 100644
index 00000000..f9306d75
--- /dev/null
+++ b/crates/processing_video/src/lib.rs
@@ -0,0 +1,195 @@
+use bevy::asset::AssetPath;
+use bevy::asset::io::AssetSourceId;
+use bevy::ecs::system::RunSystemOnce;
+use bevy::prelude::*;
+
+pub use nannou_video::{
+    HwAccelPolicy, NannouVideoPlugin, NetworkPreset, PlaybackMode, SeekTo, Video,
+    VideoAssetLoaderError, VideoEnded, VideoFailed, VideoLoaded, VideoLoaderSettings, VideoLooped,
+    VideoOutput, VideoPlayer, VideoResize, VideoSeeked, VideoSource,
+};
+
+use processing_core::app_mut;
+use processing_core::error::{ProcessingError, Result};
+use processing_render::image;
+
+#[derive(Component)]
+pub struct ProcessingVideo;
+
+fn create(In(handle): In<Handle<Video>>, mut commands: Commands) -> Entity {
+    commands
+        .spawn((ProcessingVideo, VideoPlayer::new(handle)))
+        .id()
+}
+
+fn create_with_mode(
+    In((handle, mode)): In<(Handle<Video>, PlaybackMode)>,
+    mut commands: Commands,
+) -> Entity {
+    commands
+        .spawn((
+            ProcessingVideo,
+            VideoPlayer::new(handle).with_mode(mode),
+        ))
+        .id()
+}
+
+fn create_image(In(entity): In<Entity>, world: &mut World) -> Result<Entity> {
+    let output = world
+        .get::<VideoOutput>(entity)
+        .ok_or(ProcessingError::VideoNotLoaded)?;
+    let handle = output.image.clone();
+
+    let child = world
+        .run_system_once_with(image::from_handle, handle)
+        .unwrap()?;
+    world.entity_mut(entity).add_child(child);
+    Ok(child)
+}
+
+fn is_loaded(In(entity): In<Entity>, outputs: Query<&VideoOutput>) -> Result<bool> {
+    Ok(outputs.get(entity).is_ok())
+}
+
+fn resolution(In(entity): In<Entity>, outputs: Query<&VideoOutput>) -> Result<(u32, u32)> {
+    let output = outputs
+        .get(entity)
+        .map_err(|_| ProcessingError::VideoNotLoaded)?;
+    Ok((output.size.x, output.size.y))
+}
+
+fn position(In(entity): In<Entity>, outputs: Query<&VideoOutput>) -> Result<f64> {
+    let output = outputs
+        .get(entity)
+        .map_err(|_| ProcessingError::VideoNotLoaded)?;
+    Ok(output.position_seconds)
+}
+
+fn seek(In((entity, seconds)): In<(Entity, f64)>, mut commands: Commands) -> Result<()> {
+    commands.entity(entity).insert(SeekTo(seconds));
+    Ok(())
+}
+
+fn set_paused(
+    In((entity, paused)): In<(Entity, bool)>,
+    mut players: Query<&mut VideoPlayer>,
+) -> Result<()> {
+    let mut player = players
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::VideoNotLoaded)?;
+    player.paused = paused;
+    Ok(())
+}
+
+fn set_speed(
+    In((entity, speed)): In<(Entity, f32)>,
+    mut players: Query<&mut VideoPlayer>,
+) -> Result<()> {
+    let mut player = players
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::VideoNotLoaded)?;
+    player.speed = speed;
+    Ok(())
+}
+
+fn destroy(In(entity): In<Entity>, mut commands: Commands) -> Result<()> {
+    commands.entity(entity).despawn();
+    Ok(())
+}
+
+pub fn video_load(path: &str) -> Result<Handle<Video>> {
+    app_mut(|app| {
+        let config = app.world().resource::<processing_core::config::Config>();
+        let asset_path: AssetPath = match config.get(processing_core::config::ConfigKey::AssetRootPath) {
+            Some(_) => {
+                AssetPath::from_path_buf(path.into())
+                    .with_source(AssetSourceId::from("assets_directory"))
+            }
+            None => AssetPath::from_path_buf(path.into()),
+        };
+        let asset_server = app.world().resource::<AssetServer>();
+        Ok(asset_server.load(asset_path))
+    })
+}
+
+pub fn video_create(handle: Handle<Video>) -> Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(create, handle)
+            .unwrap())
+    })
+}
+
+pub fn video_create_with_mode(handle: Handle<Video>, mode: PlaybackMode) -> Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(create_with_mode, (handle, mode))
+            .unwrap())
+    })
+}
+
+pub fn video_is_loaded(entity: Entity) -> Result<bool> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(is_loaded, entity)
+            .unwrap()
+    })
+}
+
+pub fn video_image(entity: Entity) -> Result<Entity> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(create_image, entity)
+            .unwrap()
+    })
+}
+
+pub fn video_resolution(entity: Entity) -> Result<(u32, u32)> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(resolution, entity)
+            .unwrap()
+    })
+}
+
+pub fn video_position(entity: Entity) -> Result<f64> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(position, entity)
+            .unwrap()
+    })
+}
+
+pub fn video_seek(entity: Entity, seconds: f64) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(seek, (entity, seconds))
+            .unwrap()
+    })
+}
+
+pub fn video_set_paused(entity: Entity, paused: bool) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(set_paused, (entity, paused))
+            .unwrap()
+    })
+}
+
+pub fn video_set_speed(entity: Entity, speed: f32) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(set_speed, (entity, speed))
+            .unwrap()
+    })
+}
+
+pub fn video_destroy(entity: Entity) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(destroy, entity)
+            .unwrap()
+    })
+}
diff --git a/examples/video.rs b/examples/video.rs
new file mode 100644
index 00000000..665b09ba
--- /dev/null
+++ b/examples/video.rs
@@ -0,0 +1,50 @@
+use processing_glfw::GlfwContext;
+
+use processing::prelude::*;
+use processing_render::render::command::DrawCommand;
+use processing_video::{video_create, video_destroy, video_image, video_is_loaded, video_load};
+
+fn main() {
+    match sketch() {
+        Ok(_) => {
+            eprintln!("Sketch completed successfully");
+            exit(0).unwrap();
+        }
+        Err(e) => {
+            eprintln!("Sketch error: {:?}", e);
+            exit(1).unwrap();
+        }
+    };
+}
+
+fn sketch() -> error::Result<()> {
+    let width = 640;
+    let height = 480;
+
+    let mut glfw_ctx = GlfwContext::new(width, height)?;
+    init(Config::default())?;
+
+    let surface = glfw_ctx.create_surface(width, height)?;
+    let graphics = graphics_create(surface, width, height, TextureFormat::Rgba16Float)?;
+
+    let handle = video_load("video/file_example_MP4_640_3MG.mp4")?;
+    let video = video_create(handle)?;
+    let mut image_entity = None;
+
+    while glfw_ctx.poll_events() {
+        graphics_begin_draw(graphics)?;
+
+        if image_entity.is_none() && video_is_loaded(video)? {
+            image_entity = Some(video_image(video)?);
+        }
+
+        if let Some(img) = image_entity {
+            graphics_record_command(graphics, DrawCommand::BackgroundImage(img))?;
+        }
+
+        graphics_end_draw(graphics)?;
+    }
+
+    video_destroy(video)?;
+    Ok(())
+}
diff --git a/src/lib.rs b/src/lib.rs
index 9f00d064..e86cd758 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -67,6 +67,9 @@ fn create_app(config: Config) -> App {
     #[cfg(feature = "cuda")]
     app.add_plugins(processing_cuda::CudaPlugin);
 
+    #[cfg(feature = "video")]
+    app.add_plugins(processing_video::NannouVideoPlugin);
+
     #[cfg(feature = "webcam")]
     app.add_plugins(processing_webcam::WebcamPlugin);
 

From d8cf4fafdd7cfbc0a85ae1f9d6f193d494e00936 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 28 Apr 2026 17:36:44 -0700
Subject: [PATCH 03/14] Make more like processing video.

---
 crates/processing_pyo3/src/lib.rs   |  5 ++--
 crates/processing_pyo3/src/video.rs | 41 ++++++++++++++++++-----------
 crates/processing_video/src/lib.rs  | 19 +++++++++++++
 3 files changed, 47 insertions(+), 18 deletions(-)

diff --git a/crates/processing_pyo3/src/lib.rs b/crates/processing_pyo3/src/lib.rs
index 36c9221f..8f98b91c 100644
--- a/crates/processing_pyo3/src/lib.rs
+++ b/crates/processing_pyo3/src/lib.rs
@@ -2235,9 +2235,8 @@ mod mewnala {
 
     #[cfg(feature = "video")]
     #[pyfunction]
-    #[pyo3(signature = (path, looping=false))]
-    fn create_video(path: &str, looping: bool) -> PyResult<video::Video> {
-        video::Video::new(path, looping)
+    fn create_video(path: &str) -> PyResult<video::Video> {
+        video::Video::new(path)
     }
 
     #[cfg(feature = "webcam")]
diff --git a/crates/processing_pyo3/src/video.rs b/crates/processing_pyo3/src/video.rs
index 0fef1cf6..dd492cc1 100644
--- a/crates/processing_pyo3/src/video.rs
+++ b/crates/processing_pyo3/src/video.rs
@@ -1,7 +1,8 @@
 use bevy::prelude::Entity;
 use processing_video::{
-    PlaybackMode, video_create_with_mode, video_destroy, video_image, video_is_loaded, video_load,
-    video_position, video_resolution, video_seek, video_set_paused, video_set_speed,
+    PlaybackMode, video_create, video_destroy, video_image, video_is_loaded, video_load,
+    video_position, video_resolution, video_seek, video_set_mode, video_set_paused,
+    video_set_speed,
 };
 use pyo3::{exceptions::PyRuntimeError, prelude::*};
 
@@ -15,16 +16,10 @@ pub struct Video {
 #[pymethods]
 impl Video {
     #[new]
-    #[pyo3(signature = (path, looping=false))]
-    pub fn new(path: &str, looping: bool) -> PyResult<Self> {
+    pub fn new(path: &str) -> PyResult<Self> {
         let handle = video_load(path).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        let mode = if looping {
-            PlaybackMode::Loop
-        } else {
-            PlaybackMode::Once
-        };
-        let entity = video_create_with_mode(handle, mode)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        let entity =
+            video_create(handle).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
         Ok(Self { entity })
     }
 
@@ -50,16 +45,32 @@ impl Video {
         video_seek(self.entity, seconds).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn play(&self) -> PyResult<()> {
+        video_set_mode(self.entity, PlaybackMode::Once)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        video_set_paused(self.entity, false)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn pause(&self) -> PyResult<()> {
         video_set_paused(self.entity, true).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn resume(&self) -> PyResult<()> {
-        video_set_paused(self.entity, false).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(name = "loop")]
+    pub fn loop_(&self) -> PyResult<()> {
+        video_set_mode(self.entity, PlaybackMode::Loop)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        video_set_paused(self.entity, false)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn no_loop(&self) -> PyResult<()> {
+        video_set_mode(self.entity, PlaybackMode::Once)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn set_speed(&self, speed: f32) -> PyResult<()> {
-        video_set_speed(self.entity, speed).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    pub fn speed(&self, rate: f32) -> PyResult<()> {
+        video_set_speed(self.entity, rate).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 }
 
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
index f9306d75..b8645726 100644
--- a/crates/processing_video/src/lib.rs
+++ b/crates/processing_video/src/lib.rs
@@ -92,6 +92,17 @@ fn set_speed(
     Ok(())
 }
 
+fn set_mode(
+    In((entity, mode)): In<(Entity, PlaybackMode)>,
+    mut players: Query<&mut VideoPlayer>,
+) -> Result<()> {
+    let mut player = players
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::VideoNotLoaded)?;
+    player.mode = mode;
+    Ok(())
+}
+
 fn destroy(In(entity): In<Entity>, mut commands: Commands) -> Result<()> {
     commands.entity(entity).despawn();
     Ok(())
@@ -186,6 +197,14 @@ pub fn video_set_speed(entity: Entity, speed: f32) -> Result<()> {
     })
 }
 
+pub fn video_set_mode(entity: Entity, mode: PlaybackMode) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(set_mode, (entity, mode))
+            .unwrap()
+    })
+}
+
 pub fn video_destroy(entity: Entity) -> Result<()> {
     app_mut(|app| {
         app.world_mut()

From c74deae773faaa42b4f5bcaad0b88be5301a05e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 28 Apr 2026 17:39:05 -0700
Subject: [PATCH 04/14] Bump version.

---
 crates/processing_video/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/processing_video/Cargo.toml b/crates/processing_video/Cargo.toml
index b01209e2..401d9f2a 100644
--- a/crates/processing_video/Cargo.toml
+++ b/crates/processing_video/Cargo.toml
@@ -8,6 +8,6 @@ workspace = true
 
 [dependencies]
 bevy = { workspace = true }
-nannou_video = { path = "../../../../nannou-org/nannou/nannou_video" }
+nannou_video = { git = "https://github.com/nannou-org/nannou", branch = "bevy-refactor" }
 processing_core = { workspace = true }
 processing_render = { workspace = true }

From c872a217489a3f39499965f77e90059526829185 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 28 Apr 2026 17:40:46 -0700
Subject: [PATCH 05/14] Fmt.

---
 crates/processing_pyo3/src/video.rs |  9 +++------
 crates/processing_video/src/lib.rs  | 18 +++++++-----------
 2 files changed, 10 insertions(+), 17 deletions(-)

diff --git a/crates/processing_pyo3/src/video.rs b/crates/processing_pyo3/src/video.rs
index dd492cc1..8f0e76db 100644
--- a/crates/processing_pyo3/src/video.rs
+++ b/crates/processing_pyo3/src/video.rs
@@ -18,8 +18,7 @@ impl Video {
     #[new]
     pub fn new(path: &str) -> PyResult<Self> {
         let handle = video_load(path).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        let entity =
-            video_create(handle).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        let entity = video_create(handle).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
         Ok(Self { entity })
     }
 
@@ -48,8 +47,7 @@ impl Video {
     pub fn play(&self) -> PyResult<()> {
         video_set_mode(self.entity, PlaybackMode::Once)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        video_set_paused(self.entity, false)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+        video_set_paused(self.entity, false).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     pub fn pause(&self) -> PyResult<()> {
@@ -60,8 +58,7 @@ impl Video {
     pub fn loop_(&self) -> PyResult<()> {
         video_set_mode(self.entity, PlaybackMode::Loop)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        video_set_paused(self.entity, false)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+        video_set_paused(self.entity, false).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     pub fn no_loop(&self) -> PyResult<()> {
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
index b8645726..0ea8e291 100644
--- a/crates/processing_video/src/lib.rs
+++ b/crates/processing_video/src/lib.rs
@@ -27,10 +27,7 @@ fn create_with_mode(
     mut commands: Commands,
 ) -> Entity {
     commands
-        .spawn((
-            ProcessingVideo,
-            VideoPlayer::new(handle).with_mode(mode),
-        ))
+        .spawn((ProcessingVideo, VideoPlayer::new(handle).with_mode(mode)))
         .id()
 }
 
@@ -111,13 +108,12 @@ fn destroy(In(entity): In<Entity>, mut commands: Commands) -> Result<()> {
 pub fn video_load(path: &str) -> Result<Handle<Video>> {
     app_mut(|app| {
         let config = app.world().resource::<processing_core::config::Config>();
-        let asset_path: AssetPath = match config.get(processing_core::config::ConfigKey::AssetRootPath) {
-            Some(_) => {
-                AssetPath::from_path_buf(path.into())
-                    .with_source(AssetSourceId::from("assets_directory"))
-            }
-            None => AssetPath::from_path_buf(path.into()),
-        };
+        let asset_path: AssetPath =
+            match config.get(processing_core::config::ConfigKey::AssetRootPath) {
+                Some(_) => AssetPath::from_path_buf(path.into())
+                    .with_source(AssetSourceId::from("assets_directory")),
+                None => AssetPath::from_path_buf(path.into()),
+            };
         let asset_server = app.world().resource::<AssetServer>();
         Ok(asset_server.load(asset_path))
     })

From c5ca080984550ee756584194e20dcae62e7e1f38 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 28 Apr 2026 22:32:28 -0700
Subject: [PATCH 06/14] ffmpeg cicd.

---
 .github/workflows/release.yml | 62 +++++++++++++++++++++++++++++++----
 1 file changed, 56 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index a379efed..a782172b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -8,6 +8,9 @@ on:
 permissions:
   contents: read
 
+env:
+  FFMPEG_VERSION: "7.1.1"
+
 jobs:
   generate-stubs:
     runs-on: ubuntu-22.04
@@ -16,9 +19,18 @@ jobs:
         with:
           submodules: true
       - uses: ./.github/actions/setup
+      - name: Build FFmpeg
+        run: |
+          sudo apt-get install -y nasm pkg-config
+          curl -L https://ffmpeg.org/releases/ffmpeg-${{ env.FFMPEG_VERSION }}.tar.xz | tar xJ
+          cd ffmpeg-${{ env.FFMPEG_VERSION }}
+          ./configure --prefix=/usr/local --libdir=/usr/local/lib --enable-shared --disable-static --disable-programs --disable-doc
+          make -j$(nproc)
+          sudo make install
+          sudo ldconfig
       - name: Generate type stubs
         run: |
-          cargo build --release -p processing_pyo3
+          cargo build --release -p processing_pyo3 --features video
           cargo run --release -p generate_stubs
       - uses: actions/upload-artifact@v4
         with:
@@ -31,7 +43,7 @@ jobs:
     strategy:
       matrix:
         # TODO: add aarch64 when we are ready to address long build times
-        target: [x86_64] 
+        target: [x86_64]
     steps:
       - uses: actions/checkout@v4
         with:
@@ -52,7 +64,7 @@ jobs:
           container: "quay.io/pypa/manylinux_2_34_${{matrix.target}}:latest"
           docker-options: "-e PKG_CONFIG_PATH=/usr/lib64/pkgconfig:/usr/lib/${{matrix.target}}-linux-gnu/pkgconfig:/usr/local/lib/pkgconfig"
           target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist --find-interpreter --features video
           manylinux: 2_34
           before-script-linux: |
             EXTRA_PACKAGES=""
@@ -60,11 +72,18 @@ jobs:
               EXTRA_PACKAGES="gcc-aarch64-linux-gnu"
             fi
 
-            dnf -y install cmake gcc-c++ \
+            dnf -y install cmake gcc-c++ nasm \
                 pkgconfig alsa-lib-devel systemd-devel \
                 libX11-devel libXrandr-devel libXinerama-devel libXcursor-devel libXi-devel \
                 libxkbcommon-devel wayland-devel wayland-protocols-devel \
                 glfw-devel $EXTRA_PACKAGES
+
+            curl -L https://ffmpeg.org/releases/ffmpeg-${{ env.FFMPEG_VERSION }}.tar.xz | tar xJ
+            cd ffmpeg-${{ env.FFMPEG_VERSION }}
+            ./configure --prefix=/usr/local --libdir=/usr/local/lib --enable-shared --disable-static --disable-programs --disable-doc
+            make -j$(nproc)
+            make install
+            ldconfig
           working-directory: crates/processing_pyo3
       - uses: actions/upload-artifact@v4
         with:
@@ -92,12 +111,26 @@ jobs:
         with:
           name: type-stubs
           path: crates/processing_pyo3/mewnala
+      - name: Build FFmpeg (LGPL, shared)
+        run: |
+          brew install nasm pkg-config
+          curl -L https://ffmpeg.org/releases/ffmpeg-${{ env.FFMPEG_VERSION }}.tar.xz | tar xJ
+          cd ffmpeg-${{ env.FFMPEG_VERSION }}
+          ./configure --prefix=/usr/local --libdir=/usr/local/lib --enable-shared --disable-static --disable-programs --disable-doc
+          make -j$(sysctl -n hw.ncpu)
+          sudo make install
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist --find-interpreter --features video
           working-directory: crates/processing_pyo3
+      - name: Bundle dylibs into wheels
+        run: |
+          pip install delocate
+          delocate-wheel -w dist-fixed crates/processing_pyo3/dist/*.whl
+          rm -rf crates/processing_pyo3/dist
+          mv dist-fixed crates/processing_pyo3/dist
       - uses: actions/upload-artifact@v4
         with:
           name: wheels-macos-${{ matrix.target }}
@@ -117,12 +150,29 @@ jobs:
         with:
           name: type-stubs
           path: crates/processing_pyo3/mewnala
+      - name: Install FFmpeg
+        shell: bash
+        run: |
+          curl -L -o ffmpeg.zip "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n7.1-latest-win64-lgpl-shared-7.1.zip"
+          7z x ffmpeg.zip -offmpeg-extract
+          mv ffmpeg-extract/ffmpeg-* ffmpeg
+          echo "FFMPEG_DIR=$(cygpath -w $(pwd)/ffmpeg)" >> $GITHUB_ENV
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
           target: x64
-          args: --release --out dist --find-interpreter
+          args: --release --out dist --find-interpreter --features video
           working-directory: crates/processing_pyo3
+      - name: Bundle DLLs into wheels
+        shell: bash
+        run: |
+          pip install delvewheel
+          mkdir dist-fixed
+          for whl in crates/processing_pyo3/dist/*.whl; do
+            delvewheel repair --add-path "$FFMPEG_DIR/bin" -w dist-fixed "$whl"
+          done
+          rm -rf crates/processing_pyo3/dist
+          mv dist-fixed crates/processing_pyo3/dist
       - uses: actions/upload-artifact@v4
         with:
           name: wheels-windows-x64

From acb4f8a72544fb0c6a84c13e6cd684deab0d4ca9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Wed, 29 Apr 2026 12:10:39 -0700
Subject: [PATCH 07/14] Additional features for rendering images.

---
 crates/processing_pyo3/src/graphics.rs        | 23 ++++++++++++++++++-
 crates/processing_pyo3/src/lib.rs             | 21 +++++++++++++++++
 .../processing_render/src/render/command.rs   |  4 ++++
 crates/processing_render/src/render/mod.rs    | 19 +++++++++++++++
 4 files changed, 66 insertions(+), 1 deletion(-)

diff --git a/crates/processing_pyo3/src/graphics.rs b/crates/processing_pyo3/src/graphics.rs
index e801fad8..118285a4 100644
--- a/crates/processing_pyo3/src/graphics.rs
+++ b/crates/processing_pyo3/src/graphics.rs
@@ -537,6 +537,12 @@ impl<'a, 'py> FromPyObject<'a, 'py> for ImageRef {
         if let Ok(img) = ob.extract::<PyRef<Image>>() {
             return Ok(ImageRef { entity: img.entity });
         }
+        #[cfg(feature = "video")]
+        if let Ok(vid) = ob.extract::<PyRef<crate::video::Video>>() {
+            return Ok(ImageRef {
+                entity: vid.image_entity()?,
+            });
+        }
         #[cfg(feature = "webcam")]
         if let Ok(cam) = ob.extract::<PyRef<crate::webcam::Webcam>>() {
             return Ok(ImageRef {
@@ -544,7 +550,7 @@ impl<'a, 'py> FromPyObject<'a, 'py> for ImageRef {
             });
         }
         Err(pyo3::exceptions::PyTypeError::new_err(
-            "expected an Image or Webcam",
+            "expected an Image, Video, or Webcam",
         ))
     }
 }
@@ -2169,6 +2175,21 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn texture(&self, source: ImageRef) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::Texture(source.entity))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn no_texture(&self) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::NoTexture)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn texture_transform(&self, transform: crate::math::PyAffine2) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::TextureTransform(transform.0))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn unlit(&self) -> PyResult<()> {
         graphics_record_command(self.entity, DrawCommand::Unlit)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
diff --git a/crates/processing_pyo3/src/lib.rs b/crates/processing_pyo3/src/lib.rs
index 8f98b91c..54cf4ad6 100644
--- a/crates/processing_pyo3/src/lib.rs
+++ b/crates/processing_pyo3/src/lib.rs
@@ -1830,6 +1830,27 @@ mod mewnala {
         graphics!(module).emissive(args)
     }
 
+    #[pyfunction]
+    #[pyo3(pass_module)]
+    fn texture(module: &Bound<'_, PyModule>, source: graphics::ImageRef) -> PyResult<()> {
+        graphics!(module).texture(source)
+    }
+
+    #[pyfunction]
+    #[pyo3(pass_module)]
+    fn no_texture(module: &Bound<'_, PyModule>) -> PyResult<()> {
+        graphics!(module).no_texture()
+    }
+
+    #[pyfunction]
+    #[pyo3(pass_module)]
+    fn texture_transform(
+        module: &Bound<'_, PyModule>,
+        transform: crate::math::PyAffine2,
+    ) -> PyResult<()> {
+        graphics!(module).texture_transform(transform)
+    }
+
     #[pyfunction]
     #[pyo3(pass_module)]
     fn unlit(module: &Bound<'_, PyModule>) -> PyResult<()> {
diff --git a/crates/processing_render/src/render/command.rs b/crates/processing_render/src/render/command.rs
index d514982b..7efecf56 100644
--- a/crates/processing_render/src/render/command.rs
+++ b/crates/processing_render/src/render/command.rs
@@ -1,3 +1,4 @@
+use bevy::math::Affine2;
 use bevy::math::Affine3A;
 use bevy::prelude::*;
 use bevy::render::render_resource::{BlendComponent, BlendFactor, BlendOperation, BlendState};
@@ -515,6 +516,9 @@ pub enum DrawCommand {
     Roughness(f32),
     Metallic(f32),
     Emissive(Color),
+    Texture(Entity),
+    NoTexture,
+    TextureTransform(Affine2),
     Unlit,
     Tint(Color),
     NoTint,
diff --git a/crates/processing_render/src/render/mod.rs b/crates/processing_render/src/render/mod.rs
index 685f6f80..36561130 100644
--- a/crates/processing_render/src/render/mod.rs
+++ b/crates/processing_render/src/render/mod.rs
@@ -222,6 +222,25 @@ pub fn flush_draw_commands(
                     pbr.blend_state = None;
                     state.style.material_key = pbr.into();
                 }
+                DrawCommand::Texture(entity) => {
+                    if let Ok(img) = p_images.get(entity) {
+                        let mut pbr = state.style.material_key.as_pbr();
+                        pbr.base_color_texture = Some(img.handle.clone());
+                        state.style.material_key = pbr.into();
+                    }
+                }
+                DrawCommand::NoTexture => {
+                    if let MaterialKey::Pbr { .. } = &state.style.material_key {
+                        let mut pbr = state.style.material_key.as_pbr();
+                        pbr.base_color_texture = None;
+                        state.style.material_key = pbr.into();
+                    }
+                }
+                DrawCommand::TextureTransform(transform) => {
+                    let mut pbr = state.style.material_key.as_pbr();
+                    pbr.uv_transform = transform;
+                    state.style.material_key = pbr.into();
+                }
                 DrawCommand::Unlit => {
                     state.style.material_key = MaterialKey::Color {
                         transparent: state.fill_is_transparent(),

From 3772abe5abf752fa8a953175633c0478b6e97bda Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Wed, 29 Apr 2026 12:10:48 -0700
Subject: [PATCH 08/14] More video.

---
 crates/processing_pyo3/examples/video.py | 47 +++++++++++++++++-------
 crates/processing_pyo3/src/graphics.rs   |  9 +++++
 crates/processing_pyo3/src/lib.rs        |  8 +---
 crates/processing_pyo3/src/video.rs      | 14 +++----
 crates/processing_pyo3/src/webcam.rs     | 14 +++----
 crates/processing_render/src/image.rs    |  8 ++++
 crates/processing_video/src/lib.rs       |  5 +++
 crates/processing_webcam/src/lib.rs      |  5 +++
 8 files changed, 74 insertions(+), 36 deletions(-)

diff --git a/crates/processing_pyo3/examples/video.py b/crates/processing_pyo3/examples/video.py
index ed68b3d3..56ffd053 100644
--- a/crates/processing_pyo3/examples/video.py
+++ b/crates/processing_pyo3/examples/video.py
@@ -1,20 +1,41 @@
 from mewnala import *
+from mewnala.math import *
+
+angle = 0.0
 
 def setup():
-    global vid, img, paused
-    size(640, 480)
-    vid = create_video("video/file_example_MP4_640_3MG.mp4", looping=True)
-    img = None
+    global vid, paused
+    size(600, 600)
+    mode_3d()
+
+    create_directional_light((1.0, 0.98, 0.95), 1500.0)
+
+    vid = create_video("video/file_example_MP4_640_3MG.mp4")
+    vid.loop()
     paused = False
 
 
 def draw():
-    global img
-    if img is None and vid.is_loaded():
-        img = vid.image()
-
-    if img is not None:
-        background(img)
+    global angle
+    camera_position(0.0, 100.0, 300.0)
+    camera_look_at(0.0, 0.0, 0.0)
+    background(30)
+    stroke(255)
+    stroke_weight(2)
+
+    if vid.is_loaded():
+        texture(vid)
+        texture_transform(Affine2.from_scale_angle_translation(
+            Vec2(0.75, 1.0), 0.0, Vec2(0.125, 0.0)
+        ))
+        push_matrix()
+        rotate_x(0.3)
+        rotate_y(angle)
+        box(100.0, 100.0, 100.0)
+        pop_matrix()
+        no_texture()
+
+    angle += 0.0009
 
 
 def key_pressed():
@@ -24,15 +45,15 @@ def key_pressed():
         if paused:
             vid.pause()
         else:
-            vid.resume()
+            vid.play()
     elif key_code == RIGHT_ARROW:
         vid.seek(vid.position() + 1.0)
     elif key_code == LEFT_ARROW:
         vid.seek(max(0.0, vid.position() - 1.0))
     elif key_code == UP:
-        vid.set_speed(2.0)
+        vid.speed(2.0)
     elif key_code == DOWN:
-        vid.set_speed(1.0)
+        vid.speed(1.0)
 
 
 run()
diff --git a/crates/processing_pyo3/src/graphics.rs b/crates/processing_pyo3/src/graphics.rs
index 118285a4..35635732 100644
--- a/crates/processing_pyo3/src/graphics.rs
+++ b/crates/processing_pyo3/src/graphics.rs
@@ -1096,6 +1096,15 @@ impl Graphics {
 
     #[pyo3(signature = (*args))]
     pub fn background(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        if let Ok(first) = args.get_item(0) {
+            if let Ok(img_ref) = first.extract::<ImageRef>() {
+                return graphics_record_command(
+                    self.entity,
+                    DrawCommand::BackgroundImage(img_ref.entity),
+                )
+                .map_err(|e| PyRuntimeError::new_err(format!("{e}")));
+            }
+        }
         let color = extract_color_with_mode(
             args,
             &graphics_get_color_mode(self.entity)
diff --git a/crates/processing_pyo3/src/lib.rs b/crates/processing_pyo3/src/lib.rs
index 54cf4ad6..450a2539 100644
--- a/crates/processing_pyo3/src/lib.rs
+++ b/crates/processing_pyo3/src/lib.rs
@@ -1207,13 +1207,7 @@ mod mewnala {
     #[pyfunction]
     #[pyo3(pass_module, signature = (*args))]
     fn background(module: &Bound<'_, PyModule>, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let graphics = graphics!(module);
-        let first = args.get_item(0)?;
-        if first.is_instance_of::<Image>() {
-            graphics.background_image(&*first.extract::<PyRef<Image>>()?)
-        } else {
-            graphics.background(args)
-        }
+        graphics!(module).background(args)
     }
 
     #[pyfunction]
diff --git a/crates/processing_pyo3/src/video.rs b/crates/processing_pyo3/src/video.rs
index 8f0e76db..c55d962d 100644
--- a/crates/processing_pyo3/src/video.rs
+++ b/crates/processing_pyo3/src/video.rs
@@ -6,13 +6,17 @@ use processing_video::{
 };
 use pyo3::{exceptions::PyRuntimeError, prelude::*};
 
-use crate::graphics::Image;
-
 #[pyclass(unsendable)]
 pub struct Video {
     entity: Entity,
 }
 
+impl Video {
+    pub(crate) fn image_entity(&self) -> PyResult<Entity> {
+        video_image(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+}
+
 #[pymethods]
 impl Video {
     #[new]
@@ -30,12 +34,6 @@ impl Video {
         video_resolution(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn image(&self) -> PyResult<Image> {
-        let entity =
-            video_image(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        Ok(Image::from_entity(entity))
-    }
-
     pub fn position(&self) -> PyResult<f64> {
         video_position(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
diff --git a/crates/processing_pyo3/src/webcam.rs b/crates/processing_pyo3/src/webcam.rs
index 3cc06ba7..f60fca1f 100644
--- a/crates/processing_pyo3/src/webcam.rs
+++ b/crates/processing_pyo3/src/webcam.rs
@@ -5,13 +5,17 @@ use processing_webcam::{
 };
 use pyo3::{exceptions::PyRuntimeError, prelude::*};
 
-use crate::graphics::Image;
-
 #[pyclass(unsendable)]
 pub struct Webcam {
     entity: Entity,
 }
 
+impl Webcam {
+    pub(crate) fn image_entity(&self) -> PyResult<Entity> {
+        webcam_image(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+}
+
 #[pymethods]
 impl Webcam {
     #[new]
@@ -40,12 +44,6 @@ impl Webcam {
     pub fn resolution(&self) -> PyResult<(u32, u32)> {
         webcam_resolution(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
-
-    pub fn image(&self) -> PyResult<Image> {
-        let entity =
-            webcam_image(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        Ok(Image::from_entity(entity))
-    }
 }
 
 impl Drop for Webcam {
diff --git a/crates/processing_render/src/image.rs b/crates/processing_render/src/image.rs
index e7a4fcd7..4945b3b5 100644
--- a/crates/processing_render/src/image.rs
+++ b/crates/processing_render/src/image.rs
@@ -100,6 +100,14 @@ pub fn blit(
     Ok(())
 }
 
+#[derive(Component)]
+#[relationship(relationship_target = LinkedImageTarget)]
+pub struct LinkedImage(pub Entity);
+
+#[derive(Component)]
+#[relationship_target(relationship = LinkedImage)]
+pub struct LinkedImageTarget(Entity);
+
 #[derive(Component)]
 pub struct Image {
     pub handle: Handle<bevy::image::Image>,
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
index 0ea8e291..5e6dd542 100644
--- a/crates/processing_video/src/lib.rs
+++ b/crates/processing_video/src/lib.rs
@@ -32,6 +32,10 @@ fn create_with_mode(
 }
 
 fn create_image(In(entity): In<Entity>, world: &mut World) -> Result<Entity> {
+    if let Some(linked) = world.get::<image::LinkedImage>(entity) {
+        return Ok(linked.0);
+    }
+
     let output = world
         .get::<VideoOutput>(entity)
         .ok_or(ProcessingError::VideoNotLoaded)?;
@@ -40,6 +44,7 @@ fn create_image(In(entity): In<Entity>, world: &mut World) -> Result<Entity> {
     let child = world
         .run_system_once_with(image::from_handle, handle)
         .unwrap()?;
+    world.entity_mut(entity).insert(image::LinkedImage(child));
     world.entity_mut(entity).add_child(child);
     Ok(child)
 }
diff --git a/crates/processing_webcam/src/lib.rs b/crates/processing_webcam/src/lib.rs
index 7b66dfcc..04166aec 100644
--- a/crates/processing_webcam/src/lib.rs
+++ b/crates/processing_webcam/src/lib.rs
@@ -31,6 +31,10 @@ fn create_with_format(In(format): In<WebcamFormat>, mut commands: Commands) -> E
 }
 
 fn create_image(In(entity): In<Entity>, world: &mut World) -> Result<Entity> {
+    if let Some(linked) = world.get::<image::LinkedImage>(entity) {
+        return Ok(linked.0);
+    }
+
     let stream = world
         .get::<WebcamStream>(entity)
         .ok_or(ProcessingError::WebcamNotConnected)?;
@@ -39,6 +43,7 @@ fn create_image(In(entity): In<Entity>, world: &mut World) -> Result<Entity> {
     let child = world
         .run_system_once_with(image::from_handle, handle)
         .unwrap()?;
+    world.entity_mut(entity).insert(image::LinkedImage(child));
     world.entity_mut(entity).add_child(child);
     Ok(child)
 }

From afcd53c85160756ecd00ef07eea9bafc44c2be66 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Sun, 16 Aug 2026 01:08:05 -0700
Subject: [PATCH 09/14] .

---
 Cargo.lock                                    | 247 +++++++++++--
 crates/processing_pyo3/src/graphics.rs        |  51 ++-
 crates/processing_pyo3/src/lib.rs             |  36 ++
 crates/processing_pyo3/src/record.rs          | 134 +++++++
 crates/processing_video/Cargo.toml            |   5 +
 .../processing_video/examples/record_demo.rs  |  43 +++
 crates/processing_video/src/lib.rs            |   3 +
 crates/processing_video/src/record.rs         | 330 ++++++++++++++++++
 crates/processing_video/tests/record.rs       |  98 ++++++
 examples/combine_mix_test.rs                  |  18 +-
 examples/field_falloff_test.rs                |  10 +-
 examples/flock_grid_test.rs                   |  16 +-
 examples/glue_test.rs                         |  11 +-
 examples/grid_test.rs                         |  11 +-
 examples/group_compact_test.rs                |  10 +-
 examples/lookup_test.rs                       |  12 +-
 examples/map_test.rs                          |  16 +-
 examples/reduce_test.rs                       |  10 +-
 examples/scan_test.rs                         |  13 +-
 examples/sort_test.rs                         |  10 +-
 20 files changed, 901 insertions(+), 183 deletions(-)
 create mode 100644 crates/processing_pyo3/src/record.rs
 create mode 100644 crates/processing_video/examples/record_demo.rs
 create mode 100644 crates/processing_video/src/record.rs
 create mode 100644 crates/processing_video/tests/record.rs

diff --git a/Cargo.lock b/Cargo.lock
index c1bf6e52..c81682f7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -762,7 +762,7 @@ dependencies = [
  "serde",
  "smallvec",
  "thiserror 2.0.20",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -808,7 +808,7 @@ dependencies = [
  "encase",
  "serde",
  "thiserror 2.0.20",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1101,14 +1101,14 @@ dependencies = [
  "bevy_world_serialization",
  "fixedbitset",
  "gltf",
- "itertools",
+ "itertools 0.14.0",
  "percent-encoding",
  "serde",
  "serde_json",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1136,7 +1136,7 @@ dependencies = [
  "serde",
  "thiserror 2.0.20",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1252,7 +1252,7 @@ dependencies = [
  "half",
  "smallvec",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1314,7 +1314,7 @@ dependencies = [
  "thiserror 2.0.20",
  "tracing",
  "variadics_please",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1337,7 +1337,7 @@ dependencies = [
  "bevy_reflect",
  "derive_more",
  "glam 0.32.1",
- "itertools",
+ "itertools 0.14.0",
  "libm",
  "rand 0.10.2",
  "rand_distr",
@@ -1370,7 +1370,7 @@ dependencies = [
  "hexasphere",
  "thiserror 2.0.20",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1427,7 +1427,7 @@ dependencies = [
  "static_assertions",
  "thiserror 2.0.20",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1528,7 +1528,7 @@ dependencies = [
  "thiserror 2.0.20",
  "uuid",
  "variadics_please",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1581,7 +1581,7 @@ dependencies = [
  "glam 0.32.1",
  "image",
  "indexmap",
- "itertools",
+ "itertools 0.14.0",
  "js-sys",
  "naga",
  "nonmax",
@@ -1594,7 +1594,7 @@ dependencies = [
  "weak-table",
  "web-sys",
  "wgpu",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1693,7 +1693,7 @@ dependencies = [
  "tracing",
  "wesl",
  "wgpu-naga-bridge",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1718,7 +1718,7 @@ dependencies = [
  "bevy_window",
  "radsort",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -1821,7 +1821,7 @@ dependencies = [
  "sys-locale",
  "thiserror 2.0.20",
  "tracing",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -2004,7 +2004,7 @@ dependencies = [
  "tracing",
  "wasm-bindgen",
  "web-sys",
- "wgpu-types",
+ "wgpu-types 29.0.4",
  "winit",
 ]
 
@@ -2046,12 +2046,30 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex 1.3.0",
  "syn 2.0.119",
  "which",
 ]
 
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags 2.13.1",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash 2.1.3",
+ "shlex 1.3.0",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.8.0"
@@ -3144,6 +3162,31 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "ffmpeg-next"
+version = "8.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c4bd5ab1ac61f29c634df1175d350ded29cf74c3c6d4f7030431a5ae3c7d5d"
+dependencies = [
+ "bitflags 2.13.1",
+ "ffmpeg-sys-next",
+ "libc",
+]
+
+[[package]]
+name = "ffmpeg-sys-next"
+version = "8.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a314bc0e022a33a99567ed4bd2576bd58ffd8fcff7891c29194cfecc26a62547"
+dependencies = [
+ "bindgen 0.72.1",
+ "cc",
+ "libc",
+ "num_cpus",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "file-id"
 version = "0.2.3"
@@ -3477,6 +3520,15 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
 
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
 [[package]]
 name = "fsevent-sys"
 version = "4.1.0"
@@ -3740,6 +3792,16 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
 
+[[package]]
+name = "gloo-events"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27c26fb45f7c385ba980f5fa87ac677e363949e065a083722697ef1b2cc91e41"
+dependencies = [
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "glow"
 version = "0.17.0"
@@ -4126,6 +4188,27 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"
 
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
 [[package]]
 name = "image"
 version = "0.25.10"
@@ -4230,6 +4313,15 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itertools"
 version = "0.14.0"
@@ -4430,7 +4522,7 @@ dependencies = [
  "ascii-canvas",
  "bit-set 0.8.0",
  "ena",
- "itertools",
+ "itertools 0.14.0",
  "lalrpop-util",
  "petgraph 0.7.1",
  "regex",
@@ -4927,7 +5019,7 @@ dependencies = [
  "num-traits",
  "once_cell",
  "pp-rs",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "serde",
  "spirv",
  "thiserror 2.0.20",
@@ -4945,7 +5037,7 @@ dependencies = [
  "indexmap",
  "naga",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "thiserror 2.0.20",
  "tracing",
  "unicode-ident",
@@ -4961,6 +5053,24 @@ dependencies = [
  "midir",
 ]
 
+[[package]]
+name = "nannou_video"
+version = "0.1.0"
+source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f713c439c03b4e4614c2ef8ff899932efd0a1c44"
+dependencies = [
+ "bevy",
+ "flume",
+ "gloo-events",
+ "js-sys",
+ "serde",
+ "tempfile",
+ "thiserror 2.0.20",
+ "video-rs",
+ "wasm-bindgen",
+ "web-sys",
+ "wgpu-types 28.0.0",
+]
+
 [[package]]
 name = "nannou_webcam"
 version = "0.1.0"
@@ -5274,6 +5384,16 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
 [[package]]
 name = "num_enum"
 version = "0.7.6"
@@ -6123,6 +6243,7 @@ dependencies = [
  "processing_input",
  "processing_midi",
  "processing_render",
+ "processing_video",
  "processing_webcam",
  "rand 0.10.2",
  "tracing",
@@ -6208,6 +6329,7 @@ dependencies = [
  "processing_cuda",
  "processing_glfw",
  "processing_render",
+ "processing_video",
  "processing_webcam",
  "pyo3",
  "rand 0.10.2",
@@ -6241,6 +6363,19 @@ dependencies = [
  "windows 0.58.0",
 ]
 
+[[package]]
+name = "processing_video"
+version = "0.0.1"
+dependencies = [
+ "bevy",
+ "nannou_video",
+ "processing_core",
+ "processing_render",
+ "tempfile",
+ "thiserror 2.0.20",
+ "video-rs",
+]
+
 [[package]]
 name = "processing_wasm"
 version = "0.0.5"
@@ -6508,7 +6643,7 @@ dependencies = [
  "built",
  "cfg-if 1.0.4",
  "interpolate_name",
- "itertools",
+ "itertools 0.14.0",
  "libc",
  "libfuzzer-sys",
  "log",
@@ -6823,6 +6958,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -7817,6 +7958,18 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -7858,7 +8011,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6779878362b9bacadc7893eac76abe69612e8837ef746573c4a5239daf11990b"
 dependencies = [
- "bindgen",
+ "bindgen 0.65.1",
 ]
 
 [[package]]
@@ -7889,6 +8042,12 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -7901,6 +8060,17 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "video-rs"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2633ec4c2a8aeb7c0e970f75ba99122a75841e9f7b34d5225366d0e61a870a8c"
+dependencies = [
+ "ffmpeg-next",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "visibility"
 version = "0.1.1"
@@ -8154,7 +8324,7 @@ dependencies = [
  "annotate-snippets",
  "derive_more",
  "half",
- "itertools",
+ "itertools 0.14.0",
  "num-traits",
  "proc-macro2",
  "quote",
@@ -8170,7 +8340,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d321ea9e1cc0a2e3de41c02e3a7586695a9c03beccb5460e938a7ccf00cb612"
 dependencies = [
- "itertools",
+ "itertools 0.14.0",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -8203,7 +8373,7 @@ dependencies = [
  "web-sys",
  "wgpu-core",
  "wgpu-hal",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -8228,7 +8398,7 @@ dependencies = [
  "portable-atomic",
  "profiling",
  "raw-window-handle",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "smallvec",
  "thiserror 2.0.20",
  "wgpu-core-deps-apple",
@@ -8237,7 +8407,7 @@ dependencies = [
  "wgpu-core-deps-windows-linux-android",
  "wgpu-hal",
  "wgpu-naga-bridge",
- "wgpu-types",
+ "wgpu-types 29.0.4",
 ]
 
 [[package]]
@@ -8324,7 +8494,7 @@ dependencies = [
  "wayland-sys",
  "web-sys",
  "wgpu-naga-bridge",
- "wgpu-types",
+ "wgpu-types 29.0.4",
  "windows 0.62.2",
  "windows-core 0.62.2",
  "windows-result 0.4.1",
@@ -8337,7 +8507,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95226013f547544b223281cd16a4fb549aa9dcb562adbda0faae4c73ffbbc161"
 dependencies = [
  "naga",
- "wgpu-types",
+ "wgpu-types 29.0.4",
+]
+
+[[package]]
+name = "wgpu-types"
+version = "28.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e18308757e594ed2cd27dddbb16a139c42a683819d32a2e0b1b0167552f5840c"
+dependencies = [
+ "bitflags 2.13.1",
+ "bytemuck",
+ "js-sys",
+ "log",
+ "web-sys",
 ]
 
 [[package]]
@@ -8363,7 +8546,7 @@ checksum = "946419efa46664a8070c512fb358ac4acfc6e6215c2396ae5afeb9b72dd6ca7d"
 dependencies = [
  "annotate-snippets",
  "derive_more",
- "itertools",
+ "itertools 0.14.0",
  "lalrpop",
  "lalrpop-util",
  "lexical",
@@ -8379,7 +8562,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7aed068ca1dc8fb182f574c9f2ace45ec988c71ba050f6dd334883fe3b8a88e2"
 dependencies = [
  "half",
- "itertools",
+ "itertools 0.14.0",
  "num-traits",
 ]
 
diff --git a/crates/processing_pyo3/src/graphics.rs b/crates/processing_pyo3/src/graphics.rs
index 35635732..beaf22b7 100644
--- a/crates/processing_pyo3/src/graphics.rs
+++ b/crates/processing_pyo3/src/graphics.rs
@@ -151,6 +151,23 @@ fn composite_apply(
     graphics_apply_filter(dst, filter).map_err(rt_err)
 }
 
+/// Read a graphics canvas back as sRGB-encoded RGBA8 bytes plus pixel dimensions.
+pub(crate) fn readback_rgba8(entity: Entity) -> PyResult<(Vec<u8>, u32, u32)> {
+    let raw = graphics_readback_raw(entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+    let rgba = match raw.format {
+        TextureFormat::Rgba8UnormSrgb => raw.bytes,
+        _ => {
+            let pixels =
+                graphics_readback(entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+            pixels
+                .iter()
+                .flat_map(|pixel| Srgba::from(*pixel).to_u8_array())
+                .collect()
+        }
+    };
+    Ok((rgba, raw.width, raw.height))
+}
+
 /// Write raw sRGB RGBA bytes to a PNG file on disk.
 fn write_png_file(path: &str, width: u32, height: u32, rgba: &[u8]) -> PyResult<()> {
     let lower = path.to_lowercase();
@@ -947,25 +964,11 @@ impl Graphics {
     }
 
     pub fn readback_png(&self) -> PyResult<Vec<u8>> {
-        let raw = graphics_readback_raw(self.entity)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-
-        // png-ify our raw data, for srgb formats we're already good
-        let rgba_bytes = match raw.format {
-            TextureFormat::Rgba8UnormSrgb => raw.bytes,
-            _ => {
-                let pixels = graphics_readback(self.entity)
-                    .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-                pixels
-                    .iter()
-                    .flat_map(|pixel| Srgba::from(*pixel).to_u8_array())
-                    .collect()
-            }
-        };
+        let (rgba_bytes, width, height) = readback_rgba8(self.entity)?;
 
         let mut png_buf: Vec<u8> = Vec::new();
         {
-            let mut encoder = png::Encoder::new(&mut png_buf, raw.width, raw.height);
+            let mut encoder = png::Encoder::new(&mut png_buf, width, height);
             // todo: infer these from the texture format instead of hardcoding
             encoder.set_color(png::ColorType::Rgba);
             encoder.set_depth(png::BitDepth::Eight);
@@ -983,20 +986,8 @@ impl Graphics {
 
     /// Save the current canvas to a PNG file (Processing `save`).
     pub fn save(&self, filename: &str) -> PyResult<()> {
-        let raw = graphics_readback_raw(self.entity)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-        let rgba = match raw.format {
-            TextureFormat::Rgba8UnormSrgb => raw.bytes,
-            _ => {
-                let pixels = graphics_readback(self.entity)
-                    .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-                pixels
-                    .iter()
-                    .flat_map(|pixel| Srgba::from(*pixel).to_u8_array())
-                    .collect()
-            }
-        };
-        write_png_file(filename, raw.width, raw.height, &rgba)
+        let (rgba, width, height) = readback_rgba8(self.entity)?;
+        write_png_file(filename, width, height, &rgba)
     }
 
     /// Read a single pixel as a `Color` (Processing `get`).
diff --git a/crates/processing_pyo3/src/lib.rs b/crates/processing_pyo3/src/lib.rs
index 450a2539..cc0608e9 100644
--- a/crates/processing_pyo3/src/lib.rs
+++ b/crates/processing_pyo3/src/lib.rs
@@ -23,6 +23,8 @@ pub(crate) mod math;
 mod midi;
 mod monitor;
 pub(crate) mod particles;
+#[cfg(feature = "video")]
+mod record;
 pub(crate) mod shader;
 mod surface;
 mod time;
@@ -968,12 +970,23 @@ mod mewnala {
                     wg.bind(py).borrow().end_draw()?;
                 }
 
+                #[cfg(feature = "video")]
+                {
+                    let entity = get_graphics(module)?
+                        .ok_or_else(|| PyRuntimeError::new_err("call size() first"))?
+                        .entity;
+                    record::capture(entity)?;
+                }
+
                 update_loop_state(|s| s.redraw_requested = false);
             }
 
             Ok(())
         });
 
+        #[cfg(feature = "video")]
+        record::finish_on_exit();
+
         // tear down the app while the thread-local is still alive; the eager
         // TLS destructor aborts inside a Bevy resource drop
         let _ = ::processing::exit(0);
@@ -2254,6 +2267,29 @@ mod mewnala {
         video::Video::new(path)
     }
 
+    /// Start recording the canvas to a video file (Processing `beginRecord`).
+    /// Frames are timestamped at `1 / fps` regardless of render time.
+    /// `crf`: 0 (lossless) to 51, default 23. `preset`: x264 speed/size
+    /// trade-off, `"ultrafast"` .. `"veryslow"`.
+    #[cfg(feature = "video")]
+    #[pyfunction]
+    #[pyo3(signature = (filename, fps=60.0, crf=None, preset=None))]
+    fn begin_record(
+        filename: &str,
+        fps: f64,
+        crf: Option<u8>,
+        preset: Option<String>,
+    ) -> PyResult<()> {
+        record::begin(filename, fps, crf, preset)
+    }
+
+    /// Stop recording, finalize the video file, and return the frame count.
+    #[cfg(feature = "video")]
+    #[pyfunction]
+    fn end_record() -> PyResult<u64> {
+        record::end()
+    }
+
     #[cfg(feature = "webcam")]
     #[pyfunction]
     #[pyo3(signature = (width=None, height=None, framerate=None))]
diff --git a/crates/processing_pyo3/src/record.rs b/crates/processing_pyo3/src/record.rs
new file mode 100644
index 00000000..918d72be
--- /dev/null
+++ b/crates/processing_pyo3/src/record.rs
@@ -0,0 +1,134 @@
+//! `begin_record` / `end_record`: capture drawn frames into a video file.
+
+use std::cell::RefCell;
+
+use bevy::prelude::Entity;
+use processing_video::{VideoRecorder, VideoRecorderConfig};
+use pyo3::exceptions::{PyRuntimeError, PyValueError};
+use pyo3::prelude::*;
+
+const X264_PRESETS: [&str; 10] = [
+    "ultrafast",
+    "superfast",
+    "veryfast",
+    "faster",
+    "fast",
+    "medium",
+    "slow",
+    "slower",
+    "veryslow",
+    "placebo",
+];
+
+enum RecState {
+    /// The recorder is created on the first captured frame so its dimensions
+    /// match the actual readback.
+    Pending {
+        path: String,
+        fps: f64,
+        crf: Option<u8>,
+        preset: Option<String>,
+    },
+    Active(VideoRecorder),
+}
+
+thread_local! {
+    static RECORDER: RefCell<Option<RecState>> = const { RefCell::new(None) };
+}
+
+pub(crate) fn begin(path: &str, fps: f64, crf: Option<u8>, preset: Option<String>) -> PyResult<()> {
+    RECORDER.with(|r| {
+        let mut slot = r.borrow_mut();
+        if slot.is_some() {
+            return Err(PyRuntimeError::new_err(
+                "already recording; call end_record() first",
+            ));
+        }
+        if !(fps.is_finite() && fps > 0.0 && fps <= 1_000_000.0) {
+            return Err(PyValueError::new_err(format!(
+                "fps must be a positive number no greater than 1000000, got {fps}"
+            )));
+        }
+        if let Some(crf) = crf
+            && crf > 51
+        {
+            return Err(PyValueError::new_err(format!(
+                "crf must be between 0 (lossless) and 51 (worst quality), got {crf}"
+            )));
+        }
+        if let Some(ref preset) = preset
+            && !X264_PRESETS.contains(&preset.as_str())
+        {
+            return Err(PyValueError::new_err(format!(
+                "unknown preset {preset:?}; expected one of {X264_PRESETS:?}"
+            )));
+        }
+        *slot = Some(RecState::Pending {
+            path: path.to_string(),
+            fps,
+            crf,
+            preset,
+        });
+        Ok(())
+    })
+}
+
+pub(crate) fn capture(entity: Entity) -> PyResult<()> {
+    RECORDER.with(|r| {
+        let mut slot = r.borrow_mut();
+        let Some(state) = slot.as_mut() else {
+            return Ok(());
+        };
+        let result = (|| {
+            let (rgba, width, height) = crate::graphics::readback_rgba8(entity)?;
+            if let RecState::Pending {
+                path,
+                fps,
+                crf,
+                preset,
+            } = state
+            {
+                let mut config = VideoRecorderConfig::new(width, height, *fps);
+                config.crf = *crf;
+                config.preset = preset.clone();
+                let recorder = VideoRecorder::new(&*path, config)
+                    .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+                *state = RecState::Active(recorder);
+            }
+            let RecState::Active(recorder) = state else {
+                unreachable!("state was just made Active");
+            };
+            recorder
+                .record_frame(rgba)
+                .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+        })();
+        if result.is_err() {
+            *slot = None;
+        }
+        result
+    })
+}
+
+/// Finish the recording and return the number of frames encoded.
+pub(crate) fn end() -> PyResult<u64> {
+    RECORDER.with(|r| match r.borrow_mut().take() {
+        None => Err(PyRuntimeError::new_err(
+            "not recording; call begin_record() first",
+        )),
+        Some(RecState::Pending { .. }) => Err(PyRuntimeError::new_err(
+            "no frames were drawn between begin_record() and end_record()",
+        )),
+        Some(RecState::Active(recorder)) => recorder
+            .finish()
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}"))),
+    })
+}
+
+/// Closing the window mid-recording still leaves a playable file.
+pub(crate) fn finish_on_exit() {
+    RECORDER.with(|r| {
+        if let Some(RecState::Active(recorder)) = r.borrow_mut().take() {
+            let _ = recorder.finish();
+        }
+    });
+}
diff --git a/crates/processing_video/Cargo.toml b/crates/processing_video/Cargo.toml
index 401d9f2a..3a6f0fbe 100644
--- a/crates/processing_video/Cargo.toml
+++ b/crates/processing_video/Cargo.toml
@@ -11,3 +11,8 @@ bevy = { workspace = true }
 nannou_video = { git = "https://github.com/nannou-org/nannou", branch = "bevy-refactor" }
 processing_core = { workspace = true }
 processing_render = { workspace = true }
+thiserror = "2"
+video-rs = "0.11"
+
+[dev-dependencies]
+tempfile = "3"
diff --git a/crates/processing_video/examples/record_demo.rs b/crates/processing_video/examples/record_demo.rs
new file mode 100644
index 00000000..643e959a
--- /dev/null
+++ b/crates/processing_video/examples/record_demo.rs
@@ -0,0 +1,43 @@
+//! Renders an animated plasma pattern to a video file.
+//!
+//! cargo run -p processing_video --example record_demo -- out.mp4
+
+use processing_video::{VideoRecorder, VideoRecorderConfig};
+
+const WIDTH: u32 = 640;
+const HEIGHT: u32 = 360;
+const FPS: f64 = 30.0;
+const SECONDS: f64 = 6.0;
+
+fn main() {
+    let path = std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| "record_demo.mp4".to_string());
+
+    let config = VideoRecorderConfig::new(WIDTH, HEIGHT, FPS);
+    let mut recorder = VideoRecorder::new(&path, config).expect("create recorder");
+
+    let frames = (SECONDS * FPS) as u64;
+    let mut pixels = vec![0u8; (WIDTH * HEIGHT * 4) as usize];
+    for i in 0..frames {
+        let t = i as f32 / FPS as f32;
+        for y in 0..HEIGHT {
+            for x in 0..WIDTH {
+                let (fx, fy) = (x as f32, y as f32);
+                let v = (fx / 32.0 + t).sin()
+                    + (fy / 24.0 - t * 1.3).sin()
+                    + ((fx + fy) / 48.0 + t * 0.7).sin()
+                    + ((fx * fx + fy * fy).sqrt() / 24.0 - t * 2.0).sin();
+                let p = &mut pixels[((y * WIDTH + x) * 4) as usize..][..4];
+                p[0] = ((v * std::f32::consts::PI).sin() * 127.0 + 128.0) as u8;
+                p[1] = ((v * std::f32::consts::PI + 2.0).sin() * 127.0 + 128.0) as u8;
+                p[2] = ((v * std::f32::consts::PI + 4.0).sin() * 127.0 + 128.0) as u8;
+                p[3] = 255;
+            }
+        }
+        recorder.record_frame(pixels.clone()).expect("record frame");
+    }
+
+    let encoded = recorder.finish().expect("finish");
+    println!("wrote {encoded} frames to {path}");
+}
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
index 5e6dd542..967ea238 100644
--- a/crates/processing_video/src/lib.rs
+++ b/crates/processing_video/src/lib.rs
@@ -9,6 +9,9 @@ pub use nannou_video::{
     VideoOutput, VideoPlayer, VideoResize, VideoSeeked, VideoSource,
 };
 
+mod record;
+pub use record::{RecorderPixelFormat, VideoRecordError, VideoRecorder, VideoRecorderConfig};
+
 use processing_core::app_mut;
 use processing_core::error::{ProcessingError, Result};
 use processing_render::image;
diff --git a/crates/processing_video/src/record.rs b/crates/processing_video/src/record.rs
new file mode 100644
index 00000000..6d25d717
--- /dev/null
+++ b/crates/processing_video/src/record.rs
@@ -0,0 +1,330 @@
+//! Offline video recording. Frame timestamps come from the frame index and
+//! configured fps, never wall-clock time.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::Once;
+use std::sync::mpsc::{Receiver, SyncSender, sync_channel};
+use std::thread;
+
+use video_rs::encode::{Encoder, Settings};
+use video_rs::frame::{PixelFormat, RawFrame};
+use video_rs::time::Time;
+
+/// Pixel layout of the frames passed to [`VideoRecorder::record_frame`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RecorderPixelFormat {
+    /// 4 bytes per pixel, `[r, g, b, a]`. Alpha is discarded.
+    Rgba8,
+    /// 4 bytes per pixel, `[b, g, r, a]`. Alpha is discarded.
+    Bgra8,
+    /// 3 bytes per pixel, `[r, g, b]`.
+    Rgb8,
+}
+
+impl RecorderPixelFormat {
+    pub fn bytes_per_pixel(self) -> usize {
+        match self {
+            RecorderPixelFormat::Rgba8 | RecorderPixelFormat::Bgra8 => 4,
+            RecorderPixelFormat::Rgb8 => 3,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct VideoRecorderConfig {
+    pub width: u32,
+    pub height: u32,
+    pub fps: f64,
+    pub pixel_format: RecorderPixelFormat,
+    /// Use the encoder's realtime preset (faster encode, larger output).
+    pub realtime: bool,
+    /// Keyframe interval in frames. `None` uses the encoder default.
+    pub keyframe_interval: Option<u64>,
+    /// Constant Rate Factor, 0 (lossless) to 51 (worst quality). `None` uses
+    /// x264's default of 23; ~18 is visually lossless.
+    pub crf: Option<u8>,
+    /// x264 speed/compression preset (`ultrafast` .. `veryslow`). Slower
+    /// presets compress better at the same quality. `None` uses `medium`.
+    pub preset: Option<String>,
+}
+
+impl VideoRecorderConfig {
+    pub fn new(width: u32, height: u32, fps: f64) -> Self {
+        Self {
+            width,
+            height,
+            fps,
+            pixel_format: RecorderPixelFormat::Rgba8,
+            realtime: false,
+            keyframe_interval: None,
+            crf: None,
+            preset: None,
+        }
+    }
+
+    pub fn with_pixel_format(mut self, format: RecorderPixelFormat) -> Self {
+        self.pixel_format = format;
+        self
+    }
+
+    pub fn with_realtime(mut self, realtime: bool) -> Self {
+        self.realtime = realtime;
+        self
+    }
+
+    pub fn with_keyframe_interval(mut self, interval: u64) -> Self {
+        self.keyframe_interval = Some(interval);
+        self
+    }
+
+    pub fn with_crf(mut self, crf: u8) -> Self {
+        self.crf = Some(crf);
+        self
+    }
+
+    pub fn with_preset(mut self, preset: impl Into<String>) -> Self {
+        self.preset = Some(preset.into());
+        self
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum VideoRecordError {
+    #[error("invalid recorder config: {0}")]
+    InvalidConfig(String),
+    #[error("failed to create encoder: {0}")]
+    Create(video_rs::Error),
+    #[error("failed to encode frame {frame}: {source}")]
+    Encode { frame: u64, source: video_rs::Error },
+    #[error("failed to finalize video: {0}")]
+    Finish(video_rs::Error),
+    #[error("frame has {got} bytes but {expected} were expected ({width}x{height} {format:?})")]
+    FrameSize {
+        expected: usize,
+        got: usize,
+        width: u32,
+        height: u32,
+        format: RecorderPixelFormat,
+    },
+    #[error("no frames were recorded; the empty output file was removed")]
+    NoFrames,
+    #[error("encoder thread terminated unexpectedly")]
+    WorkerDied,
+}
+
+/// Encodes pixel frames into a video file (H.264; container chosen by the path
+/// extension). Dropping without [`finish`](Self::finish) finalizes best-effort
+/// and swallows errors.
+pub struct VideoRecorder {
+    frame_tx: Option<SyncSender<Vec<u8>>>,
+    handle: Option<thread::JoinHandle<Result<u64, VideoRecordError>>>,
+    expected_len: usize,
+    config: VideoRecorderConfig,
+    frames_sent: u64,
+}
+
+impl VideoRecorder {
+    pub fn new(
+        path: impl AsRef<Path>,
+        config: VideoRecorderConfig,
+    ) -> Result<Self, VideoRecordError> {
+        if config.width == 0 || config.height == 0 {
+            return Err(VideoRecordError::InvalidConfig(
+                "width and height must be non-zero".to_string(),
+            ));
+        }
+        // 1e6 = the encoder's microsecond timebase; higher fps collapses
+        // consecutive frames onto duplicate timestamps.
+        if !(config.fps.is_finite() && config.fps > 0.0 && config.fps <= 1_000_000.0) {
+            return Err(VideoRecordError::InvalidConfig(format!(
+                "fps must be a positive number no greater than 1000000, got {}",
+                config.fps
+            )));
+        }
+        if let Some(crf) = config.crf
+            && crf > 51
+        {
+            return Err(VideoRecordError::InvalidConfig(format!(
+                "crf must be between 0 (lossless) and 51 (worst), got {crf}"
+            )));
+        }
+
+        static FFMPEG_INIT: Once = Once::new();
+        FFMPEG_INIT.call_once(|| {
+            let _ = video_rs::init();
+        });
+
+        let mut options = HashMap::new();
+        options.insert(
+            "preset".to_string(),
+            config
+                .preset
+                .clone()
+                .unwrap_or_else(|| "medium".to_string()),
+        );
+        if config.realtime {
+            options.insert("tune".to_string(), "zerolatency".to_string());
+        }
+        if let Some(crf) = config.crf {
+            options.insert("crf".to_string(), crf.to_string());
+        }
+        let mut settings = Settings::preset_h264_custom(
+            config.width as usize,
+            config.height as usize,
+            PixelFormat::YUV420P,
+            options.into(),
+        );
+        if let Some(interval) = config.keyframe_interval {
+            settings.set_keyframe_interval(interval);
+        }
+
+        let encoder = Encoder::new(path.as_ref(), settings).map_err(VideoRecordError::Create)?;
+
+        let (frame_tx, frame_rx) = sync_channel(3);
+        let worker_config = config.clone();
+        let dest = path.as_ref().to_path_buf();
+        let handle = thread::Builder::new()
+            .name("processing_video_encode".to_string())
+            .spawn(move || encode_main(encoder, worker_config, frame_rx, dest))
+            .expect("failed to spawn video encoder thread");
+
+        let expected_len =
+            config.width as usize * config.height as usize * config.pixel_format.bytes_per_pixel();
+        Ok(Self {
+            frame_tx: Some(frame_tx),
+            handle: Some(handle),
+            expected_len,
+            config,
+            frames_sent: 0,
+        })
+    }
+
+    /// Queue one frame: tightly packed rows in the configured pixel format,
+    /// top row first. Blocks while the encoder is a few frames behind.
+    pub fn record_frame(&mut self, pixels: Vec<u8>) -> Result<(), VideoRecordError> {
+        if pixels.len() != self.expected_len {
+            return Err(VideoRecordError::FrameSize {
+                expected: self.expected_len,
+                got: pixels.len(),
+                width: self.config.width,
+                height: self.config.height,
+                format: self.config.pixel_format,
+            });
+        }
+        let tx = self.frame_tx.as_ref().ok_or(VideoRecordError::WorkerDied)?;
+        if tx.send(pixels).is_err() {
+            // The worker only exits early on an error; join to surface it.
+            return Err(self
+                .join_worker()
+                .err()
+                .unwrap_or(VideoRecordError::WorkerDied));
+        }
+        self.frames_sent += 1;
+        Ok(())
+    }
+
+    pub fn frames_recorded(&self) -> u64 {
+        self.frames_sent
+    }
+
+    pub fn width(&self) -> u32 {
+        self.config.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.config.height
+    }
+
+    pub fn fps(&self) -> f64 {
+        self.config.fps
+    }
+
+    /// Flush, finalize the container, and return the number of frames encoded.
+    pub fn finish(mut self) -> Result<u64, VideoRecordError> {
+        self.join_worker()
+    }
+
+    fn join_worker(&mut self) -> Result<u64, VideoRecordError> {
+        // Closing the channel signals the worker to flush and finish.
+        drop(self.frame_tx.take());
+        match self.handle.take() {
+            Some(handle) => handle.join().map_err(|_| VideoRecordError::WorkerDied)?,
+            None => Err(VideoRecordError::WorkerDied),
+        }
+    }
+}
+
+impl Drop for VideoRecorder {
+    fn drop(&mut self) {
+        if self.handle.is_some() {
+            let _ = self.join_worker();
+        }
+    }
+}
+
+fn encode_main(
+    mut encoder: Encoder,
+    config: VideoRecorderConfig,
+    frame_rx: Receiver<Vec<u8>>,
+    dest: PathBuf,
+) -> Result<u64, VideoRecordError> {
+    let time_base = encoder.time_base();
+    let mut frame_index: u64 = 0;
+
+    while let Ok(pixels) = frame_rx.recv() {
+        let mut frame = RawFrame::new(PixelFormat::RGB24, config.width, config.height);
+        fill_rgb24(&mut frame, &pixels, &config);
+
+        let pts = Time::from_secs_f64(frame_index as f64 / config.fps)
+            .with_time_base(time_base)
+            .into_value();
+        frame.set_pts(pts);
+
+        encoder
+            .encode_raw(frame)
+            .map_err(|source| VideoRecordError::Encode {
+                frame: frame_index,
+                source,
+            })?;
+        frame_index += 1;
+    }
+
+    if frame_index == 0 {
+        drop(encoder);
+        let _ = std::fs::remove_file(&dest);
+        return Err(VideoRecordError::NoFrames);
+    }
+
+    encoder.finish().map_err(VideoRecordError::Finish)?;
+    Ok(frame_index)
+}
+
+fn fill_rgb24(frame: &mut RawFrame, pixels: &[u8], config: &VideoRecorderConfig) {
+    let width = config.width as usize;
+    let height = config.height as usize;
+    let bpp = config.pixel_format.bytes_per_pixel();
+    let src_stride = width * bpp;
+    let dst_stride = frame.stride(0);
+    let data = frame.data_mut(0);
+
+    for y in 0..height {
+        let src_row = &pixels[y * src_stride..(y + 1) * src_stride];
+        let dst_row = &mut data[y * dst_stride..y * dst_stride + width * 3];
+        match config.pixel_format {
+            RecorderPixelFormat::Rgb8 => dst_row.copy_from_slice(src_row),
+            RecorderPixelFormat::Rgba8 => {
+                for (dst, src) in dst_row.chunks_exact_mut(3).zip(src_row.chunks_exact(4)) {
+                    dst.copy_from_slice(&src[..3]);
+                }
+            }
+            RecorderPixelFormat::Bgra8 => {
+                for (dst, src) in dst_row.chunks_exact_mut(3).zip(src_row.chunks_exact(4)) {
+                    dst[0] = src[2];
+                    dst[1] = src[1];
+                    dst[2] = src[0];
+                }
+            }
+        }
+    }
+}
diff --git a/crates/processing_video/tests/record.rs b/crates/processing_video/tests/record.rs
new file mode 100644
index 00000000..df2e18c4
--- /dev/null
+++ b/crates/processing_video/tests/record.rs
@@ -0,0 +1,98 @@
+use processing_video::{VideoRecorder, VideoRecorderConfig};
+
+const WIDTH: u32 = 64;
+const HEIGHT: u32 = 48;
+const FPS: f64 = 30.0;
+const FRAMES: u64 = 30;
+
+fn gradient_frame(index: u64) -> Vec<u8> {
+    let mut pixels = Vec::with_capacity(WIDTH as usize * HEIGHT as usize * 4);
+    for y in 0..HEIGHT {
+        for x in 0..WIDTH {
+            let r = (x * 255 / WIDTH) as u8;
+            let g = (y * 255 / HEIGHT) as u8;
+            let b = ((index * 8) % 256) as u8;
+            pixels.extend_from_slice(&[r, g, b, 255]);
+        }
+    }
+    pixels
+}
+
+#[test]
+fn encode_decode_roundtrip() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("out.mp4");
+
+    let config = VideoRecorderConfig::new(WIDTH, HEIGHT, FPS);
+    let mut recorder = VideoRecorder::new(&path, config).unwrap();
+    for i in 0..FRAMES {
+        recorder.record_frame(gradient_frame(i)).unwrap();
+    }
+    assert_eq!(recorder.finish().unwrap(), FRAMES);
+
+    let mut decoder = video_rs::Decoder::new(path.as_path()).unwrap();
+    assert_eq!(decoder.size(), (WIDTH, HEIGHT));
+    let time_base = decoder.time_base();
+    let (tb_num, tb_den) = (time_base.numerator() as f64, time_base.denominator() as f64);
+
+    let mut decoded = 0u64;
+    let mut last_pts = 0.0f64;
+    loop {
+        match decoder.decode_raw() {
+            Ok(frame) => {
+                if let Some(pts) = frame.pts() {
+                    last_pts = pts as f64 * tb_num / tb_den;
+                }
+                decoded += 1;
+            }
+            Err(video_rs::Error::DecodeExhausted | video_rs::Error::ReadExhausted) => break,
+            Err(e) => panic!("decode error after {decoded} frames: {e}"),
+        }
+    }
+    assert_eq!(decoded, FRAMES);
+    let expected_last = (FRAMES - 1) as f64 / FPS;
+    assert!(
+        (last_pts - expected_last).abs() < 1.5 / FPS,
+        "last pts {last_pts} should be near {expected_last}"
+    );
+}
+
+#[test]
+fn zero_frames_is_an_error_and_removes_the_file() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("empty.mp4");
+    let recorder = VideoRecorder::new(&path, VideoRecorderConfig::new(WIDTH, HEIGHT, FPS)).unwrap();
+    let err = recorder.finish().unwrap_err();
+    assert!(matches!(err, processing_video::VideoRecordError::NoFrames));
+    assert!(!path.exists());
+}
+
+#[test]
+fn crf_controls_output_size() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut sizes = Vec::new();
+    for (name, crf) in [("hi.mp4", 18u8), ("lo.mp4", 40u8)] {
+        let path = dir.path().join(name);
+        let config = VideoRecorderConfig::new(WIDTH, HEIGHT, FPS).with_crf(crf);
+        let mut recorder = VideoRecorder::new(&path, config).unwrap();
+        // Incompressible noise, so quantization dominates the file size.
+        let mut rng: u32 = 1;
+        for _ in 0..FRAMES {
+            let mut pixels = Vec::with_capacity(WIDTH as usize * HEIGHT as usize * 4);
+            for _ in 0..(WIDTH * HEIGHT) {
+                rng = rng.wrapping_mul(1664525).wrapping_add(1013904223);
+                let [a, b, c, _] = rng.to_le_bytes();
+                pixels.extend_from_slice(&[a, b, c, 255]);
+            }
+            recorder.record_frame(pixels).unwrap();
+        }
+        recorder.finish().unwrap();
+        sizes.push(std::fs::metadata(&path).unwrap().len());
+    }
+    assert!(
+        sizes[0] > sizes[1] * 2,
+        "crf 18 ({}) should be much larger than crf 40 ({})",
+        sizes[0],
+        sizes[1]
+    );
+}
diff --git a/examples/combine_mix_test.rs b/examples/combine_mix_test.rs
index f16d20d5..d6059194 100644
--- a/examples/combine_mix_test.rs
+++ b/examples/combine_mix_test.rs
@@ -1,9 +1,4 @@
-//! Validation harness for the `combine` and `mix` algebra verbs (task #5),
-//! including the alias guard (a `dst` that aliases a read-only operand must be
-//! rejected in Rust, NOT reach wgpu — where it would be a fatal validation
-//! error, see `examples/alias_spike.rs`).
-//!
-//! Run: `cargo run --example combine_mix_test`. Exits non-zero on mismatch.
+//! `combine` and `mix` algebra verbs, including the operand-alias guard.
 
 use processing::prelude::*;
 
@@ -27,7 +22,6 @@ fn sketch() -> error::Result<bool> {
 
     let mut ok = true;
 
-    // --- combine in-place: a += b (Float3, 4 particles) ---
     let av: Vec<f32> = (0..12).map(|i| i as f32).collect();
     let bv: Vec<f32> = (0..12).map(|i| (i * 10) as f32).collect();
     let a = buffer_create_with_data(to_bytes(&av))?;
@@ -42,7 +36,6 @@ fn sketch() -> error::Result<bool> {
         println!("  FAIL combine in-place: got {got:?}, want {want:?}");
     }
 
-    // --- combine out-of-place: dst = a * b, inputs preserved ---
     let dst = buffer_create_with_data(to_bytes(&vec![0.0; 12]))?;
     combine(dst, a, b, 3, COMBINE_MUL, 1.0, 0.0)?;
     let got_dst = f32s(&buffer_read(dst)?);
@@ -55,7 +48,6 @@ fn sketch() -> error::Result<bool> {
         println!("  FAIL combine out-of-place: dst={got_dst:?} want {want_dst:?}");
     }
 
-    // --- alias guard: combine(dst=b, a, b) must be rejected in Rust ---
     match combine(b, a, b, 3, COMBINE_ADD, 1.0, 0.0) {
         Err(_) => println!("  PASS combine alias guard (dst==b rejected before dispatch)"),
         Ok(()) => {
@@ -68,11 +60,9 @@ fn sketch() -> error::Result<bool> {
     buffer_destroy(b)?;
     buffer_destroy(dst)?;
 
-    // --- mix out-of-place: dst = lerp(a, b, t), t per-particle broadcast ---
-    // 3 particles x 4 components (color-like); t = [0, 0.5, 1].
     let comps = 4u32;
-    let a2: Vec<f32> = vec![1.0; 12]; // all-ones
-    let b2: Vec<f32> = vec![3.0; 12]; // all-threes
+    let a2: Vec<f32> = vec![1.0; 12];
+    let b2: Vec<f32> = vec![3.0; 12];
     let tv = vec![0.0f32, 0.5, 1.0];
     let am = buffer_create_with_data(to_bytes(&a2))?;
     let bm = buffer_create_with_data(to_bytes(&b2))?;
@@ -80,7 +70,6 @@ fn sketch() -> error::Result<bool> {
     let dm = buffer_create_with_data(to_bytes(&vec![0.0; 12]))?;
     mix(dm, am, bm, tm, comps, 1.0, 0.0, true)?;
     let got_mix = f32s(&buffer_read(dm)?);
-    // particle 0 -> a(1.0), particle 1 -> midpoint(2.0), particle 2 -> b(3.0)
     let mut want_mix = vec![1.0f32; 4];
     want_mix.extend([2.0f32; 4]);
     want_mix.extend([3.0f32; 4]);
@@ -91,7 +80,6 @@ fn sketch() -> error::Result<bool> {
         println!("  FAIL mix out-of-place: got {got_mix:?}, want {want_mix:?}");
     }
 
-    // --- mix in-place: a = lerp(a, b, t) ---
     mix(am, am, bm, tm, comps, 1.0, 0.0, true)?;
     let got_mix_ip = f32s(&buffer_read(am)?);
     if approx(&got_mix_ip, &want_mix) {
diff --git a/examples/field_falloff_test.rs b/examples/field_falloff_test.rs
index 4f73beb4..fa192870 100644
--- a/examples/field_falloff_test.rs
+++ b/examples/field_falloff_test.rs
@@ -1,8 +1,4 @@
-//! Validates the shared `falloff` WESL helper (task #10) end-to-end: dispatches
-//! the `field` kernel (which now `import`s `processing::particles::falloff`) over
-//! particles at known distances and checks the weights against CPU falloff.
-//!
-//! Run: `cargo run --example field_falloff_test`. Exits non-zero on mismatch.
+//! Shared `falloff` WESL helper against CPU falloff at known distances.
 
 use bevy::prelude::Entity;
 use processing::prelude::*;
@@ -21,7 +17,6 @@ fn approx(a: &[f32], b: &[f32]) -> bool {
     a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5)
 }
 
-// Particles along +x at distances 0, 0.5, 1.0, 1.5 from the origin.
 const DISTS: [f32; 4] = [0.0, 0.5, 1.0, 1.5];
 
 fn cpu_falloff(d: f32, mode: u32) -> f32 {
@@ -70,8 +65,7 @@ fn sketch() -> error::Result<bool> {
         ok &= run_mode(field, pos, weight, mode)?;
     }
 
-    // The other falloff users share the same import — instantiate them so their
-    // WESL actually compiles (compute_create errors if the import is broken).
+    // Instantiate the other falloff importers so their WESL compiles too.
     for (name, r) in [
         ("attract", particles_kernel_attract()),
         ("vortex", particles_kernel_vortex()),
diff --git a/examples/flock_grid_test.rs b/examples/flock_grid_test.rs
index 365c7a56..bfce80ba 100644
--- a/examples/flock_grid_test.rs
+++ b/examples/flock_grid_test.rs
@@ -1,14 +1,4 @@
-//! Validation harness for the grid-accelerated flock kernel.
-//!
-//! The boids steering math in `flock.wgsl` is a verbatim port of the previous
-//! brute-force kernel; the only new logic is sourcing neighbours from the
-//! spatial hash. So this test isolates and proves *that*: an inline `count_grid`
-//! kernel that walks the same 3x3x3 cell block as `flock` must find exactly the
-//! same neighbour set (within RADIUS) as an all-pairs `count_brute` — compared
-//! as exact integer counts (no float-order ambiguity). Then it runs the real
-//! flock kernel once as a smoke test (finite output, velocities actually change).
-//!
-//! Run: `cargo run --example flock_grid_test`. Exits non-zero on any mismatch.
+//! Grid-accelerated flock kernel: grid neighbours must match all-pairs exactly.
 
 use processing::prelude::*;
 
@@ -106,7 +96,6 @@ fn bytes_to_f32s(b: &[u8]) -> Vec<f32> {
         .collect()
 }
 
-// Deterministic pseudo-random in [0,1) from a u32 seed.
 fn rnd(seed: u32) -> f32 {
     let mut x = seed.wrapping_mul(747796405).wrapping_add(2891336453);
     x = ((x >> ((x >> 28).wrapping_add(4))) ^ x).wrapping_mul(277803737);
@@ -119,7 +108,6 @@ fn sketch() -> error::Result<bool> {
     let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
     let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
 
-    // Boids in [0.5, 9.5]^3 with small velocities; deterministic.
     let mut pos = Vec::with_capacity((N * 3) as usize);
     let mut vel = Vec::with_capacity((N * 3) as usize);
     for i in 0..N {
@@ -147,7 +135,6 @@ fn sketch() -> error::Result<bool> {
 
     let mut ok = true;
 
-    // --- Neighbour-count equivalence (exact) ---
     let cg = compute_create(shader_create(COUNT_GRID_SRC)?)?;
     compute_set(cg, "position", shader_value::ShaderValue::Buffer(position))?;
     compute_set(cg, "counts", shader_value::ShaderValue::Buffer(counts_grid))?;
@@ -173,7 +160,6 @@ fn sketch() -> error::Result<bool> {
         println!("  FAIL neighbour count at particle {i}: grid {}, brute {}", g[i], b[i]);
     }
 
-    // --- Real flock kernel smoke test ---
     let flock = particles_kernel_flock()?;
     compute_set(flock, "position", shader_value::ShaderValue::Buffer(position))?;
     compute_set(flock, "velocity", shader_value::ShaderValue::Buffer(velocity))?;
diff --git a/examples/glue_test.rs b/examples/glue_test.rs
index aa4ea940..55a26605 100644
--- a/examples/glue_test.rs
+++ b/examples/glue_test.rs
@@ -1,7 +1,4 @@
-//! Validation harness for the glue algebra verbs (task #7): `reduce_components`,
-//! `extract`, `pack`, `generate`.
-//!
-//! Run: `cargo run --example glue_test`. Exits non-zero on mismatch.
+//! Glue algebra verbs: `reduce_components`, `extract`, `pack`, `generate`.
 
 use processing::prelude::*;
 
@@ -25,10 +22,8 @@ fn sketch() -> error::Result<bool> {
 
     let mut ok = true;
 
-    // Float3 velocities for reduce/extract.
     let vel = vec![3.0f32, 4.0, 0.0, 1.0, 2.0, 2.0, 0.0, 0.0, 7.0, 5.0, 0.0, 0.0];
 
-    // --- reduce_components LENGTH: speed = |velocity| ---
     let v = buffer_create_with_data(to_bytes(&vel))?;
     let speed = buffer_create_with_data(to_bytes(&vec![0.0; 4]))?;
     reduce_components(speed, v, 3, REDUCE_LENGTH)?;
@@ -40,7 +35,6 @@ fn sketch() -> error::Result<bool> {
         println!("  FAIL reduce LENGTH: got {got:?}, want [5,3,7,5]");
     }
 
-    // --- extract component 1 (.y) ---
     let y = buffer_create_with_data(to_bytes(&vec![0.0; 4]))?;
     extract(y, v, 3, 1)?;
     let got_y = f32s(&buffer_read(y)?);
@@ -54,7 +48,6 @@ fn sketch() -> error::Result<bool> {
     buffer_destroy(speed)?;
     buffer_destroy(y)?;
 
-    // --- pack 3 scalar buffers -> Float3 ---
     let xs = buffer_create_with_data(to_bytes(&[1.0, 2.0, 3.0]))?;
     let ys = buffer_create_with_data(to_bytes(&[10.0, 20.0, 30.0]))?;
     let zs = buffer_create_with_data(to_bytes(&[100.0, 200.0, 300.0]))?;
@@ -75,7 +68,6 @@ fn sketch() -> error::Result<bool> {
     buffer_destroy(zs)?;
     buffer_destroy(packed)?;
 
-    // --- generate: uniform in [0,1), deterministic in seed ---
     let g1 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
     let g2 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
     let g3 = buffer_create_with_data(to_bytes(&vec![0.0; 16]))?;
@@ -88,7 +80,6 @@ fn sketch() -> error::Result<bool> {
     let in_range = a.iter().all(|x| (0.0..1.0).contains(x));
     let deterministic = approx(&a, &b);
     let seed_varies = !approx(&a, &c);
-    // basic spread sanity: not all identical
     let varied = a.windows(2).any(|w| (w[0] - w[1]).abs() > 1e-6);
     if in_range && deterministic && seed_varies && varied {
         println!("  PASS generate uniform (in-range, deterministic, seed-sensitive)");
diff --git a/examples/grid_test.rs b/examples/grid_test.rs
index bbd355ba..f42aaec6 100644
--- a/examples/grid_test.rs
+++ b/examples/grid_test.rs
@@ -1,10 +1,4 @@
-//! Validation harness for the bounded uniform spatial hash grid
-//! (`grid_create` / `grid_build`). Places particles at known cell centres,
-//! builds the grid on the GPU, reads back the CSR `offsets` and `sorted`
-//! buffers, and checks them against a CPU reference: exact offsets, and each
-//! cell's bucket membership as a set (intra-cell order is atomic-nondeterministic).
-//!
-//! Run: `cargo run --example grid_test`. Exits non-zero on any mismatch.
+//! Spatial hash grid (`grid_create` / `grid_build`) against a CPU reference.
 
 use std::collections::BTreeSet;
 
@@ -41,7 +35,6 @@ fn sketch() -> error::Result<bool> {
     let capacity: u32 = 40;
     let num_cells = (DIMS[0] * DIMS[1] * DIMS[2]) as usize;
 
-    // Deterministic spread across cells with varying occupancy (incl. empties).
     let cells: Vec<[u32; 3]> = (0..capacity)
         .map(|i| [(i * 7) % 4, (i * 13) % 4, (i * 5) % 4])
         .collect();
@@ -67,7 +60,6 @@ fn sketch() -> error::Result<bool> {
     let offsets = bytes_to_u32s(&buffer_read(grid.offsets)?);
     let sorted = bytes_to_u32s(&buffer_read(grid.sorted)?);
 
-    // CPU reference.
     let mut counts = vec![0u32; num_cells];
     for i in 0..capacity as usize {
         counts[cpu_cell(positions[i]) as usize] += 1;
@@ -93,7 +85,6 @@ fn sketch() -> error::Result<bool> {
         println!("  PASS offsets (total={})", expected_offsets[num_cells]);
     }
 
-    // Bucket membership per cell, compared as sets.
     let mut buckets_ok = true;
     for c in 0..num_cells {
         let (s, e) = (expected_offsets[c] as usize, expected_offsets[c + 1] as usize);
diff --git a/examples/group_compact_test.rs b/examples/group_compact_test.rs
index e4c7ce8c..f70f071e 100644
--- a/examples/group_compact_test.rs
+++ b/examples/group_compact_test.rs
@@ -1,9 +1,4 @@
-//! Validation harness for task #17: stream compaction (`compact`) and the group
-//! predicate (`map` comparison ops). Checks the compaction primitive directly,
-//! then the full chain: a `> threshold` predicate produces keep-flags which
-//! compact to the dense list of matching indices.
-//!
-//! Run: `cargo run --example group_compact_test`. Exits non-zero on mismatch.
+//! Stream compaction (`compact`) and the group predicate chain.
 
 use bevy::prelude::Entity;
 use processing::prelude::*;
@@ -44,7 +39,6 @@ fn sketch() -> error::Result<bool> {
 
     let mut ok = true;
 
-    // --- compaction primitive, directly ---
     let (c, out) = compact_flags(&[0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0])?;
     ok &= check("compact mixed", c, &out, &[1, 2, 4, 7]);
 
@@ -54,12 +48,10 @@ fn sketch() -> error::Result<bool> {
     let (c, out) = compact_flags(&[1.0, 1.0, 1.0, 1.0])?;
     ok &= check("compact all", c, &out, &[0, 1, 2, 3]);
 
-    // --- group predicate (map > threshold) -> compact ---
     let src_vals = [0.1f32, 0.5, 0.9, 0.3, 0.7];
     let src = buffer_create_with_data(f32_bytes(&src_vals))?;
     let flags = buffer_create((src_vals.len() as u64) * 4)?;
     let idx = buffer_create((src_vals.len() as u64) * 4)?;
-    // flags[i] = src[i] > 0.4 ? 1 : 0   → [0,1,1,0,1]
     map(flags, src, 1, MAP_GREATER, 0.4, 0.0)?;
     let count = compact(flags, idx)?;
     let out = u32s(&buffer_read(idx)?);
diff --git a/examples/lookup_test.rs b/examples/lookup_test.rs
index 03843104..fb233dfe 100644
--- a/examples/lookup_test.rs
+++ b/examples/lookup_test.rs
@@ -1,16 +1,9 @@
-//! Validation harness for the `lookup` algebra verb (task #6): sample a texture
-//! by a per-particle coordinate into a flat RGBA `dst`. Exercises both the 1-D
-//! (in_components=1) and 2-D (in_components=2, interleaved uv) paths, plus the
-//! sampler-binding fix (a `Texture` value bound to a `sampler` param).
-//!
-//! Uses pure 0/1 primary colours + nearest sampling so texel reads are exact.
-//! Run: `cargo run --example lookup_test`. Exits non-zero on mismatch.
+//! `lookup` algebra verb: texture sampling by per-particle coordinate, 1-D and 2-D.
 
 use bevy::prelude::Entity;
 use bevy::render::render_resource::Extent3d;
 use processing::prelude::*;
 
-// R,G,B,W as RGBA8 bytes.
 const RED: [u8; 4] = [255, 0, 0, 255];
 const GREEN: [u8; 4] = [0, 255, 0, 255];
 const BLUE: [u8; 4] = [0, 0, 255, 255];
@@ -51,7 +44,6 @@ fn sketch() -> error::Result<bool> {
 
     let mut ok = true;
 
-    // --- 1-D: 4-wide ramp, sample at texel centres ---
     let ramp = ramp_image(4, 1, &[RED, GREEN, BLUE, WHITE])?;
     let t = vec![0.125f32, 0.375, 0.625, 0.875];
     let op_in = buffer_create_with_data(to_bytes(&t))?;
@@ -73,8 +65,6 @@ fn sketch() -> error::Result<bool> {
     buffer_destroy(op_in)?;
     buffer_destroy(dst)?;
 
-    // --- 2-D: 2x2 texture, sample at 4 texel centres ---
-    // row0 = [red, green], row1 = [blue, white]
     let tex2 = ramp_image(2, 2, &[RED, GREEN, BLUE, WHITE])?;
     let uv = vec![
         0.25f32, 0.25, // red
diff --git a/examples/map_test.rs b/examples/map_test.rs
index 656c1856..0fae79f3 100644
--- a/examples/map_test.rs
+++ b/examples/map_test.rs
@@ -1,14 +1,4 @@
-//! Validation harness for the `map` algebra verb (task #5) and, underneath it,
-//! the WESL `@if(in_place)` specialization + `shader_create_with_features`
-//! infra (task #4's chosen approach).
-//!
-//! Checks:
-//!  - both pipelines (in-place / out-of-place) compile from one source;
-//!  - in-place `map` (dst == a) transforms EVERY component of a Float3 buffer
-//!    (the old scalar attr_* kernels left most of a wide attribute untouched);
-//!  - out-of-place `map` writes `dst = f(a)` and leaves `a` unchanged.
-//!
-//! Run: `cargo run --example map_test`. Exits non-zero on mismatch.
+//! `map` algebra verb: in-place and out-of-place pipelines from one WESL source.
 
 use processing::prelude::*;
 
@@ -30,15 +20,12 @@ fn sketch() -> error::Result<bool> {
     let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
     let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
 
-    // 5 particles x 3 components = 15 floats. The old bug would only touch the
-    // first 5 floats; component-generic map must touch all 15.
     let n_particles = 5u32;
     let components = 3u32;
     let input: Vec<f32> = (0..(n_particles * components)).map(|i| i as f32).collect();
 
     let mut ok = true;
 
-    // --- in-place: a *= 2 + 1 ---
     let a = buffer_create_with_data(to_bytes(&input))?;
     map(a, a, components, MAP_AFFINE, 2.0, 1.0)?;
     let got = f32s(&buffer_read(a)?);
@@ -51,7 +38,6 @@ fn sketch() -> error::Result<bool> {
     }
     buffer_destroy(a)?;
 
-    // --- out-of-place: dst = |a|, a unchanged ---
     let neg: Vec<f32> = (0..(n_particles * components))
         .map(|i| -(i as f32) - 0.5)
         .collect();
diff --git a/examples/reduce_test.rs b/examples/reduce_test.rs
index a2cc938d..75d3d613 100644
--- a/examples/reduce_test.rs
+++ b/examples/reduce_test.rs
@@ -1,8 +1,4 @@
-//! Validation harness for the GPU→CPU reduction (`reduce`): sum / min / max over
-//! an f32 buffer, read back to the host. Covers single- and multi-level (n>256)
-//! reductions. Values stay under 2^24 so f32 sums are exact.
-//!
-//! Run: `cargo run --example reduce_test`. Exits non-zero on mismatch.
+//! GPU->CPU `reduce` (sum / min / max), single- and multi-level.
 
 use bevy::prelude::Entity;
 use processing::prelude::*;
@@ -38,26 +34,22 @@ fn sketch() -> error::Result<bool> {
 
     let mut ok = true;
 
-    // all-ones, single level
     let (s, mn, mx) = reduce_all(&vec![1.0; 1000])?;
     ok &= check("ones/1000 sum", s, 1000.0);
     ok &= check("ones/1000 min", mn, 1.0);
     ok &= check("ones/1000 max", mx, 1.0);
 
-    // ramp 0..300
     let ramp: Vec<f32> = (0..300).map(|i| i as f32).collect();
     let (s, mn, mx) = reduce_all(&ramp)?;
     ok &= check("ramp/300 sum", s, 300.0 * 299.0 / 2.0);
     ok &= check("ramp/300 min", mn, 0.0);
     ok &= check("ramp/300 max", mx, 299.0);
 
-    // multi-level: all-ones n=70000
     let (s, mn, mx) = reduce_all(&vec![1.0; 70_000])?;
     ok &= check("ones/70k sum", s, 70_000.0);
     ok &= check("ones/70k min", mn, 1.0);
     ok &= check("ones/70k max", mx, 1.0);
 
-    // multi-level min/max: ramp 0..70000
     let big: Vec<f32> = (0..70_000).map(|i| i as f32).collect();
     let b = buffer_create_with_data(to_bytes(&big))?;
     ok &= check("ramp/70k min", reduce(b, REDUCE_OP_MIN)?, 0.0);
diff --git a/examples/scan_test.rs b/examples/scan_test.rs
index a516bec0..ca9aab76 100644
--- a/examples/scan_test.rs
+++ b/examples/scan_test.rs
@@ -1,10 +1,4 @@
-//! Validation harness for the GPU exclusive prefix-sum primitive
-//! (`prefix_sum_u32`). Boots an offscreen graphics context (to initialise the
-//! render device), scans several buffer sizes that exercise the single-block,
-//! block-boundary, and multi-level paths, and checks each against a CPU scan.
-//!
-//! Run: `cargo run --example scan_test`. Prints PASS/FAIL per case and exits
-//! non-zero if any case fails.
+//! GPU exclusive prefix-sum (`prefix_sum_u32`) against a CPU scan.
 
 use processing::prelude::*;
 
@@ -19,7 +13,7 @@ fn bytes_to_u32s(b: &[u8]) -> Vec<u32> {
 }
 
 fn run_case(n: usize) -> error::Result<bool> {
-    // Deterministic, non-trivial values (1..=7) so wrong strides/offsets show up.
+    // Non-trivial values so wrong strides/offsets show up.
     let input: Vec<u32> = (0..n).map(|i| (i % 7 + 1) as u32).collect();
 
     let buf = buffer_create_with_data(u32s_to_bytes(&input))?;
@@ -54,8 +48,7 @@ fn sketch() -> error::Result<bool> {
     let surface = surface_create_offscreen(1, 1, 1.0, TextureFormat::Rgba8Unorm)?;
     let _graphics = graphics_create(surface, 1, 1, TextureFormat::Rgba8Unorm)?;
 
-    // n values covering: empty, single, sub-block, exact block, block+1,
-    // multi-block single level, and two-level (> 256*256 = 65536).
+    // Sizes cover empty, block-boundary, and two-level (> 256*256) paths.
     let cases = [1usize, 5, 255, 256, 257, 1000, 65_536, 70_000, 300_000];
     let mut all_ok = true;
     for &n in &cases {
diff --git a/examples/sort_test.rs b/examples/sort_test.rs
index 871c014c..512d42a3 100644
--- a/examples/sort_test.rs
+++ b/examples/sort_test.rs
@@ -1,9 +1,4 @@
-//! Validation harness for the GPU bitonic sort (`bitonic_sort_by_key`). Sorts a
-//! buffer of random f32 keys with `payload[i] = i`, then checks: keys come back
-//! ascending, payload is a permutation of 0..n, and each payload entry points at
-//! the original key now sitting in that slot (so the permutation is correct).
-//!
-//! Run: `cargo run --example sort_test`. Exits non-zero on any failure.
+//! GPU bitonic sort (`bitonic_sort_by_key`): key order and payload permutation.
 
 use processing::prelude::*;
 
@@ -45,12 +40,10 @@ fn run_case(n: u32) -> error::Result<bool> {
     buffer_destroy(keys)?;
     buffer_destroy(payload)?;
 
-    // 1. ascending
     if let Some(i) = (1..n as usize).find(|&i| sorted_keys[i] < sorted_keys[i - 1]) {
         println!("  FAIL n={n}: not ascending at {i}: {} < {}", sorted_keys[i], sorted_keys[i - 1]);
         return Ok(false);
     }
-    // 2. permutation of 0..n
     let mut seen = vec![false; n as usize];
     for &p in &perm {
         if p >= n || seen[p as usize] {
@@ -59,7 +52,6 @@ fn run_case(n: u32) -> error::Result<bool> {
         }
         seen[p as usize] = true;
     }
-    // 3. payload tracks the keys: original key at payload[i] equals sorted key i
     if let Some(i) = (0..n as usize).find(|&i| orig_keys[perm[i] as usize] != sorted_keys[i]) {
         println!("  FAIL n={n}: payload[{i}] mismatch: orig[{}]={} != {}", perm[i], orig_keys[perm[i] as usize], sorted_keys[i]);
         return Ok(false);

From b2347e21df887516a36962cd3c2bade602a5faec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Fri, 14 Aug 2026 11:15:11 -0700
Subject: [PATCH 10/14] Bevy 20.

---
 Cargo.lock                                    | 4026 ++++++++++-------
 Cargo.toml                                    |   42 +-
 assets/shaders/plexus_link.wesl               |   66 +-
 crates/processing_ffi/src/lib.rs              |    8 +
 .../examples/particles_lissajous.py           |   36 +-
 crates/processing_pyo3/src/color.rs           |    4 +
 crates/processing_pyo3/src/graphics.rs        |   28 +-
 crates/processing_pyo3/src/lib.rs             |   10 +-
 crates/processing_pyo3/src/particles.rs       |   67 +-
 crates/processing_render/Cargo.toml           |    2 +-
 .../shaders/processing/prims.wesl             |  100 +
 crates/processing_render/src/compute.rs       |    6 +-
 crates/processing_render/src/graphics.rs      |   11 +-
 crates/processing_render/src/image.rs         |    5 +-
 crates/processing_render/src/lib.rs           |   83 +-
 .../processing_render/src/material/custom.rs  |    9 +-
 crates/processing_render/src/material/mod.rs  |   15 +-
 .../processing_render/src/particles/emit.rs   |  108 +-
 .../src/particles/kernels/flock.wgsl          |   83 +-
 .../src/particles/kernels/mod.rs              |   12 +
 .../src/particles/material.rs                 |   15 +-
 crates/processing_render/src/particles/mod.rs |   30 +-
 .../processing_render/src/particles/pack.wgsl |    1 +
 .../src/particles/particles.wgsl              |   13 +-
 .../src/particles/point_render.rs             |   30 +-
 .../processing_render/src/particles/prims.rs  |  214 +
 .../processing_render/src/render/material.rs  |    2 +-
 crates/processing_render/src/render/mod.rs    |   81 +-
 examples/particles_stress.rs                  |  207 +-
 src/lib.rs                                    |    3 +-
 src/prelude.rs                                |   38 +-
 31 files changed, 3478 insertions(+), 1877 deletions(-)
 create mode 100644 crates/processing_render/shaders/processing/prims.wesl
 create mode 100644 crates/processing_render/src/particles/prims.rs

diff --git a/Cargo.lock b/Cargo.lock
index c81682f7..67321bc5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -29,22 +29,26 @@ dependencies = [
 
 [[package]]
 name = "accesskit_consumer"
-version = "0.35.0"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53cf47daed85312e763fbf85ceca136e0d7abc68e0a7e12abe11f48172bc3b10"
+checksum = "5d10a236f96f87d70732e44520046785431ef01d5bcd6b041317bfadd2f88245"
 dependencies = [
  "accesskit",
  "hashbrown 0.16.1",
 ]
 
 [[package]]
-name = "accesskit_consumer"
-version = "0.38.0"
+name = "accesskit_ios"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d10a236f96f87d70732e44520046785431ef01d5bcd6b041317bfadd2f88245"
+checksum = "750c4e9f6ce888dfe8a10c0f1b5ceb646a7854fd46579d74919219d1bb314083"
 dependencies = [
  "accesskit",
+ "accesskit_consumer",
  "hashbrown 0.16.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
+ "objc2-ui-kit",
 ]
 
 [[package]]
@@ -54,7 +58,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce02dc63b43f0c9296af9ac946312a2dc8814427d7a64d2d600971dac55b6076"
 dependencies = [
  "accesskit",
- "accesskit_consumer 0.38.0",
+ "accesskit_consumer",
  "hashbrown 0.16.1",
  "objc2 0.5.2",
  "objc2-app-kit 0.2.2",
@@ -63,12 +67,12 @@ dependencies = [
 
 [[package]]
 name = "accesskit_windows"
-version = "0.32.1"
+version = "0.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eff7009f1a532e917d66970a1e80c965140c6cfbbabbdde3d64e5431e6c78e21"
+checksum = "106c2b961215864d1c2e703ee63269c25c4e80a577ffb2c1017b9c17dcdf83a1"
 dependencies = [
  "accesskit",
- "accesskit_consumer 0.35.0",
+ "accesskit_consumer",
  "hashbrown 0.16.1",
  "static_assertions",
  "windows 0.62.2",
@@ -77,11 +81,12 @@ dependencies = [
 
 [[package]]
 name = "accesskit_winit"
-version = "0.32.2"
+version = "0.33.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fe9a94394896352cc4660ca2288bd4ef883d83238853c038b44070c8f134313"
+checksum = "d5b41e63a69f36d9f1f41e70464c7e5f72eee485ef26aab19f0b4f86e6c0a84c"
 dependencies = [
  "accesskit",
+ "accesskit_ios",
  "accesskit_macos",
  "accesskit_windows",
  "raw-window-handle",
@@ -182,15 +187,6 @@ dependencies = [
  "thiserror 2.0.20",
 ]
 
-[[package]]
-name = "android-build"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fc9904ad2ad097c3c1cfe2eacaaf0fc24710936fa9ed941cb310b7c6ed2ab7"
-dependencies = [
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "android-properties"
 version = "0.2.2"
@@ -347,7 +343,7 @@ version = "0.38.0+1.3.281"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"
 dependencies = [
- "libloading 0.8.9",
+ "libloading",
 ]
 
 [[package]]
@@ -467,43 +463,6 @@ dependencies = [
  "portable-atomic-util",
 ]
 
-[[package]]
-name = "audio-core"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ebbf82d06013f4c41fe71303feb980cddd78496d904d06be627972de51a24"
-
-[[package]]
-name = "audioadapter"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c75c3943c6c7279bb25a449a8d1727480730ab2efd7b6fd5d6ca51927096e6e4"
-dependencies = [
- "audio-core",
- "num-traits",
-]
-
-[[package]]
-name = "audioadapter-buffers"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ece3390b6eb40379094843a1da5aaccc34bc0d85a8cbf68d09fe092fee6de29e"
-dependencies = [
- "audioadapter",
- "audioadapter-sample",
- "num-traits",
-]
-
-[[package]]
-name = "audioadapter-sample"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1592f90413568e259413c21a41a3d571feb1774255c209e7966d98f9db708c90"
-dependencies = [
- "audio-core",
- "num-traits",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -561,50 +520,77 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bevy"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bfadbebfc6599aa59289b754ac30023959854304f3d393da2cf62bb3cd5df8f"
+dependencies = [
+ "bevy_internal 0.19.1",
+]
+
+[[package]]
+name = "bevy"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_internal 0.20.0-dev",
+]
+
+[[package]]
+name = "bevy_a11y"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c02cd43f914ef7a0f5b16f8a3d88c378c07c92f1a8c32ac5ac4d4f73e55f9e2"
 dependencies = [
- "bevy_internal",
+ "accesskit",
+ "bevy_app 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_reflect 0.19.1",
 ]
 
 [[package]]
 name = "bevy_a11y"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "accesskit",
- "bevy_app",
- "bevy_derive",
- "bevy_ecs",
- "bevy_reflect",
+ "bevy_app 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+]
+
+[[package]]
+name = "bevy_android"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae5ea5245a845cefa8efb5ff7c2a8a36cdebfb99596068780f340f0b5aba6689"
+dependencies = [
+ "android-activity",
 ]
 
 [[package]]
 name = "bevy_android"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "android-activity",
 ]
 
 [[package]]
 name = "bevy_animation"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "bevy_animation_macros",
- "bevy_app",
- "bevy_asset",
- "bevy_color",
- "bevy_derive",
- "bevy_ecs",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_time",
- "bevy_transform",
- "bevy_utils",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "blake3",
  "derive_more",
  "downcast-rs 2.0.2",
@@ -621,60 +607,143 @@ dependencies = [
 
 [[package]]
 name = "bevy_animation_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_anti_alias"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_core_pipeline",
- "bevy_derive",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_image",
- "bevy_math",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde973fc942cb596b03cae0dbece0a4d9dc2d2790bbc9852aa415affc1210d3a"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_utils 0.19.1",
+ "tracing",
+]
+
+[[package]]
+name = "bevy_anti_alias"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "tracing",
 ]
 
 [[package]]
 name = "bevy_app"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_derive",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "bevy_tasks",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd2aa472d43b4d081ef41d26300d17bd22cba6d68df2a223eb358782fa40bc6"
+dependencies = [
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_utils 0.19.1",
+ "console_error_panic_hook",
+ "ctrlc",
+ "downcast-rs 2.0.2",
+ "log",
+ "thiserror 2.0.20",
+ "variadics_please 1.1.0",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "bevy_app"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "console_error_panic_hook",
  "ctrlc",
  "downcast-rs 2.0.2",
  "log",
  "thiserror 2.0.20",
- "variadics_please",
+ "variadics_please 2.0.0",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "bevy_asset"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1624eddbf2293441b2158506aba75e523432b898d9da26eb6ed3e20af4c7fd38"
+dependencies = [
+ "async-broadcast",
+ "async-channel",
+ "async-fs",
+ "async-io",
+ "async-lock",
+ "atomicow",
+ "bevy_android 0.19.1",
+ "bevy_app 0.19.1",
+ "bevy_asset_macros 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_utils 0.19.1",
+ "bitflags 2.13.1",
+ "blake3",
+ "crossbeam-channel",
+ "derive_more",
+ "disqualified",
+ "downcast-rs 2.0.2",
+ "either",
+ "futures-io",
+ "futures-lite",
+ "futures-util",
+ "js-sys",
+ "ron",
+ "serde",
+ "stackfuture",
+ "thiserror 2.0.20",
+ "tracing",
+ "uuid",
  "wasm-bindgen",
+ "wasm-bindgen-futures",
  "web-sys",
 ]
 
 [[package]]
 name = "bevy_asset"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "async-broadcast",
  "async-channel",
@@ -682,15 +751,15 @@ dependencies = [
  "async-io",
  "async-lock",
  "atomicow",
- "bevy_android",
- "bevy_app",
- "bevy_asset_macros",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "bevy_tasks",
- "bevy_utils",
+ "bevy_android 0.20.0-dev",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset_macros 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "bitflags 2.13.1",
  "blake3",
  "crossbeam-channel",
@@ -716,10 +785,21 @@ dependencies = [
 
 [[package]]
 name = "bevy_asset_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "735611c80e926e960d279cba2a6f6ab27a61291752ec3b26e76bf9a0957e11e1"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "bevy_asset_macros"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -727,36 +807,36 @@ dependencies = [
 
 [[package]]
 name = "bevy_audio"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_ecs",
- "bevy_math",
- "bevy_reflect",
- "bevy_transform",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
  "rodio",
  "tracing",
 ]
 
 [[package]]
 name = "bevy_camera"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_color",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_math",
- "bevy_mesh",
- "bevy_reflect",
- "bevy_transform",
- "bevy_utils",
- "bevy_window",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de20d0babfb51e3907eb4eb56f1e36096a6f8c77acd997f5de611df4ee067d"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bevy_window 0.19.1",
  "derive_more",
  "downcast-rs 2.0.2",
  "serde",
@@ -765,32 +845,69 @@ dependencies = [
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_camera"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+ "derive_more",
+ "downcast-rs 2.0.2",
+ "serde",
+ "smallvec",
+ "thiserror 2.0.20",
+ "wgpu-types 30.0.0",
+]
+
 [[package]]
 name = "bevy_camera_controller"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+]
+
+[[package]]
+name = "bevy_clipboard"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a9792c7f2e8b5b71b9572a6d98fca4ee88ed186c8a02e164540c461ae3a92e"
 dependencies = [
- "bevy_app",
- "bevy_camera",
- "bevy_ecs",
- "bevy_input",
- "bevy_log",
- "bevy_math",
- "bevy_picking",
- "bevy_time",
- "bevy_transform",
- "bevy_window",
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_platform 0.19.1",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
 name = "bevy_clipboard"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_log",
- "bevy_platform",
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
@@ -798,11 +915,12 @@ dependencies = [
 
 [[package]]
 name = "bevy_color"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5370beae13bea2db64744f370bb33566aa770dff91c2beae245ce82217fbbc"
 dependencies = [
- "bevy_math",
- "bevy_reflect",
+ "bevy_math 0.19.1",
+ "bevy_reflect 0.19.1",
  "bytemuck",
  "derive_more",
  "encase",
@@ -811,29 +929,71 @@ dependencies = [
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_color"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_math 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bytemuck",
+ "derive_more",
+ "encase",
+ "serde",
+ "thiserror 2.0.20",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_core_pipeline"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2564f1ba766532e8eeb20059133ff6703e8dd5c3864b92378d0d1c541096ef12"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_light 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bevy_window 0.19.1",
+ "bitflags 2.13.1",
+ "indexmap",
+ "nonmax",
+]
+
 [[package]]
 name = "bevy_core_pipeline"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_derive",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_image",
- "bevy_light",
- "bevy_log",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_transform",
- "bevy_utils",
- "bevy_window",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_light 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
  "bitflags 2.13.1",
  "indexmap",
  "nonmax",
@@ -845,66 +1005,130 @@ version = "0.1.0"
 source = "git+https://github.com/tychedelia/bevy_cuda#f1e63bb2811eddfb6ed13ff9920f7ae2be091da1"
 dependencies = [
  "ash",
- "bevy",
+ "bevy 0.20.0-dev",
  "cudarc",
  "thiserror 2.0.20",
- "wgpu",
- "wgpu-hal",
+ "wgpu 29.0.4",
+ "wgpu-hal 29.0.4",
  "windows 0.58.0",
 ]
 
 [[package]]
 name = "bevy_derive"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d2a03321f3bd8016a041b3ae6afe83e636b3540fbc61d571bf069a21fda3231"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "bevy_derive"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_dev_tools"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_image",
- "bevy_input",
- "bevy_log",
- "bevy_math",
- "bevy_pbr",
- "bevy_picking",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_state",
- "bevy_text",
- "bevy_time",
- "bevy_transform",
- "bevy_ui",
- "bevy_ui_render",
- "bevy_window",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee5887919325facb6142d98de3e3d156c1b86c2375ac569e2e3547601ab05eaf"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_pbr 0.19.1",
+ "bevy_picking 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_state 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_time 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_ui 0.19.1",
+ "bevy_ui_render 0.19.1",
+ "bevy_window 0.19.1",
+ "tracing",
+]
+
+[[package]]
+name = "bevy_dev_tools"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_animation",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_audio",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_light 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_pbr 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_sprite 0.20.0-dev",
+ "bevy_state 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_ui 0.20.0-dev",
+ "bevy_ui_render 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+ "bevy_world_serialization",
  "tracing",
 ]
 
 [[package]]
 name = "bevy_diagnostic"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07a3a736f15486650c4c6866798a78d625c7063c991a3cc7b13f1577d89c82ae"
+dependencies = [
+ "atomic-waker",
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_time 0.19.1",
+ "const-fnv1a-hash",
+ "log",
+ "serde",
+]
+
+[[package]]
+name = "bevy_diagnostic"
+version = "0.20.0-dev"
 dependencies = [
  "atomic-waker",
- "bevy_app",
- "bevy_ecs",
- "bevy_platform",
- "bevy_tasks",
- "bevy_time",
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
  "const-fnv1a-hash",
  "log",
  "serde",
@@ -913,16 +1137,43 @@ dependencies = [
 
 [[package]]
 name = "bevy_ecs"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a350b2e4c2e47f7903d688affb8a723b31bca63af9789f1da88703f1ba04e354"
+dependencies = [
+ "arrayvec",
+ "bevy_ecs_macros 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_ptr 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_utils 0.19.1",
+ "bitflags 2.13.1",
+ "bumpalo",
+ "concurrent-queue",
+ "derive_more",
+ "fixedbitset",
+ "indexmap",
+ "log",
+ "nonmax",
+ "serde",
+ "slotmap",
+ "smallvec",
+ "thiserror 2.0.20",
+ "variadics_please 1.1.0",
+]
+
+[[package]]
+name = "bevy_ecs"
+version = "0.20.0-dev"
 dependencies = [
  "arrayvec",
- "bevy_ecs_macros",
- "bevy_platform",
- "bevy_ptr",
- "bevy_reflect",
- "bevy_tasks",
- "bevy_utils",
+ "bevy_ecs_macros 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_ptr 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "bitflags 2.13.1",
  "bumpalo",
  "concurrent-queue",
@@ -935,169 +1186,288 @@ dependencies = [
  "slotmap",
  "smallvec",
  "thiserror 2.0.20",
- "variadics_please",
+ "variadics_please 2.0.0",
 ]
 
 [[package]]
 name = "bevy_ecs_macro_logic"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a10fef45a3e7dad717ba03e8b5f7ecdf3b3fd1cd1c5e425793525938e90d5f"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.19.1",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
-name = "bevy_ecs_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+name = "bevy_ecs_macro_logic"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_ecs_macro_logic",
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
-name = "bevy_encase_derive"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+name = "bevy_ecs_macros"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3916d712264b6f3ec9c964ba10719450ea371e537e202a2ffcfa9f6a5e68169d"
 dependencies = [
- "bevy_macro_utils 0.19.0",
- "encase_derive_impl",
+ "bevy_ecs_macro_logic 0.19.1",
+ "bevy_macro_utils 0.19.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "bevy_feathers"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+name = "bevy_ecs_macros"
+version = "0.20.0-dev"
 dependencies = [
- "accesskit",
- "bevy_a11y",
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_derive",
- "bevy_ecs",
- "bevy_input",
- "bevy_input_focus",
- "bevy_log",
- "bevy_math",
- "bevy_picking",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render",
- "bevy_scene",
- "bevy_shader",
- "bevy_text",
- "bevy_ui",
- "bevy_ui_render",
- "bevy_ui_widgets",
- "bevy_window",
- "smol_str",
+ "bevy_ecs_macro_logic 0.20.0-dev",
+ "bevy_macro_utils 0.20.0-dev",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "bevy_gilrs"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_input",
- "bevy_platform",
- "bevy_time",
- "gilrs",
- "thiserror 2.0.20",
- "tracing",
+name = "bevy_encase_derive"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be03820f64f2279ae9d826c882e4ef764516ff75ab7bdc39bb40801891533b89"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "encase_derive_impl",
+]
+
+[[package]]
+name = "bevy_encase_derive"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_macro_utils 0.20.0-dev",
+ "encase_derive_impl",
+]
+
+[[package]]
+name = "bevy_feathers"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2bb6cfa726defd90add3eb71dc8b1ab32ca441f2531130679bfa880af2fb1f1"
+dependencies = [
+ "accesskit",
+ "bevy_a11y 0.19.1",
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_input_focus 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_picking 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_scene 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_ui 0.19.1",
+ "bevy_ui_render 0.19.1",
+ "bevy_ui_widgets 0.19.1",
+ "bevy_window 0.19.1",
+ "smol_str",
+]
+
+[[package]]
+name = "bevy_feathers"
+version = "0.20.0-dev"
+dependencies = [
+ "accesskit",
+ "bevy_a11y 0.20.0-dev",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_input_focus 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_scene 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_ui 0.20.0-dev",
+ "bevy_ui_render 0.20.0-dev",
+ "bevy_ui_widgets 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+ "smol_str",
+]
+
+[[package]]
+name = "bevy_gilrs"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "gilrs",
+ "thiserror 2.0.20",
+ "tracing",
 ]
 
 [[package]]
 name = "bevy_gizmos"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_ecs",
- "bevy_gizmos_macros",
- "bevy_input",
- "bevy_log",
- "bevy_math",
- "bevy_mesh",
- "bevy_reflect",
- "bevy_time",
- "bevy_transform",
- "bevy_utils",
- "bevy_window",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ac5bcad0b8d141ef64f4a89643f74f11827ea6ef48073192b39d69156ed1b92"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_gizmos_macros 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_time 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bevy_window 0.19.1",
+]
+
+[[package]]
+name = "bevy_gizmos"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_gizmos_macros 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+]
+
+[[package]]
+name = "bevy_gizmos_macros"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b37bbaa6241480b119da406fc261c9cf85d435addad880ae564c9b0f54a89a28"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_gizmos_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_gizmos_render"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_ecs",
- "bevy_gizmos",
- "bevy_image",
- "bevy_log",
- "bevy_material",
- "bevy_math",
- "bevy_mesh",
- "bevy_pbr",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_sprite_render",
- "bevy_transform",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ea2b6266d210bca0aa3bcba7e17204e437b4e86cecd4021ab7dcd32da576a02"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_gizmos 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_material 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bytemuck",
+ "tracing",
+]
+
+[[package]]
+name = "bevy_gizmos_render"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_gizmos 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_material 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_pbr 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_sprite_render 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "bytemuck",
  "tracing",
 ]
 
 [[package]]
 name = "bevy_gltf"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "async-lock",
  "base64",
  "bevy_animation",
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_ecs",
- "bevy_image",
- "bevy_light",
- "bevy_material",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_tasks",
- "bevy_transform",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_light 0.20.0-dev",
+ "bevy_material 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
  "bevy_world_serialization",
  "fixedbitset",
  "gltf",
@@ -1108,26 +1478,52 @@ dependencies = [
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_image"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca63218585b83f98831214431449e9344b363349dd5cab98dae0b8129f0a0e2f"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_utils 0.19.1",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "futures-lite",
+ "guillotiere 0.6.2",
+ "half",
+ "image",
+ "rectangle-pack",
+ "serde",
+ "thiserror 2.0.20",
+ "tracing",
  "wgpu-types 29.0.4",
 ]
 
 [[package]]
 name = "bevy_image"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_color",
- "bevy_ecs",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_utils",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "bitflags 2.13.1",
  "bytemuck",
  "futures-lite",
- "guillotiere",
+ "guillotiere 0.7.0",
  "half",
  "image",
  "ktx2",
@@ -1136,19 +1532,35 @@ dependencies = [
  "serde",
  "thiserror 2.0.20",
  "tracing",
- "wgpu-types 29.0.4",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_input"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b22e8b1119ff5c0b551cc11b672d25732c4e3eda72aceabc380595bd0e7bbe88"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "derive_more",
+ "log",
+ "smol_str",
+ "thiserror 2.0.20",
 ]
 
 [[package]]
 name = "bevy_input"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
  "derive_more",
  "log",
  "smol_str",
@@ -1157,114 +1569,211 @@ dependencies = [
 
 [[package]]
 name = "bevy_input_focus"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_input",
- "bevy_math",
- "bevy_picking",
- "bevy_reflect",
- "bevy_window",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4d5573eb503387f73d12acde3010d49c808c790d34691e2fb410fc54b8c72b9"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_window 0.19.1",
+ "log",
+ "thiserror 2.0.20",
+]
+
+[[package]]
+name = "bevy_input_focus"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
  "log",
  "thiserror 2.0.20",
 ]
 
 [[package]]
 name = "bevy_internal"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ba99ca2e501f14f4af3322d66ae41b5c5b6ebd3aac4d00cda47dea4c00290ae"
+dependencies = [
+ "bevy_a11y 0.19.1",
+ "bevy_android 0.19.1",
+ "bevy_anti_alias 0.19.1",
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_dev_tools 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_feathers 0.19.1",
+ "bevy_gizmos 0.19.1",
+ "bevy_gizmos_render 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_pbr 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_post_process 0.19.1",
+ "bevy_ptr 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_sprite_render 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_time 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bevy_window 0.19.1",
+]
+
+[[package]]
+name = "bevy_internal"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_a11y",
- "bevy_android",
+ "bevy_a11y 0.20.0-dev",
+ "bevy_android 0.20.0-dev",
  "bevy_animation",
- "bevy_anti_alias",
- "bevy_app",
- "bevy_asset",
+ "bevy_anti_alias 0.20.0-dev",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
  "bevy_audio",
- "bevy_camera",
+ "bevy_camera 0.20.0-dev",
  "bevy_camera_controller",
- "bevy_clipboard",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_derive",
- "bevy_dev_tools",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_feathers",
+ "bevy_clipboard 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_dev_tools 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_feathers 0.20.0-dev",
  "bevy_gilrs",
- "bevy_gizmos",
- "bevy_gizmos_render",
+ "bevy_gizmos 0.20.0-dev",
+ "bevy_gizmos_render 0.20.0-dev",
  "bevy_gltf",
- "bevy_image",
- "bevy_input",
- "bevy_input_focus",
- "bevy_light",
- "bevy_log",
- "bevy_material",
- "bevy_math",
- "bevy_mesh",
- "bevy_pbr",
- "bevy_picking",
- "bevy_platform",
- "bevy_post_process",
- "bevy_ptr",
- "bevy_reflect",
- "bevy_render",
- "bevy_scene",
- "bevy_shader",
- "bevy_sprite",
- "bevy_sprite_render",
- "bevy_state",
- "bevy_tasks",
- "bevy_text",
- "bevy_time",
- "bevy_transform",
- "bevy_ui",
- "bevy_ui_render",
- "bevy_ui_widgets",
- "bevy_utils",
- "bevy_window",
+ "bevy_image 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_input_focus 0.20.0-dev",
+ "bevy_light 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_material 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_pbr 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_post_process 0.20.0-dev",
+ "bevy_ptr 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_scene 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_sprite 0.20.0-dev",
+ "bevy_sprite_render 0.20.0-dev",
+ "bevy_state 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_ui 0.20.0-dev",
+ "bevy_ui_render 0.20.0-dev",
+ "bevy_ui_widgets 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
  "bevy_winit",
  "bevy_world_serialization",
 ]
 
 [[package]]
 name = "bevy_light"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_ecs",
- "bevy_gizmos",
- "bevy_image",
- "bevy_log",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_transform",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4f91fb900c2412c5cb7ff5083d428d8361a1d39b605df86eb259aff82f7ac45"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
  "half",
  "smallvec",
  "tracing",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_light"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_gizmos 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "half",
+ "smallvec",
+ "tracing",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_log"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e24488594832237c1e3abc823642823fa057b810c3a21e14e65bdbd15d1579d5"
+dependencies = [
+ "android_log-sys",
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_utils 0.19.1",
+ "tracing",
+ "tracing-log",
+ "tracing-oslog",
+ "tracing-subscriber",
+ "tracing-wasm",
+]
+
 [[package]]
 name = "bevy_log"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "android_log-sys",
- "bevy_app",
- "bevy_ecs",
- "bevy_platform",
- "bevy_utils",
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "tracing",
  "tracing-log",
  "tracing-oslog",
@@ -1274,67 +1783,99 @@ dependencies = [
 
 [[package]]
 name = "bevy_macro_utils"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7164fe229422295bba15f1885048f34f4660db069aacb895208f996b0c7784fb"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.119",
- "toml_edit 0.25.13+spec-1.1.0",
+ "toml_edit",
 ]
 
 [[package]]
 name = "bevy_macro_utils"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7164fe229422295bba15f1885048f34f4660db069aacb895208f996b0c7784fb"
+version = "0.20.0-dev"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.119",
- "toml_edit 0.25.13+spec-1.1.0",
+ "toml_edit",
 ]
 
 [[package]]
 name = "bevy_material"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_asset",
- "bevy_derive",
- "bevy_ecs",
- "bevy_material_macros",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_shader",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3efcdb3ba04a57f6e05548884745684a2051e9692398915f57c5c276306b7f10"
+dependencies = [
+ "bevy_asset 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_material_macros 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_utils 0.19.1",
  "encase",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
- "variadics_please",
+ "variadics_please 1.1.0",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_material"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_asset 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_material_macros 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "encase",
+ "smallvec",
+ "thiserror 2.0.20",
+ "tracing",
+ "variadics_please 2.0.0",
+ "wgpu-types 30.0.0",
+]
+
 [[package]]
 name = "bevy_material_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854f95c8f3374ef6242790de50b5cb8f5a601c698772d1447bf856067b53ee64"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "bevy_material_macros"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_math"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98ead494dcfaa9b4594eed7f09a27d868b7cc7fc9ebd655c5643322778f4a8a2"
 dependencies = [
  "approx",
  "arrayvec",
- "bevy_reflect",
+ "bevy_reflect 0.19.1",
  "derive_more",
  "glam 0.32.1",
  "itertools 0.14.0",
@@ -1343,36 +1884,82 @@ dependencies = [
  "rand_distr",
  "serde",
  "thiserror 2.0.20",
- "variadics_please",
+ "variadics_please 1.1.0",
+]
+
+[[package]]
+name = "bevy_math"
+version = "0.20.0-dev"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bevy_reflect 0.20.0-dev",
+ "derive_more",
+ "glam 0.33.3",
+ "itertools 0.14.0",
+ "libm",
+ "rand 0.10.2",
+ "rand_distr",
+ "serde",
+ "thiserror 2.0.20",
+ "variadics_please 2.0.0",
 ]
 
 [[package]]
 name = "bevy_mesh"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_derive",
- "bevy_ecs",
- "bevy_encase_derive",
- "bevy_math",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2adbf8e5a5817c345986756eb0377e18a510e1d7685ef62d6c7bafcd3bab85e"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_encase_derive 0.19.1",
+ "bevy_math 0.19.1",
  "bevy_mikktspace",
- "bevy_platform",
- "bevy_reflect",
- "bevy_transform",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_transform 0.19.1",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
  "encase",
  "glam 0.32.1",
  "half",
- "hexasphere",
+ "hexasphere 18.0.0",
  "thiserror 2.0.20",
  "tracing",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_mesh"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_encase_derive 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mikktspace",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "derive_more",
+ "encase",
+ "glam 0.33.3",
+ "half",
+ "hexasphere 19.0.0",
+ "serde",
+ "thiserror 2.0.20",
+ "tracing",
+ "wgpu-types 30.0.0",
+]
+
 [[package]]
 name = "bevy_mikktspace"
 version = "1.0.0"
@@ -1382,40 +1969,39 @@ checksum = "bff34eb29ff4b8a8688bc7299f14fb6b597461ca80fec03ed7d22939ab33e48f"
 [[package]]
 name = "bevy_naga_reflect"
 version = "0.2.0"
-source = "git+https://github.com/tychedelia/bevy_naga_reflect#3e59d3698281fcf6c56a6478be3ee12049737218"
 dependencies = [
- "bevy",
- "naga",
+ "bevy 0.20.0-dev",
+ "naga 29.0.4",
 ]
 
 [[package]]
 name = "bevy_pbr"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "244ae7d618b51a59c913c36b0564a295cd85ea91a5e777b542bb7bdb846a23d6"
 dependencies = [
  "arrayvec",
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_derive",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_gltf",
- "bevy_image",
- "bevy_light",
- "bevy_log",
- "bevy_material",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_tasks",
- "bevy_transform",
- "bevy_utils",
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_light 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_material 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
@@ -1430,24 +2016,86 @@ dependencies = [
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_pbr"
+version = "0.20.0-dev"
+dependencies = [
+ "arrayvec",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_gltf",
+ "bevy_image 0.20.0-dev",
+ "bevy_light 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_material 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "derive_more",
+ "fixedbitset",
+ "indexmap",
+ "nonmax",
+ "offset-allocator",
+ "smallvec",
+ "static_assertions",
+ "thiserror 2.0.20",
+ "tracing",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_picking"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "235d1ea0cd7d0ff2f37592f37b4d8504c597884296058ecadcb0d206d0258ab7"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_time 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_window 0.19.1",
+ "tracing",
+ "uuid",
+]
+
 [[package]]
 name = "bevy_picking"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_derive",
- "bevy_ecs",
- "bevy_input",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_time",
- "bevy_transform",
- "bevy_window",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
  "crossbeam-channel",
  "tracing",
  "uuid",
@@ -1455,8 +2103,9 @@ dependencies = [
 
 [[package]]
 name = "bevy_platform"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd610a417e7b4a3b9602cf11264d16cbbff8eabe689c5fed8be4e84c6a2680a3"
 dependencies = [
  "critical-section",
  "foldhash 0.2.0",
@@ -1474,25 +2123,69 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "bevy_platform"
+version = "0.20.0-dev"
+dependencies = [
+ "critical-section",
+ "foldhash 0.2.0",
+ "futures-channel",
+ "futures-lite",
+ "hashbrown 0.16.1",
+ "js-sys",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+ "spin 0.10.1",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-time",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "bevy_post_process"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eb9340107f7a4292b3b1d138cffb2700f31cef580f5777f2e83f4f00eae4dc1"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_utils 0.19.1",
+ "smallvec",
+ "thiserror 2.0.20",
+ "tracing",
+]
+
 [[package]]
 name = "bevy_post_process"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_utils",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
@@ -1500,19 +2193,25 @@ dependencies = [
 
 [[package]]
 name = "bevy_ptr"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1974de4b140f102fded747229ff4a61921acec07f02f0d1dcdadfe9ce177d0ff"
+
+[[package]]
+name = "bevy_ptr"
+version = "0.20.0-dev"
 
 [[package]]
 name = "bevy_reflect"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b76c3d056da3e299b84652ccf914c487b786857225d8ffbc8fc9509441a9e6b"
 dependencies = [
  "assert_type_match",
- "bevy_platform",
- "bevy_ptr",
- "bevy_reflect_derive",
- "bevy_utils",
+ "bevy_platform 0.19.1",
+ "bevy_ptr 0.19.1",
+ "bevy_reflect_derive 0.19.1",
+ "bevy_utils 0.19.1",
  "derive_more",
  "disqualified",
  "downcast-rs 2.0.2",
@@ -1521,88 +2220,192 @@ dependencies = [
  "glam 0.32.1",
  "indexmap",
  "inventory",
+ "serde",
+ "smallvec",
+ "smol_str",
+ "thiserror 2.0.20",
+ "uuid",
+ "variadics_please 1.1.0",
+ "wgpu-types 29.0.4",
+]
+
+[[package]]
+name = "bevy_reflect"
+version = "0.20.0-dev"
+dependencies = [
+ "assert_type_match",
+ "bevy_platform 0.20.0-dev",
+ "bevy_ptr 0.20.0-dev",
+ "bevy_reflect_derive 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "derive_more",
+ "disqualified",
+ "downcast-rs 2.0.2",
+ "erased-serde",
+ "foldhash 0.2.0",
+ "glam 0.33.3",
+ "indexmap",
+ "inventory",
  "petgraph 0.8.3",
  "serde",
  "smallvec",
  "smol_str",
  "thiserror 2.0.20",
  "uuid",
- "variadics_please",
+ "variadics_please 2.0.0",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_reflect_derive"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fc5f820ee52afeca6d3bb83f15c1bf61ea6196c840a761a21a8bc266a3b166e"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "indexmap",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "uuid",
+]
+
+[[package]]
+name = "bevy_reflect_derive"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_macro_utils 0.20.0-dev",
+ "indexmap",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "uuid",
+]
+
+[[package]]
+name = "bevy_render"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc86a32b2eef9859e1e7d323c6d1a9150fe77aa17c30fd05abebc12f645929dc"
+dependencies = [
+ "async-channel",
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_diagnostic 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_encase_derive 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_material 0.19.1",
+ "bevy_material_macros 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render_macros 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_time 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bevy_window 0.19.1",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "derive_more",
+ "downcast-rs 2.0.2",
+ "encase",
+ "glam 0.32.1",
+ "image",
+ "indexmap",
+ "itertools 0.14.0",
+ "js-sys",
+ "naga 29.0.4",
+ "nonmax",
+ "offset-allocator",
+ "send_wrapper",
+ "smallvec",
+ "thiserror 2.0.20",
+ "variadics_please 1.1.0",
+ "wasm-bindgen",
+ "weak-table",
+ "web-sys",
+ "wgpu 29.0.4",
  "wgpu-types 29.0.4",
 ]
 
-[[package]]
-name = "bevy_reflect_derive"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_macro_utils 0.19.0",
- "indexmap",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "uuid",
-]
-
 [[package]]
 name = "bevy_render"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "async-channel",
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_derive",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_encase_derive",
- "bevy_image",
- "bevy_log",
- "bevy_material",
- "bevy_material_macros",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render_macros",
- "bevy_shader",
- "bevy_tasks",
- "bevy_time",
- "bevy_transform",
- "bevy_utils",
- "bevy_window",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_diagnostic 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_encase_derive 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_material 0.20.0-dev",
+ "bevy_material_macros 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render_macros 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
  "downcast-rs 2.0.2",
  "encase",
- "glam 0.32.1",
+ "glam 0.33.3",
  "image",
  "indexmap",
  "itertools 0.14.0",
  "js-sys",
- "naga",
+ "naga 30.0.0",
  "nonmax",
  "offset-allocator",
  "send_wrapper",
  "smallvec",
  "thiserror 2.0.20",
- "variadics_please",
+ "tracing",
+ "variadics_please 2.0.0",
  "wasm-bindgen",
  "weak-table",
  "web-sys",
- "wgpu",
- "wgpu-types 29.0.4",
+ "wgpu 30.0.0",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_render_macros"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6be6eba0ce9770ae4576693804d6c605f8afd9c4769787414254efcf92196a90"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_render_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -1610,68 +2413,63 @@ dependencies = [
 
 [[package]]
 name = "bevy_scene"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_derive",
- "bevy_ecs",
- "bevy_log",
- "bevy_platform",
- "bevy_reflect",
- "bevy_scene_macros",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33f6f4f24cd771c6fd67286a8f264a45a644dc798a36614252db220d4fbbd63b"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_scene_macros 0.19.1",
+ "bevy_utils 0.19.1",
+ "smallvec",
+ "thiserror 2.0.20",
+ "tracing",
+ "variadics_please 1.1.0",
+]
+
+[[package]]
+name = "bevy_scene"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_scene_macros 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
- "variadics_please",
+ "variadics_please 2.0.0",
 ]
 
 [[package]]
 name = "bevy_scene_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fc7844c3410e228581200f73be123467c424f62fc40499c3e869b641b582748"
 dependencies = [
- "bevy_ecs_macro_logic",
- "bevy_macro_utils 0.19.0",
+ "bevy_ecs_macro_logic 0.19.1",
+ "bevy_macro_utils 0.19.1",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
-name = "bevy_seedling"
-version = "0.8.0"
-source = "git+https://github.com/CorvusPrudens/bevy_seedling?branch=master#ab4a88b430d216e8614549926e3532bcec5ce2db"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_diagnostic",
- "bevy_ecs",
- "bevy_log",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_seedling_macros",
- "bevy_time",
- "bevy_transform",
- "bevy_utils",
- "cpal 0.18.1",
- "firewheel",
- "firewheel-ircam-hrtf",
- "rand 0.10.2",
- "smallvec",
- "symphonia",
- "symphonium",
-]
-
-[[package]]
-name = "bevy_seedling_macros"
-version = "0.8.0"
-source = "git+https://github.com/CorvusPrudens/bevy_seedling?branch=master#ab4a88b430d216e8614549926e3532bcec5ce2db"
+name = "bevy_scene_macros"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.1",
+ "bevy_ecs_macro_logic 0.20.0-dev",
+ "bevy_macro_utils 0.20.0-dev",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -1679,115 +2477,232 @@ dependencies = [
 
 [[package]]
 name = "bevy_shader"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_asset",
- "bevy_platform",
- "bevy_reflect",
- "bevy_utils",
- "naga",
- "naga_oil",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50ba4fa5c5102a9ad1b0508c5bf8a6d02a22d5dc13c23ba908ee6d3d16a357cd"
+dependencies = [
+ "bevy_asset 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_utils 0.19.1",
+ "naga 29.0.4",
+ "naga_oil 0.22.0",
+ "serde",
+ "thiserror 2.0.20",
+ "tracing",
+ "wgpu-naga-bridge 29.0.4",
+ "wgpu-types 29.0.4",
+]
+
+[[package]]
+name = "bevy_shader"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_asset 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "naga 30.0.0",
+ "naga_oil 0.23.0",
  "serde",
  "thiserror 2.0.20",
  "tracing",
  "wesl",
- "wgpu-naga-bridge",
- "wgpu-types 29.0.4",
+ "wgpu-naga-bridge 30.0.0",
+ "wgpu-types 30.0.0",
 ]
 
 [[package]]
 name = "bevy_sprite"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_log",
- "bevy_math",
- "bevy_mesh",
- "bevy_picking",
- "bevy_reflect",
- "bevy_text",
- "bevy_transform",
- "bevy_window",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e93e631436ff9c08613843d46521ee60f2fcb2eb5f4754eec59591ca817a2ba0"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_window 0.19.1",
  "radsort",
  "tracing",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_sprite"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+ "radsort",
+ "tracing",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_sprite_render"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0a13c775880fe8fb3e7928921b2a1b549fd92c17571e7ca5e1250e53f0e56c"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_material 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_sprite 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "derive_more",
+ "fixedbitset",
+ "nonmax",
+ "tracing",
+]
+
 [[package]]
 name = "bevy_sprite_render"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_material",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_sprite",
- "bevy_text",
- "bevy_transform",
- "bevy_utils",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_material 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_sprite 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
  "fixedbitset",
  "nonmax",
+ "smallvec",
+ "static_assertions",
  "tracing",
 ]
 
 [[package]]
 name = "bevy_state"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "bevy_state_macros",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f69ce6a0066eb4626165e2f8c85d3cf4808cfe4cb2027df8840d5cbfe8a3428d"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_state_macros 0.19.1",
+ "bevy_utils 0.19.1",
+ "log",
+ "variadics_please 1.1.0",
+]
+
+[[package]]
+name = "bevy_state"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_state_macros 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "log",
- "variadics_please",
+ "variadics_please 2.0.0",
+]
+
+[[package]]
+name = "bevy_state_macros"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a36dd49049023a0abbd0bd1e2b99580ed83a18c5351c64caba4c06e3b584cf9c"
+dependencies = [
+ "bevy_macro_utils 0.19.1",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_state_macros"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.19.0",
+ "bevy_macro_utils 0.20.0-dev",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "bevy_tasks"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f787d4ba7237b64b30bd2d690a8cbae1ba775e0eec326711c446654cb720e7c"
+dependencies = [
+ "async-executor",
+ "async-task",
+ "atomic-waker",
+ "bevy_platform 0.19.1",
+ "crossbeam-queue",
+ "derive_more",
+ "futures-lite",
+ "heapless",
+ "web-task",
+]
+
+[[package]]
+name = "bevy_tasks"
+version = "0.20.0-dev"
 dependencies = [
  "async-channel",
  "async-executor",
  "async-task",
  "atomic-waker",
- "bevy_platform",
+ "bevy_platform 0.20.0-dev",
  "concurrent-queue",
  "crossbeam-queue",
  "derive_more",
@@ -1798,21 +2713,22 @@ dependencies = [
 
 [[package]]
 name = "bevy_text"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_clipboard",
- "bevy_color",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_log",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0b275f50fb01b1e2d411326a7750ecc2fe629c48b89997cf2a3c93fe786e076"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_clipboard 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_utils 0.19.1",
  "parley 0.9.0",
  "serde",
  "smallvec",
@@ -1824,15 +2740,56 @@ dependencies = [
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "bevy_text"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_clipboard 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "parley 0.11.0",
+ "serde",
+ "smallvec",
+ "smol_str",
+ "swash",
+ "sys-locale",
+ "thiserror 2.0.20",
+ "tracing",
+ "wgpu-types 30.0.0",
+]
+
+[[package]]
+name = "bevy_time"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6896d83d7ed32a2f89da127b7aeddf01eb702e603897cf5ddac231480a1870e"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "crossbeam-channel",
+ "log",
+ "serde",
+]
+
 [[package]]
 name = "bevy_time"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
  "crossbeam-channel",
  "log",
  "serde",
@@ -1840,15 +2797,31 @@ dependencies = [
 
 [[package]]
 name = "bevy_transform"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_ecs",
- "bevy_math",
- "bevy_reflect",
- "bevy_tasks",
- "bevy_utils",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d94cc6065320ebeb58ae88a0863a4c4c2a642c6db698e283eb50be01a834ca5a"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_tasks 0.19.1",
+ "bevy_utils 0.19.1",
+ "derive_more",
+ "serde",
+ "thiserror 2.0.20",
+]
+
+[[package]]
+name = "bevy_transform"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "derive_more",
  "serde",
  "thiserror 2.0.20",
@@ -1856,31 +2829,32 @@ dependencies = [
 
 [[package]]
 name = "bevy_ui"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a2f97c39dadfef97dbe295fc1ce212825bb9fda2becc8f558d1d7e7d7dbbedf"
 dependencies = [
  "accesskit",
- "bevy_a11y",
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_input",
- "bevy_input_focus",
- "bevy_log",
- "bevy_math",
- "bevy_picking",
- "bevy_platform",
- "bevy_reflect",
- "bevy_sprite",
- "bevy_text",
- "bevy_time",
- "bevy_transform",
- "bevy_utils",
- "bevy_window",
+ "bevy_a11y 0.19.1",
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_input_focus 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_picking 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_sprite 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_time 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_utils 0.19.1",
+ "bevy_window 0.19.1",
  "derive_more",
  "parley 0.9.0",
  "smallvec",
@@ -1891,32 +2865,100 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "bevy_ui"
+version = "0.20.0-dev"
+dependencies = [
+ "accesskit",
+ "bevy_a11y 0.20.0-dev",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_input_focus 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_sprite 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+ "derive_more",
+ "parley 0.11.0",
+ "smallvec",
+ "swash",
+ "taffy",
+ "thiserror 2.0.20",
+ "tracing",
+ "uuid",
+]
+
+[[package]]
+name = "bevy_ui_render"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30a36be1c251417421ee070ecd1a393f0036631f7495564a8c9d4abb6042dc40"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_asset 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_color 0.19.1",
+ "bevy_core_pipeline 0.19.1",
+ "bevy_derive 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_image 0.19.1",
+ "bevy_input_focus 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_mesh 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_render 0.19.1",
+ "bevy_shader 0.19.1",
+ "bevy_sprite 0.19.1",
+ "bevy_sprite_render 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_transform 0.19.1",
+ "bevy_ui 0.19.1",
+ "bevy_utils 0.19.1",
+ "bytemuck",
+ "derive_more",
+ "indexmap",
+ "tracing",
+]
+
 [[package]]
 name = "bevy_ui_render"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_color",
- "bevy_core_pipeline",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_input_focus",
- "bevy_math",
- "bevy_mesh",
- "bevy_platform",
- "bevy_reflect",
- "bevy_render",
- "bevy_shader",
- "bevy_sprite",
- "bevy_sprite_render",
- "bevy_text",
- "bevy_transform",
- "bevy_ui",
- "bevy_utils",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_color 0.20.0-dev",
+ "bevy_core_pipeline 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_input_focus 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_mesh 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_render 0.20.0-dev",
+ "bevy_shader 0.20.0-dev",
+ "bevy_sprite 0.20.0-dev",
+ "bevy_sprite_render 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_ui 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "bytemuck",
  "derive_more",
  "indexmap",
@@ -1925,34 +2967,70 @@ dependencies = [
 
 [[package]]
 name = "bevy_ui_widgets"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a71063099a056a010bdbbcc1f1daf2d50bff517d69d62e5334d4c32d7bf9e9e0"
 dependencies = [
  "accesskit",
- "bevy_a11y",
- "bevy_app",
- "bevy_camera",
- "bevy_ecs",
- "bevy_input",
- "bevy_input_focus",
- "bevy_log",
- "bevy_math",
- "bevy_picking",
- "bevy_reflect",
- "bevy_text",
- "bevy_ui",
- "bevy_window",
+ "bevy_a11y 0.19.1",
+ "bevy_app 0.19.1",
+ "bevy_camera 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_input_focus 0.19.1",
+ "bevy_log 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_picking 0.19.1",
+ "bevy_reflect 0.19.1",
+ "bevy_text 0.19.1",
+ "bevy_ui 0.19.1",
+ "bevy_window 0.19.1",
  "parley 0.9.0",
  "smol_str",
 ]
 
+[[package]]
+name = "bevy_ui_widgets"
+version = "0.20.0-dev"
+dependencies = [
+ "accesskit",
+ "bevy_a11y 0.20.0-dev",
+ "bevy_app 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_input_focus 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_picking 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_text 0.20.0-dev",
+ "bevy_time 0.20.0-dev",
+ "bevy_ui 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
+ "parley 0.11.0",
+ "smol_str",
+]
+
+[[package]]
+name = "bevy_utils"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de51fa7ea2e95d4c2d1278c5629285d59eec951cc60c992964c03f30910ef5a1"
+dependencies = [
+ "async-channel",
+ "bevy_platform 0.19.1",
+ "disqualified",
+ "indexmap",
+ "thread_local",
+]
+
 [[package]]
 name = "bevy_utils"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "async-channel",
- "bevy_platform",
+ "bevy_platform 0.20.0-dev",
  "disqualified",
  "indexmap",
  "thread_local",
@@ -1960,17 +3038,33 @@ dependencies = [
 
 [[package]]
 name = "bevy_window"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_ecs",
- "bevy_image",
- "bevy_input",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38373ee93a9248c14afe41d2025f4aa5e68b004b06ae7702816b180e72b39ea3"
+dependencies = [
+ "bevy_app 0.19.1",
+ "bevy_ecs 0.19.1",
+ "bevy_input 0.19.1",
+ "bevy_math 0.19.1",
+ "bevy_platform 0.19.1",
+ "bevy_reflect 0.19.1",
+ "log",
+ "raw-window-handle",
+ "serde",
+]
+
+[[package]]
+name = "bevy_window"
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
  "log",
  "raw-window-handle",
  "serde",
@@ -1978,50 +3072,48 @@ dependencies = [
 
 [[package]]
 name = "bevy_winit"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
+version = "0.20.0-dev"
 dependencies = [
  "accesskit",
  "accesskit_winit",
  "approx",
- "bevy_a11y",
- "bevy_android",
- "bevy_app",
- "bevy_asset",
- "bevy_derive",
- "bevy_ecs",
- "bevy_image",
- "bevy_input",
- "bevy_input_focus",
- "bevy_log",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_tasks",
- "bevy_window",
+ "bevy_a11y 0.20.0-dev",
+ "bevy_android 0.20.0-dev",
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_image 0.20.0-dev",
+ "bevy_input 0.20.0-dev",
+ "bevy_input_focus 0.20.0-dev",
+ "bevy_log 0.20.0-dev",
+ "bevy_math 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_tasks 0.20.0-dev",
+ "bevy_window 0.20.0-dev",
  "bytemuck",
  "js-sys",
  "tracing",
  "wasm-bindgen",
  "web-sys",
- "wgpu-types 29.0.4",
+ "wgpu-types 30.0.0",
  "winit",
 ]
 
 [[package]]
 name = "bevy_world_serialization"
-version = "0.19.0"
-source = "git+https://github.com/processing/bevy?branch=main#9da7c6250114ee8613ae54ab3ad7bb7e43a2f91b"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_camera",
- "bevy_derive",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "bevy_transform",
- "bevy_utils",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app 0.20.0-dev",
+ "bevy_asset 0.20.0-dev",
+ "bevy_camera 0.20.0-dev",
+ "bevy_derive 0.20.0-dev",
+ "bevy_ecs 0.20.0-dev",
+ "bevy_platform 0.20.0-dev",
+ "bevy_reflect 0.20.0-dev",
+ "bevy_transform 0.20.0-dev",
+ "bevy_utils 0.20.0-dev",
  "derive_more",
  "ron",
  "serde",
@@ -2088,6 +3180,15 @@ dependencies = [
  "bit-vec 0.9.1",
 ]
 
+[[package]]
+name = "bit-set"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d"
+dependencies = [
+ "bit-vec 0.9.1",
+]
+
 [[package]]
 name = "bit-vec"
 version = "0.8.0"
@@ -2350,7 +3451,7 @@ checksum = "157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a"
 dependencies = [
  "glob",
  "libc",
- "libloading 0.8.9",
+ "libloading",
 ]
 
 [[package]]
@@ -2380,15 +3481,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
-[[package]]
-name = "cmake"
-version = "0.1.58"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "cocoa"
 version = "0.20.2"
@@ -2630,104 +3722,52 @@ dependencies = [
 name = "core-video-sys"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34ecad23610ad9757664d644e369246edde1803fcb43ed72876565098a5d3828"
-dependencies = [
- "cfg-if 0.1.10",
- "core-foundation-sys 0.7.0",
- "core-graphics 0.19.2",
- "libc",
- "metal",
- "objc",
-]
-
-[[package]]
-name = "core_maths"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
-dependencies = [
- "libm",
-]
-
-[[package]]
-name = "coreaudio-rs"
-version = "0.14.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58"
-dependencies = [
- "bitflags 2.13.1",
- "libc",
- "objc2-audio-toolbox",
- "objc2-core-audio",
- "objc2-core-audio-types",
- "objc2-core-foundation",
-]
-
-[[package]]
-name = "coremidi"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a57ede822fdaf19280cf1320a5a5d3a522c75c910d01750af1e8122b6ad2595b"
-dependencies = [
- "block2 0.6.2",
- "core-foundation 0.10.1",
- "core-foundation-sys 0.8.7",
- "coremidi-sys",
+checksum = "34ecad23610ad9757664d644e369246edde1803fcb43ed72876565098a5d3828"
+dependencies = [
+ "cfg-if 0.1.10",
+ "core-foundation-sys 0.7.0",
+ "core-graphics 0.19.2",
+ "libc",
+ "metal",
+ "objc",
 ]
 
 [[package]]
-name = "coremidi-sys"
-version = "3.2.1"
+name = "core_maths"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a2b8c2cefa9a8f712213c5a1383ffe428efc8f1a1fd1e2f757be94daf7e256a"
+checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
 dependencies = [
- "core-foundation-sys 0.8.7",
+ "libm",
 ]
 
 [[package]]
-name = "cpal"
-version = "0.17.3"
+name = "coreaudio-rs"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8942da362c0f0d895d7cac616263f2f9424edc5687364dfd1d25ef7eba506d7"
+checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58"
 dependencies = [
- "alsa",
- "coreaudio-rs",
- "dasp_sample",
- "jni 0.21.1",
- "js-sys",
+ "bitflags 2.13.1",
  "libc",
- "mach2 0.5.0",
- "ndk",
- "ndk-context",
- "num-derive",
- "num-traits",
- "objc2 0.6.4",
  "objc2-audio-toolbox",
- "objc2-avf-audio",
  "objc2-core-audio",
  "objc2-core-audio-types",
  "objc2-core-foundation",
- "objc2-foundation 0.3.2",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "windows 0.62.2",
 ]
 
 [[package]]
 name = "cpal"
-version = "0.18.1"
+version = "0.17.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f77b11176c37874be37e8d691c946e31b2b8c357abce9526f6a99eb469e1028"
+checksum = "d8942da362c0f0d895d7cac616263f2f9424edc5687364dfd1d25ef7eba506d7"
 dependencies = [
  "alsa",
- "block2 0.6.2",
  "coreaudio-rs",
  "dasp_sample",
- "jni 0.22.4",
+ "jni 0.21.1",
  "js-sys",
  "libc",
- "mach2 0.6.0",
+ "mach2",
  "ndk",
  "ndk-context",
  "num-derive",
@@ -2743,7 +3783,6 @@ dependencies = [
  "wasm-bindgen-futures",
  "web-sys",
  "windows 0.62.2",
- "windows-core 0.62.2",
 ]
 
 [[package]]
@@ -2855,7 +3894,7 @@ version = "0.18.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3aa12038120eb13347a6ae2ffab1d34efe78150125108627fd85044dd4d6ff1e"
 dependencies = [
- "libloading 0.8.9",
+ "libloading",
 ]
 
 [[package]]
@@ -2950,17 +3989,7 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"
 dependencies = [
- "libloading 0.8.9",
-]
-
-[[package]]
-name = "dlopen2"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60768c353d76ba6dd1b6332a5dbbdd3bc2dddadc2935f4cc6a9d0f17ca8ecb6a"
-dependencies = [
- "libc",
- "windows-sys 0.61.2",
+ "libloading",
 ]
 
 [[package]]
@@ -3135,12 +4164,6 @@ dependencies = [
  "zune-inflate",
 ]
 
-[[package]]
-name = "extended"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
-
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -3202,166 +4225,6 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26b73573e6edcd2af0cdf47bd6cb58f0b3839491263c314eaad1ccf24430e1de"
 
-[[package]]
-name = "firewheel"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cce6a0e2684404563f22daf00caa3672a9fd1503af5c58cd79a544a8221cec6e"
-dependencies = [
- "firewheel-core",
- "firewheel-cpal",
- "firewheel-graph",
- "firewheel-nodes",
- "firewheel-rtaudio",
- "firewheel-symphonium",
- "thiserror 2.0.20",
-]
-
-[[package]]
-name = "firewheel-core"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c793ba83a0c4861d467af68844970bd063249189790f00c7feda5019732466b"
-dependencies = [
- "arrayvec",
- "audioadapter",
- "audioadapter-buffers",
- "audioadapter-sample",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "bitflags 2.13.1",
- "firewheel-macros",
- "glam 0.29.3",
- "glam 0.30.10",
- "glam 0.31.1",
- "glam 0.32.1",
- "num-traits",
- "portable-atomic",
- "ringbuf",
- "smallvec",
- "thiserror 2.0.20",
- "thunderdome",
- "wmidi",
-]
-
-[[package]]
-name = "firewheel-cpal"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cf893a68d8b89fbb6eeca6deb5166fd342cc827bf4ad37d31a973bc861bf038"
-dependencies = [
- "audioadapter-buffers",
- "bevy_platform",
- "cpal 0.18.1",
- "firewheel-core",
- "firewheel-graph",
- "fixed-resample",
- "thiserror 2.0.20",
- "tracing",
-]
-
-[[package]]
-name = "firewheel-graph"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00257afdba7edc48ce1667fc144d453f7bd17674a78450207507ca286e818b82"
-dependencies = [
- "arrayvec",
- "audioadapter",
- "bevy_platform",
- "bevy_reflect",
- "bitflags 2.13.1",
- "firewheel-core",
- "num-traits",
- "ringbuf",
- "smallvec",
- "thiserror 2.0.20",
- "thunderdome",
- "tracing",
- "triple_buffer",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "firewheel-ircam-hrtf"
-version = "0.5.0"
-source = "git+https://github.com/CorvusPrudens/bevy_seedling?branch=master#ab4a88b430d216e8614549926e3532bcec5ce2db"
-dependencies = [
- "bevy_ecs",
- "bevy_reflect",
- "firewheel",
- "glam 0.32.1",
- "hrtf",
-]
-
-[[package]]
-name = "firewheel-macros"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e19ca164d0116746e81d86266ad78d0d57e1be18437439ca6c4c8a97160bec2f"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "toml_edit 0.23.10+spec-1.0.0",
-]
-
-[[package]]
-name = "firewheel-nodes"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f4d58cfbb1c65d19e4490ed81b2e16153ab5e355535ef79aef044583adfcba"
-dependencies = [
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "firewheel-core",
- "num-traits",
- "smallvec",
- "thiserror 2.0.20",
- "triple_buffer",
-]
-
-[[package]]
-name = "firewheel-rtaudio"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a136e3893d1c1b691f355ba7b535e0a7df16ad49b7788aa88805bf473105a755"
-dependencies = [
- "audioadapter-buffers",
- "bevy_platform",
- "firewheel-core",
- "firewheel-graph",
- "rtaudio",
- "thiserror 2.0.20",
- "tracing",
-]
-
-[[package]]
-name = "firewheel-symphonium"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8261282ec848bcd8e64c715fb6d3778e2208819b1c5c015f04bc8709ac5465f"
-dependencies = [
- "bevy_platform",
- "firewheel-core",
- "symphonium",
-]
-
-[[package]]
-name = "fixed-resample"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3505607cc0adc388ce98f59707477c02fbd05a2fa0c1b8c4cf42b71a3cb9c34"
-dependencies = [
- "audioadapter",
- "audioadapter-buffers",
- "ringbuf",
- "rubato 4.0.0",
-]
-
 [[package]]
 name = "fixedbitset"
 version = "0.5.7"
@@ -3478,6 +4341,20 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "fontique"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e04c4750a17111ebd77c3e0aea00476ce33f59235bc4d9e7f0aded5033ad3fc"
+dependencies = [
+ "hashbrown 0.17.1",
+ "linebender_resource_handle",
+ "memmap2",
+ "parlance",
+ "read-fonts 0.40.2",
+ "smallvec",
+]
+
 [[package]]
 name = "foreign-types"
 version = "0.3.2"
@@ -3733,27 +4610,22 @@ dependencies = [
 
 [[package]]
 name = "glam"
-version = "0.29.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8babf46d4c1c9d92deac9f7be466f76dfc4482b6452fc5024b5e8daf6ffeb3ee"
-
-[[package]]
-name = "glam"
-version = "0.30.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19fc433e8437a212d1b6f1e68c7824af3aed907da60afa994e7f542d18d12aa9"
-
-[[package]]
-name = "glam"
-version = "0.31.1"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "556f6b2ea90b8d15a74e0e7bb41671c9bdf38cd9f78c284d750b9ce58a2b5be7"
+checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0"
+dependencies = [
+ "bytemuck",
+ "encase",
+ "libm",
+ "rand 0.10.2",
+ "serde_core",
+]
 
 [[package]]
 name = "glam"
-version = "0.32.1"
+version = "0.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0"
+checksum = "7360bd2cd76e0cd9032d42cf2922155cecea2685b0cfa4630c3246df030bcfd6"
 dependencies = [
  "bytemuck",
  "encase",
@@ -3920,6 +4792,15 @@ dependencies = [
  "svg_fmt",
 ]
 
+[[package]]
+name = "guillotiere"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b17e70c989c36bad147b27a58d148c0741c51448aa5653436547323e524d0ab"
+dependencies = [
+ "euclid",
+]
+
 [[package]]
 name = "half"
 version = "2.7.1"
@@ -3960,6 +4841,18 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "harfrust"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0589ddd0d2935dd2845827ac606b4081c266225d613b268ed2910f832889cab"
+dependencies = [
+ "bitflags 2.13.1",
+ "bytemuck",
+ "read-fonts 0.40.2",
+ "smallvec",
+]
+
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -4034,6 +4927,17 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "hexasphere"
+version = "19.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "163385eff5a0cf606ebe2c10b3a44ab02f4306e83fbd068a64f5e1d72a3049ac"
+dependencies = [
+ "constgebra",
+ "glam 0.33.3",
+ "tinyvec",
+]
+
 [[package]]
 name = "hexf-parse"
 version = "0.2.1"
@@ -4049,17 +4953,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "hrtf"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f4de47a84fd55fa33aa5ef337016814fdc869fdad23e7898b5322fa290248e6"
-dependencies = [
- "byteorder",
- "rubato 0.14.1",
- "rustfft",
-]
-
 [[package]]
 name = "icu_collections"
 version = "2.3.0"
@@ -4337,15 +5230,6 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
-[[package]]
-name = "java-locator"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09c46c1fe465c59b1474e665e85e1256c3893dd00927b8d55f63b09044c1e64f"
-dependencies = [
- "glob",
-]
-
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -4355,9 +5239,7 @@ dependencies = [
  "cesu8",
  "cfg-if 1.0.4",
  "combine",
- "java-locator",
  "jni-sys 0.3.1",
- "libloading 0.7.4",
  "log",
  "thiserror 1.0.69",
  "walkdir",
@@ -4394,21 +5276,6 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "jni-min-helper"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "913370a00ba1851b0f3369b49d0f3e745da2d20d3f15ecc296a64234ccda45f7"
-dependencies = [
- "android-build",
- "dlopen2",
- "jni 0.21.1",
- "libc",
- "log",
- "ndk-context",
- "process_path",
-]
-
 [[package]]
 name = "jni-sys"
 version = "0.3.1"
@@ -4474,7 +5341,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76"
 dependencies = [
  "libc",
- "libloading 0.8.9",
+ "libloading",
  "pkg-config",
 ]
 
@@ -4655,16 +5522,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "libloading"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
-dependencies = [
- "cfg-if 1.0.4",
- "winapi",
-]
-
 [[package]]
 name = "libloading"
 version = "0.8.9"
@@ -4850,12 +5707,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "mach2"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
-
 [[package]]
 name = "malloc_buf"
 version = "0.0.6"
@@ -4902,37 +5753,16 @@ dependencies = [
 [[package]]
 name = "metal"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e198a0ee42bdbe9ef2c09d0b9426f3b2b47d90d93a4a9b0395c4cea605e92dc0"
-dependencies = [
- "bitflags 1.3.2",
- "block",
- "cocoa",
- "core-graphics 0.19.2",
- "foreign-types 0.3.2",
- "log",
- "objc",
-]
-
-[[package]]
-name = "midir"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77c12e74a8604bc07f9a3fcf3d5889a81bc96ca6e07d6a114d63fc0371f3e5a4"
-dependencies = [
- "alsa",
- "cc",
- "coremidi",
- "jni 0.21.1",
- "jni-min-helper",
- "js-sys",
- "libc",
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e198a0ee42bdbe9ef2c09d0b9426f3b2b47d90d93a4a9b0395c4cea605e92dc0"
+dependencies = [
+ "bitflags 1.3.2",
+ "block",
+ "cocoa",
+ "core-graphics 0.19.2",
+ "foreign-types 0.3.2",
  "log",
- "ndk-context",
- "parking_lot",
- "wasm-bindgen",
- "web-sys",
- "windows 0.62.2",
+ "objc",
 ]
 
 [[package]]
@@ -4998,6 +5828,12 @@ dependencies = [
  "nasm-rs",
 ]
 
+[[package]]
+name = "mutants"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc0287524726960e07b119cebd01678f852f147742ae0d925e6a520dca956126"
+
 [[package]]
 name = "naga"
 version = "29.0.4"
@@ -5026,6 +5862,46 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "naga"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23bf0a141a9ab6f07dbb492db53245e464bc9db42f407772d9ae03d83a2c1033"
+dependencies = [
+ "arrayvec",
+ "bit-set 0.10.0",
+ "bitflags 2.13.1",
+ "cfg-if 1.0.4",
+ "cfg_aliases",
+ "codespan-reporting 0.13.1",
+ "half",
+ "hashbrown 0.17.1",
+ "indexmap",
+ "libm",
+ "log",
+ "naga-types",
+ "num-traits",
+ "once_cell",
+ "pp-rs",
+ "rustc-hash 1.1.0",
+ "spirv",
+ "thiserror 2.0.20",
+ "unicode-ident",
+]
+
+[[package]]
+name = "naga-types"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658200ddc25c6c7b860747516d132d1b284c0fafb7a380233acee9a72fb30e11"
+dependencies = [
+ "hashbrown 0.17.1",
+ "indexmap",
+ "rustc-hash 1.1.0",
+ "serde",
+ "thiserror 2.0.20",
+]
+
 [[package]]
 name = "naga_oil"
 version = "0.22.0"
@@ -5035,7 +5911,7 @@ dependencies = [
  "codespan-reporting 0.12.0",
  "data-encoding",
  "indexmap",
- "naga",
+ "naga 29.0.4",
  "regex",
  "rustc-hash 1.1.0",
  "thiserror 2.0.20",
@@ -5044,13 +5920,20 @@ dependencies = [
 ]
 
 [[package]]
-name = "nannou_midi"
-version = "0.1.0"
-source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f713c439c03b4e4614c2ef8ff899932efd0a1c44"
+name = "naga_oil"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c028f8a00a344c5e80c15c4d4f0056c59767c03bad3ad8422f8816e198d9bce7"
 dependencies = [
- "bevy",
- "crossbeam-channel",
- "midir",
+ "codespan-reporting 0.12.0",
+ "data-encoding",
+ "indexmap",
+ "naga 30.0.0",
+ "regex",
+ "rustc-hash 1.1.0",
+ "thiserror 2.0.20",
+ "tracing",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -5058,7 +5941,7 @@ name = "nannou_video"
 version = "0.1.0"
 source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f713c439c03b4e4614c2ef8ff899932efd0a1c44"
 dependencies = [
- "bevy",
+ "bevy 0.19.1",
  "flume",
  "gloo-events",
  "js-sys",
@@ -5076,7 +5959,7 @@ name = "nannou_webcam"
 version = "0.1.0"
 source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f713c439c03b4e4614c2ef8ff899932efd0a1c44"
 dependencies = [
- "bevy",
+ "bevy 0.19.1",
  "console_error_panic_hook",
  "flume",
  "getrandom 0.3.4",
@@ -5509,7 +6392,6 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"
 dependencies = [
- "bitflags 2.13.1",
  "objc2 0.6.4",
  "objc2-foundation 0.3.2",
 ]
@@ -5792,6 +6674,7 @@ dependencies = [
  "bitflags 2.13.1",
  "objc2 0.6.4",
  "objc2-core-foundation",
+ "objc2-core-graphics",
  "objc2-foundation 0.3.2",
  "objc2-metal 0.3.2",
 ]
@@ -5982,10 +6865,28 @@ dependencies = [
  "icu_segmenter",
  "linebender_resource_handle",
  "parlance",
- "parley_data",
+ "parley_data 0.9.0",
  "skrifa 0.42.1",
 ]
 
+[[package]]
+name = "parley"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0478b47dd9885a5e0a4f1c0782ffc42bf6ee8c41dea0917d7a9bcee3e6585fc"
+dependencies = [
+ "fontique 0.11.0",
+ "harfrust 0.10.0",
+ "hashbrown 0.17.1",
+ "icu_normalizer",
+ "icu_properties",
+ "icu_segmenter",
+ "linebender_resource_handle",
+ "parlance",
+ "parley_data 0.11.0",
+ "skrifa 0.43.2",
+]
+
 [[package]]
 name = "parley_data"
 version = "0.9.0"
@@ -5995,6 +6896,15 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "parley_data"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a649e01a1acc917247ee147b56b8a1fa91824acf7117bd003b4204306d601255"
+dependencies = [
+ "icu_properties",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -6193,22 +7103,13 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "primal-check"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc0d895b311e3af9902528fbb8f928688abbd95872819320517cc24ca6b2bd08"
-dependencies = [
- "num-integer",
-]
-
 [[package]]
 name = "proc-macro-crate"
 version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
 dependencies = [
- "toml_edit 0.25.13+spec-1.1.0",
+ "toml_edit",
 ]
 
 [[package]]
@@ -6220,28 +7121,16 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "process_path"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f676f11eb0b3e2ea0fbaee218fa6b806689e2297b8c8adc5bf73df465c4f6171"
-dependencies = [
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "processing"
 version = "0.0.8"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "js-sys",
- "processing_audio",
  "processing_core",
  "processing_cuda",
  "processing_glfw",
  "processing_input",
- "processing_midi",
  "processing_render",
  "processing_video",
  "processing_webcam",
@@ -6252,19 +7141,11 @@ dependencies = [
  "web-sys",
 ]
 
-[[package]]
-name = "processing_audio"
-version = "0.1.0"
-dependencies = [
- "bevy",
- "bevy_seedling",
-]
-
 [[package]]
 name = "processing_core"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "raw-window-handle",
  "thiserror 2.0.20",
  "tracing",
@@ -6274,7 +7155,7 @@ dependencies = [
 name = "processing_cuda"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "bevy_cuda",
  "processing_core",
  "processing_render",
@@ -6284,7 +7165,7 @@ dependencies = [
 name = "processing_ffi"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "cbindgen",
  "half",
  "processing",
@@ -6294,7 +7175,7 @@ dependencies = [
 name = "processing_glfw"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "glfw",
  "processing_core",
  "processing_input",
@@ -6306,16 +7187,7 @@ dependencies = [
 name = "processing_input"
 version = "0.0.5"
 dependencies = [
- "bevy",
- "processing_core",
-]
-
-[[package]]
-name = "processing_midi"
-version = "0.0.5"
-dependencies = [
- "bevy",
- "nannou_midi",
+ "bevy 0.20.0-dev",
  "processing_core",
 ]
 
@@ -6323,7 +7195,7 @@ dependencies = [
 name = "processing_pyo3"
 version = "0.0.8"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "png",
  "processing",
  "processing_cuda",
@@ -6340,14 +7212,14 @@ dependencies = [
 name = "processing_render"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "bevy_naga_reflect",
  "crossbeam-channel",
  "fontique 0.7.0",
  "half",
  "js-sys",
  "lyon",
- "naga",
+ "naga 29.0.4",
  "notosans",
  "objc2 0.6.4",
  "objc2-app-kit 0.3.2",
@@ -6359,7 +7231,7 @@ dependencies = [
  "wasm-bindgen-futures",
  "web-sys",
  "wesl",
- "wgpu",
+ "wgpu 30.0.0",
  "windows 0.58.0",
 ]
 
@@ -6367,7 +7239,7 @@ dependencies = [
 name = "processing_video"
 version = "0.0.1"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "nannou_video",
  "processing_core",
  "processing_render",
@@ -6380,7 +7252,7 @@ dependencies = [
 name = "processing_wasm"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "console_error_panic_hook",
  "getrandom 0.2.17",
  "getrandom 0.3.4",
@@ -6396,7 +7268,7 @@ dependencies = [
 name = "processing_webcam"
 version = "0.0.5"
 dependencies = [
- "bevy",
+ "bevy 0.20.0-dev",
  "nannou_webcam",
  "processing_core",
  "processing_render",
@@ -6747,9 +7619,9 @@ dependencies = [
 
 [[package]]
 name = "read-fonts"
-version = "0.41.0"
+version = "0.40.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
+checksum = "487889119a5f19ff7c0a20637196bdc76b9f54ebec17e3588b5d75e4999f8773"
 dependencies = [
  "bytemuck",
  "font-types 0.12.3",
@@ -6757,12 +7629,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "realfft"
-version = "3.5.0"
+name = "read-fonts"
+version = "0.41.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f821338fddb99d089116342c46e9f1fbf3828dba077674613e734e01d6ea8677"
+checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
 dependencies = [
- "rustfft",
+ "bytemuck",
+ "font-types 0.12.3",
+ "once_cell",
 ]
 
 [[package]]
@@ -6827,12 +7701,6 @@ dependencies = [
  "regex-syntax",
 ]
 
-[[package]]
-name = "regex-lite"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.11"
@@ -6854,24 +7722,13 @@ dependencies = [
  "bytemuck",
 ]
 
-[[package]]
-name = "ringbuf"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a158e09ede21a14b172ca6cdd6208386c6ae2cb6acef58d774368ef8c450dfa7"
-dependencies = [
- "crossbeam-utils",
- "portable-atomic",
- "portable-atomic-util",
-]
-
 [[package]]
 name = "rodio"
 version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a536bb79db59098ef71a4dd4246c02eb87b316deceb1b68e0cde7167ec01eb"
 dependencies = [
- "cpal 0.17.3",
+ "cpal",
  "dasp_sample",
  "lewton",
  "num-rational",
@@ -6902,56 +7759,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "rtaudio"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7384a8837efe4abea0e53f3887b5072cbbd1ee95c298cff4fbd7a9f3ff23a48b"
-dependencies = [
- "bitflags 2.13.1",
- "rtaudio-sys",
- "thiserror 2.0.20",
- "tracing",
-]
-
-[[package]]
-name = "rtaudio-sys"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "931ec9a72c48e96e8e2f9868aef1d4e452723354779d01159f7399647427b57b"
-dependencies = [
- "cmake",
- "pkg-config",
-]
-
-[[package]]
-name = "rubato"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6dd52e80cfc21894deadf554a5673002938ae4625f7a283e536f9cf7c17b0d5"
-dependencies = [
- "num-complex",
- "num-integer",
- "num-traits",
- "realfft",
-]
-
-[[package]]
-name = "rubato"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f57c655d11e929f05a8663b323ff553f8d9773be05dfdc087795955bedeb8d92"
-dependencies = [
- "audioadapter",
- "audioadapter-buffers",
- "num-complex",
- "num-integer",
- "num-traits",
- "realfft",
- "visibility",
- "windowfunctions",
-]
-
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -6973,20 +7780,6 @@ dependencies = [
  "semver",
 ]
 
-[[package]]
-name = "rustfft"
-version = "6.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21db5f9893e91f41798c88680037dba611ca6674703c1a18601b01a72c8adb89"
-dependencies = [
- "num-complex",
- "num-integer",
- "num-traits",
- "primal-check",
- "strength_reduce",
- "transpose",
-]
-
 [[package]]
 name = "rustix"
 version = "0.38.44"
@@ -7234,6 +8027,16 @@ dependencies = [
  "read-fonts 0.39.2",
 ]
 
+[[package]]
+name = "skrifa"
+version = "0.43.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cbe997d0f2480442d727488fbe2150779114cbe480ecdbadef58b33e0318ffb"
+dependencies = [
+ "bytemuck",
+ "read-fonts 0.40.2",
+]
+
 [[package]]
 name = "skrifa"
 version = "0.44.0"
@@ -7334,174 +8137,58 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "stackfuture"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "115beb9c69db2393ff10b75a1b8587a51716e5551d015001e55320ed279d32f9"
-dependencies = [
- "const_panic",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "strength_reduce"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
-
-[[package]]
-name = "strict-num"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
-
-[[package]]
-name = "string_cache"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
-dependencies = [
- "new_debug_unreachable",
- "parking_lot",
- "phf_shared",
- "precomputed-hash",
-]
-
-[[package]]
-name = "strsim"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
-[[package]]
-name = "svg_fmt"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0193cc4331cfd2f3d2011ef287590868599a2f33c3e69bc22c1a3d3acf9e02fb"
-
-[[package]]
-name = "swash"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e"
-dependencies = [
- "skrifa 0.44.0",
- "yazi",
- "zeno",
-]
-
-[[package]]
-name = "symphonia"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7edef6a96b696d4e0cab5ee9ebb7ca155ed95f30a6b45bbb8b97d2727f02424"
-dependencies = [
- "lazy_static",
- "symphonia-codec-pcm",
- "symphonia-codec-vorbis",
- "symphonia-core",
- "symphonia-format-ogg",
- "symphonia-format-riff",
- "symphonia-metadata",
-]
-
-[[package]]
-name = "symphonia-codec-pcm"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e04ba75686acbe43542fdd374571195f0530c0b7785ca25cc6840e9c6c4b6eea"
-dependencies = [
- "log",
- "symphonia-core",
-]
-
-[[package]]
-name = "symphonia-codec-vorbis"
-version = "0.6.1"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73d90b4fcf796137cc683c538282804ff9629f8ad9dbfd881fcbba331ac4e986"
+checksum = "115beb9c69db2393ff10b75a1b8587a51716e5551d015001e55320ed279d32f9"
 dependencies = [
- "log",
- "symphonia-common",
- "symphonia-core",
+ "const_panic",
 ]
 
 [[package]]
-name = "symphonia-common"
-version = "0.6.1"
+name = "static_assertions"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acc3fcc18ec9b8cdd48614e259c4cf0d27b71d41e5d9b120b42c5adab12d7c4"
-dependencies = [
- "log",
- "symphonia-core",
- "symphonia-metadata",
-]
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
-name = "symphonia-core"
-version = "0.6.1"
+name = "strict-num"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01c412864d599d4750d0c3d684d7e093ec05e5309681ef5252cc1096a437f6e0"
-dependencies = [
- "bitflags 2.13.1",
- "bytemuck",
- "lazy_static",
- "log",
- "num-complex",
- "rustfft",
- "smallvec",
-]
+checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
 
 [[package]]
-name = "symphonia-format-ogg"
-version = "0.6.1"
+name = "string_cache"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b5495e7f7e3c7035328d82b6d6e377eef289bb0c4105bdeb557fc93a833f994"
+checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
 dependencies = [
- "log",
- "symphonia-common",
- "symphonia-core",
- "symphonia-metadata",
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared",
+ "precomputed-hash",
 ]
 
 [[package]]
-name = "symphonia-format-riff"
-version = "0.6.1"
+name = "strsim"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ff70929083a8c1a5f6cd7c904b6071c7914ad04739b510c2f7239dfc9b7dabe"
-dependencies = [
- "extended",
- "log",
- "symphonia-core",
- "symphonia-metadata",
-]
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
-name = "symphonia-metadata"
-version = "0.6.1"
+name = "svg_fmt"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83713a97705d77bdef7cdbc0768fd6e5a54e4cd7e48d60a806ae85639e2c87c6"
-dependencies = [
- "lazy_static",
- "log",
- "regex-lite",
- "smallvec",
- "symphonia-core",
-]
+checksum = "0193cc4331cfd2f3d2011ef287590868599a2f33c3e69bc22c1a3d3acf9e02fb"
 
 [[package]]
-name = "symphonium"
-version = "0.12.2"
+name = "swash"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cc514081a8a6eb44a4ee5e68d981bf11d976876d0612082121969b31e7d53a8"
+checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e"
 dependencies = [
- "fixed-resample",
- "symphonia",
- "tracing",
+ "skrifa 0.44.0",
+ "yazi",
+ "zeno",
 ]
 
 [[package]]
@@ -7548,9 +8235,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.38.4"
+version = "0.39.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92ab6a2f8bfe508deb3c6406578252e491d299cbbf3bc0529ecc3313aee4a52f"
+checksum = "d2071df9448915b71c4fe6d25deaf1c22f12bd234f01540b77312bb8e41361e6"
 dependencies = [
  "libc",
  "memchr",
@@ -7658,12 +8345,6 @@ dependencies = [
  "cfg-if 1.0.4",
 ]
 
-[[package]]
-name = "thunderdome"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e170f93360bf9ae6fe3c31116bbf27adb1d054cedd6bc3d7857e34f2d98d0b"
-
 [[package]]
 name = "tiff"
 version = "0.11.3"
@@ -7762,18 +8443,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "toml_edit"
-version = "0.23.10+spec-1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
-dependencies = [
- "indexmap",
- "toml_datetime 0.7.5+spec-1.1.0",
- "toml_parser",
- "winnow 0.7.15",
-]
-
 [[package]]
 name = "toml_edit"
 version = "0.25.13+spec-1.1.0"
@@ -7885,25 +8554,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "transpose"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
-dependencies = [
- "num-integer",
- "strength_reduce",
-]
-
-[[package]]
-name = "triple_buffer"
-version = "9.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e875ab7068a75b74f419da453927e05527c36f0001b3c7aad3ce443640683487"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "ttf-parser"
 version = "0.25.1"
@@ -7958,6 +8608,17 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unsynn"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501a7adf1a4bd9951501e5c66621e972ef8874d787628b7f90e64f936ef7ec0a"
+dependencies = [
+ "mutants",
+ "proc-macro2",
+ "rustc-hash 2.1.3",
+]
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -8042,6 +8703,16 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "variadics_please"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b53d0f7f2d0182759a549f1f313ce16b07d8f9ba93098157b5fa10ee3e61117f"
+dependencies = [
+ "quote",
+ "unsynn",
+]
+
 [[package]]
 name = "vcpkg"
 version = "0.2.15"
@@ -8071,17 +8742,6 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "visibility"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d674d135b4a8c1d7e813e2f8d1c9a58308aee4a680323066025e53132218bd91"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -8361,7 +9021,7 @@ dependencies = [
  "hashbrown 0.16.1",
  "js-sys",
  "log",
- "naga",
+ "naga 29.0.4",
  "parking_lot",
  "portable-atomic",
  "profiling",
@@ -8371,11 +9031,41 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "wgpu-core",
- "wgpu-hal",
+ "wgpu-core 29.0.4",
+ "wgpu-hal 29.0.4",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "wgpu"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d8f4bd44d92da5270f03409dba9f952dab24f128e05d6a554926101d1bf9114"
+dependencies = [
+ "arrayvec",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "cfg-if 1.0.4",
+ "cfg_aliases",
+ "document-features",
+ "hashbrown 0.17.1",
+ "js-sys",
+ "log",
+ "naga 30.0.0",
+ "parking_lot",
+ "portable-atomic",
+ "profiling",
+ "raw-window-handle",
+ "smallvec",
+ "static_assertions",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "wgpu-core 30.0.0",
+ "wgpu-hal 30.0.0",
+ "wgpu-types 30.0.0",
+]
+
 [[package]]
 name = "wgpu-core"
 version = "29.0.4"
@@ -8392,7 +9082,7 @@ dependencies = [
  "hashbrown 0.16.1",
  "indexmap",
  "log",
- "naga",
+ "naga 29.0.4",
  "once_cell",
  "parking_lot",
  "portable-atomic",
@@ -8401,22 +9091,65 @@ dependencies = [
  "rustc-hash 1.1.0",
  "smallvec",
  "thiserror 2.0.20",
- "wgpu-core-deps-apple",
- "wgpu-core-deps-emscripten",
- "wgpu-core-deps-wasm",
- "wgpu-core-deps-windows-linux-android",
- "wgpu-hal",
- "wgpu-naga-bridge",
+ "wgpu-core-deps-apple 29.0.4",
+ "wgpu-core-deps-emscripten 29.0.4",
+ "wgpu-core-deps-windows-linux-android 29.0.4",
+ "wgpu-hal 29.0.4",
+ "wgpu-naga-bridge 29.0.4",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "wgpu-core"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08763620e76fc980bca7bf84de82568614487a53172dd968d89187282eb87fa2"
+dependencies = [
+ "arrayvec",
+ "bit-set 0.10.0",
+ "bit-vec 0.9.1",
+ "bitflags 2.13.1",
+ "bytemuck",
+ "cfg_aliases",
+ "document-features",
+ "hashbrown 0.17.1",
+ "indexmap",
+ "log",
+ "naga 30.0.0",
+ "naga-types",
+ "once_cell",
+ "parking_lot",
+ "portable-atomic",
+ "profiling",
+ "raw-window-handle",
+ "rustc-hash 1.1.0",
+ "smallvec",
+ "thiserror 2.0.20",
+ "wgpu-core-deps-apple 30.0.0",
+ "wgpu-core-deps-emscripten 30.0.0",
+ "wgpu-core-deps-wasm",
+ "wgpu-core-deps-windows-linux-android 30.0.0",
+ "wgpu-hal 30.0.0",
+ "wgpu-naga-bridge 30.0.0",
+ "wgpu-types 30.0.0",
+]
+
 [[package]]
 name = "wgpu-core-deps-apple"
 version = "29.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f5e39e26c4c0e07589e67d18546cf79ff45383659fc72fca4dd293358a0347f3"
 dependencies = [
- "wgpu-hal",
+ "wgpu-hal 29.0.4",
+]
+
+[[package]]
+name = "wgpu-core-deps-apple"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3283b6da70d7fc892de95840215aa36381b5d0cbc479e88ee2b173c7b992b225"
+dependencies = [
+ "wgpu-hal 30.0.0",
 ]
 
 [[package]]
@@ -8425,16 +9158,25 @@ version = "29.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "01e09be551dc939498bdd5f6b2c66e55ab275dad25825267a08605a80fc9f0af"
 dependencies = [
- "wgpu-hal",
+ "wgpu-hal 29.0.4",
+]
+
+[[package]]
+name = "wgpu-core-deps-emscripten"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85dcf2b2e5c2afb9eda64c570a87a4e570304bf39e52eddbaaf222d655b656ad"
+dependencies = [
+ "wgpu-hal 30.0.0",
 ]
 
 [[package]]
 name = "wgpu-core-deps-wasm"
-version = "29.0.4"
+version = "30.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1fb1798be2a912497d4c224f72d39bb0cb34af50e8bcc29865bc339c943059"
+checksum = "2b6c13228950f36a56023976a6c4ee6714b27fb40e3d52a33f7d3bb6d109c0b1"
 dependencies = [
- "wgpu-hal",
+ "wgpu-hal 30.0.0",
 ]
 
 [[package]]
@@ -8443,7 +9185,16 @@ version = "29.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e592c1bbef6ad047647ae6e666ebd8cee7a32bb4544d9700ec96cbf73230257"
 dependencies = [
- "wgpu-hal",
+ "wgpu-hal 29.0.4",
+]
+
+[[package]]
+name = "wgpu-core-deps-windows-linux-android"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f76bc9c1c186ff3d9054e0d224c93c8c1c79d6653907c5249a5c1ea1a2cb1e43"
+dependencies = [
+ "wgpu-hal 30.0.0",
 ]
 
 [[package]]
@@ -8469,9 +9220,9 @@ dependencies = [
  "js-sys",
  "khronos-egl",
  "libc",
- "libloading 0.8.9",
+ "libloading",
  "log",
- "naga",
+ "naga 29.0.4",
  "ndk-sys",
  "objc2 0.6.4",
  "objc2-core-foundation",
@@ -8493,23 +9244,89 @@ dependencies = [
  "wasm-bindgen",
  "wayland-sys",
  "web-sys",
- "wgpu-naga-bridge",
+ "wgpu-naga-bridge 29.0.4",
  "wgpu-types 29.0.4",
  "windows 0.62.2",
  "windows-core 0.62.2",
  "windows-result 0.4.1",
 ]
 
+[[package]]
+name = "wgpu-hal"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf765132d8d5f50e192e7880464890c13f4e7457aafe8e5466e8174586e9f101"
+dependencies = [
+ "android_system_properties",
+ "arrayvec",
+ "ash",
+ "bit-set 0.10.0",
+ "bitflags 2.13.1",
+ "block2 0.6.2",
+ "bytemuck",
+ "cfg-if 1.0.4",
+ "cfg_aliases",
+ "glow",
+ "glutin_wgl_sys",
+ "gpu-allocator",
+ "hashbrown 0.17.1",
+ "js-sys",
+ "khronos-egl",
+ "libc",
+ "libloading",
+ "log",
+ "naga 30.0.0",
+ "naga-types",
+ "ndk-sys",
+ "objc2 0.6.4",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation 0.3.2",
+ "objc2-metal 0.3.2",
+ "objc2-quartz-core 0.3.2",
+ "once_cell",
+ "ordered-float",
+ "parking_lot",
+ "portable-atomic",
+ "portable-atomic-util",
+ "profiling",
+ "range-alloc",
+ "raw-window-handle",
+ "raw-window-metal",
+ "renderdoc-sys",
+ "smallvec",
+ "static_assertions",
+ "thiserror 2.0.20",
+ "wasm-bindgen",
+ "wayland-sys",
+ "web-sys",
+ "wgpu-naga-bridge 30.0.0",
+ "wgpu-types 30.0.0",
+ "windows 0.62.2",
+ "windows-core 0.62.2",
+ "windows-result 0.4.1",
+]
+
 [[package]]
 name = "wgpu-naga-bridge"
 version = "29.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95226013f547544b223281cd16a4fb549aa9dcb562adbda0faae4c73ffbbc161"
 dependencies = [
- "naga",
+ "naga 29.0.4",
  "wgpu-types 29.0.4",
 ]
 
+[[package]]
+name = "wgpu-naga-bridge"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9eaac644e5008925c78567d272b9d66ef83da55a53cc17fc7daade7bb6e66e5"
+dependencies = [
+ "naga 30.0.0",
+ "wgpu-types 30.0.0",
+]
+
 [[package]]
 name = "wgpu-types"
 version = "28.0.0"
@@ -8538,6 +9355,23 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wgpu-types"
+version = "30.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a9c93c2b35edde326df60ffdee4c0f5864eac3011d6768b70d43f028ad93565"
+dependencies = [
+ "bitflags 2.13.1",
+ "bytemuck",
+ "js-sys",
+ "log",
+ "naga-types",
+ "raw-window-handle",
+ "serde",
+ "static_assertions",
+ "web-sys",
+]
+
 [[package]]
 name = "wgsl-parse"
 version = "0.3.2"
@@ -8609,15 +9443,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windowfunctions"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90628d739333b7c5d2ee0b70210b97b8cddc38440c682c96fd9e2c24c2db5f3a"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "windows"
 version = "0.58.0"
@@ -9080,9 +9905,6 @@ name = "winnow"
 version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
-dependencies = [
- "memchr",
-]
 
 [[package]]
 name = "winnow"
@@ -9099,12 +9921,6 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
-[[package]]
-name = "wmidi"
-version = "4.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b1b1e28ac6301b1c097d21c11130090f7ecc5db9d5ef4e52595ab942f8d76d5"
-
 [[package]]
 name = "writeable"
 version = "0.6.4"
@@ -9141,7 +9957,7 @@ dependencies = [
  "as-raw-xcb-connection",
  "gethostname",
  "libc",
- "libloading 0.8.9",
+ "libloading",
  "once_cell",
  "rustix 1.1.4",
  "x11rb-protocol",
diff --git a/Cargo.toml b/Cargo.toml
index 26463fc7..70a72e76 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,13 +18,15 @@ cuda = ["dep:processing_cuda", "processing_cuda/cuda"]
 [workspace]
 resolver = "3"
 members = ["crates/*", "tools/*"]
+# TEMP(bevy-020): midi/audio pin bevy 0.19
+exclude = ["crates/processing_audio", "crates/processing_midi"]
 
 [workspace.lints.clippy]
 type_complexity = "allow"
 too_many_arguments = "allow"
 
 [workspace.dependencies]
-bevy = { git = "https://github.com/processing/bevy", branch = "main", default-features = false, features = [
+bevy = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase", default-features = false, features = [
   # 2d
   "2d_bevy_render",
   "default_app",
@@ -54,7 +56,7 @@ bevy = { git = "https://github.com/processing/bevy", branch = "main", default-fe
   "pan_camera",
   
 ] }
-bevy_naga_reflect = { git = "https://github.com/tychedelia/bevy_naga_reflect" }
+bevy_naga_reflect = { path = "/Users/char/src/github.com/tychedelia/bevy_naga_reflect-020" }
 bevy_cuda = { git = "https://github.com/tychedelia/bevy_cuda" }
 naga = { version = "29", features = ["wgsl-in"] }
 wesl = { version = "0.3", default-features = false }
@@ -65,8 +67,9 @@ processing_core = { path = "crates/processing_core" }
 processing_cuda = { path = "crates/processing_cuda" }
 processing_pyo3 = { path = "crates/processing_pyo3" }
 processing_render = { path = "crates/processing_render" }
-processing_midi = { path = "crates/processing_midi" }
-processing_audio = { path = "crates/processing_audio" }
+# TEMP(bevy-020): midi/audio pin bevy 0.19
+# processing_midi = { path = "crates/processing_midi" }
+# processing_audio = { path = "crates/processing_audio" }
 processing_input = { path = "crates/processing_input" }
 processing_glfw = { path = "crates/processing_glfw" }
 processing_video = { path = "crates/processing_video" }
@@ -78,8 +81,9 @@ rand_distr = "0.6"
 bevy = { workspace = true }
 processing_core = { workspace = true }
 processing_render = { workspace = true }
-processing_midi = { workspace = true }
-processing_audio = { workspace = true }
+# TEMP(bevy-020)
+# processing_midi = { workspace = true }
+# processing_audio = { workspace = true }
 processing_input = { workspace = true }
 processing_video = { workspace = true, optional = true }
 processing_webcam = { workspace = true, optional = true }
@@ -101,22 +105,22 @@ processing_glfw = { workspace = true, features = ["wayland"] }
 
 ## TODO: Remove these patches once we've moved back to depending on upstream bevy
 [patch."https://github.com/bevyengine/bevy"]
-bevy = { git = "https://github.com/processing/bevy", branch = "main" }
+bevy = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase" }
 
 [patch.crates-io]
-bevy = { git = "https://github.com/processing/bevy", branch = "main" }
+bevy = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase" }
 # bevy_seedling depends on bevy sub-crates directly, so they must be patched too
-bevy_app = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_asset = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_diagnostic = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_ecs = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_log = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_math = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_platform = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_reflect = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_time = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_transform = { git = "https://github.com/processing/bevy", branch = "main" }
-bevy_utils = { git = "https://github.com/processing/bevy", branch = "main" }
+bevy_app = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_app" }
+bevy_asset = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_asset" }
+bevy_diagnostic = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_diagnostic" }
+bevy_ecs = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_ecs" }
+bevy_log = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_log" }
+bevy_math = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_math" }
+bevy_platform = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_platform" }
+bevy_reflect = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_reflect" }
+bevy_time = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_time" }
+bevy_transform = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_transform" }
+bevy_utils = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase/crates/bevy_utils" }
 
 [[example]]
 name = "rectangle"
diff --git a/assets/shaders/plexus_link.wesl b/assets/shaders/plexus_link.wesl
index 9b375f0b..0b701255 100644
--- a/assets/shaders/plexus_link.wesl
+++ b/assets/shaders/plexus_link.wesl
@@ -1,3 +1,17 @@
+// Proximity linker with per-edge alpha falloff — the Generative-Gestaltung
+// "lissajous, all points connected" effect (M_2_5_01), on the GPU.
+//
+// For each source particle we walk the spatial grid and, for every OTHER
+// particle within `connection_radius`, add a line whose alpha falls off with
+// the edge's length: a = (1 / (d/R + 1))^ramp. Short links are near-opaque,
+// long links fade out.
+//
+// The dynamic topology is handled by `processing::prims`: the sketch applies
+// this kernel with `p.apply(link, primitives=edges)` and the engine takes
+// care of counts, capacity, and indirect drawing.
+
+import { processing::prims };
+
 struct GridParams {
     grid_min: vec3<f32>,
     cell_size: f32,
@@ -9,23 +23,19 @@ struct GridParams {
 
 struct Params {
     connection_radius: f32,
-    connection_ramp: f32,  // falloff exponent
-    line_alpha: f32,       // opacity scale
-    max_links: u32,        // per-particle edge cap
+    connection_ramp: f32,  // falloff exponent (p5 uses 6)
+    line_alpha: f32,       // overall opacity scale (p5's lineAlpha)
+    _pad: f32,
 }
 
 // Auto-bound by apply(): names must be position/color.
-@group(0) @binding(0) var<storage, read>       position:  array<f32>;
-@group(0) @binding(1) var<storage, read>       color:     array<f32>;
-@group(0) @binding(2) var<storage, read_write> edge_pos:  array<f32>;
-@group(0) @binding(3) var<storage, read_write> edge_col:  array<f32>;
-@group(0) @binding(4) var<storage, read_write> indices:   array<u32>;
-@group(0) @binding(5) var<storage, read_write> draw_args: array<atomic<u32>>;
+@group(0) @binding(0) var<storage, read> position: array<f32>;
+@group(0) @binding(1) var<storage, read> color:    array<f32>;
 // Bound by grid.bind().
-@group(0) @binding(6) var<storage, read>       offsets:   array<u32>;
-@group(0) @binding(7) var<storage, read>       sorted:    array<u32>;
-@group(0) @binding(8) var<uniform>             params:    Params;
-@group(0) @binding(9) var<uniform>             gp:        GridParams;
+@group(0) @binding(2) var<storage, read> offsets:  array<u32>;
+@group(0) @binding(3) var<storage, read> sorted:   array<u32>;
+@group(0) @binding(4) var<uniform>       params:   Params;
+@group(0) @binding(5) var<uniform>       gp:       GridParams;
 
 fn cell_coords(p: vec3<f32>, grid_min: vec3<f32>, cell_size: f32, dims: vec3<u32>) -> vec3<i32> {
     let rel = (p - grid_min) / cell_size;
@@ -48,24 +58,12 @@ fn load_rgb(i: u32) -> vec3<f32> {
     return vec3<f32>(color[i * 4u], color[i * 4u + 1u], color[i * 4u + 2u]);
 }
 
-fn emit_vertex(slot: u32, p: vec3<f32>, rgb: vec3<f32>, a: f32) {
-    edge_pos[slot * 3u + 0u] = p.x;
-    edge_pos[slot * 3u + 1u] = p.y;
-    edge_pos[slot * 3u + 2u] = p.z;
-    edge_col[slot * 4u + 0u] = rgb.x;
-    edge_col[slot * 4u + 1u] = rgb.y;
-    edge_col[slot * 4u + 2u] = rgb.z;
-    edge_col[slot * 4u + 3u] = a;
-    indices[slot] = slot;
-}
-
 @compute @workgroup_size(64)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let i = gid.x;
     let count = arrayLength(&position) / 3u;
     if i >= count { return; }
 
-    let cap = arrayLength(&indices);
     let pos = load_pos(i);
     let rgb = load_rgb(i);
     let radius = params.connection_radius;
@@ -81,7 +79,6 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let x0 = max(base.x - reach, 0);
     let x1 = min(base.x + reach, i32(gp.dims_x) - 1);
 
-    var emitted = 0u;
     for (var cz = z0; cz <= z1; cz++) {
         for (var cy = y0; cy <= y1; cy++) {
             for (var cx = x0; cx <= x1; cx++) {
@@ -96,17 +93,16 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
                     let d2 = dot(diff, diff);
                     if d2 > r2 { continue; }
 
-                    if emitted >= params.max_links { return; }
-                    emitted += 1u;
-
+                    // Per-edge alpha: short links solid, long links fade out.
                     let d = sqrt(d2);
-                    let a = pow(1.0 / (d / radius + 1.0), params.connection_ramp) * params.line_alpha;
+                    let a = pow(1.0 / (d / radius + 1.0), params.connection_ramp)
+                        * params.line_alpha;
 
-                    let slot = atomicAdd(&draw_args[0], 2u);
-                    if slot + 1u < cap {
-                        emit_vertex(slot, pos, rgb, a);
-                        emit_vertex(slot + 1u, pj, load_rgb(j), a);
-                    }
+                    var v0 = prims::vertex(pos);
+                    v0.color = vec4<f32>(rgb, a);
+                    var v1 = prims::vertex(pj);
+                    v1.color = vec4<f32>(load_rgb(j), a);
+                    prims::line(v0, v1);
                 }
             }
         }
diff --git a/crates/processing_ffi/src/lib.rs b/crates/processing_ffi/src/lib.rs
index 731722cc..e69de277 100644
--- a/crates/processing_ffi/src/lib.rs
+++ b/crates/processing_ffi/src/lib.rs
@@ -3809,6 +3809,14 @@ pub extern "C" fn processing_particles_apply(particles_id: u64, compute_id: u64)
     });
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_flock(particles_id: u64, flock_id: u64) {
+    error::clear_error();
+    error::check(|| {
+        particles_flock_auto(Entity::from_bits(particles_id), Entity::from_bits(flock_id))
+    });
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_particles_draw(graphics_id: u64, particles_id: u64, geometry_id: u64) {
     error::clear_error();
diff --git a/crates/processing_pyo3/examples/particles_lissajous.py b/crates/processing_pyo3/examples/particles_lissajous.py
index 6bfa291c..efd7fa1f 100644
--- a/crates/processing_pyo3/examples/particles_lissajous.py
+++ b/crates/processing_pyo3/examples/particles_lissajous.py
@@ -10,45 +10,40 @@
     alpha_op=BlendMode.OP_ADD,
 )
 
-N =  10000 # points on the curve
+N = 10000
 SCALE = 10.0
 FX, FY, FZ = 3.0, 4.0, 5.0
 
 CONNECTION_RADIUS = 3.5  # link points closer than this
-CONNECTION_RAMP = 7.0    # alpha = (1/(d/R + 1))^ramp
-LINE_ALPHA = 0.2        # overall opacity scale
-MAX_LINKS = 4000           # per-point edge cap (bounds the edge buffer)
+CONNECTION_RAMP = 6.0    # alpha = (1/(d/R + 1))^ramp
+LINE_ALPHA = 0.5         # overall opacity scale
+MAX_LINES = 2_000_000    # capacity of the dynamic line set (extra dropped, see edges.overflowed())
 HUE_MIX = 0.0            # 0 = grayscale, 1 = rainbow
 
-p = None       # curve points (source)
-edges = None   # emitted line vertices (drawn)
+p = None
+edges = None
 curve = None
 link = None
 grid = None
-idx = None
 
 
 def setup():
-    global p, edges, curve, link, grid, idx
+    global p, edges, curve, link, grid
     size(1000, 800)
     window_title(f"Lissajous — all points connected — {N:,} pts")
     mode_3d()
     bloom(0.0)
 
     p = create_particles(capacity=N, attributes=[Attribute.position(), Attribute.color()])
-    # One line = 2 vertices; up to N*MAX_LINKS lines.
-    edges = create_particles(
-        capacity=N * MAX_LINKS * 2, attributes=[Attribute.position(), Attribute.color()]
-    )
-    idx = edges.index_buffer(N * MAX_LINKS * 2)  # link fills indices + the dynamic count
+    edges = p.primitives("lines", capacity=MAX_LINES)
 
     cells = int((2.0 * SCALE + 2.0) / CONNECTION_RADIUS) + 1
     grid = p.create_grid(
         min=[-SCALE - 1.0] * 3, cell_size=CONNECTION_RADIUS, dims=[cells, cells, cells]
     )
-
     curve = create_compute(load_shader("shaders/plexus_curve.wesl"))
     link = create_compute(load_shader("shaders/plexus_link.wesl"))
+    orbit_camera()
 
 
 def draw():
@@ -56,30 +51,21 @@ def draw():
     background(255, 255, 255)
 
     t = elapsed_time
-    r = 26.0
-    camera_position(cos(t * 0.08) * r, sin(t * 0.05) * r * 0.55, sin(t * 0.08) * r)
-    camera_look_at(0.0, 0.0, 0.0)
 
     curve.set(count=N, time=t, fx=FX, fy=FY, fz=FZ, loops=1.0, scale=SCALE, hue_mix=HUE_MIX)
     p.apply(curve)
 
     grid.build(p.buffer("position"))
-    edges.reset_indices()
     link.set(
-        edge_pos=edges.buffer("position"),
-        edge_col=edges.buffer("color"),
-        indices=idx,
-        draw_args=edges.draw_args(),
         connection_radius=CONNECTION_RADIUS,
         connection_ramp=CONNECTION_RAMP,
         line_alpha=LINE_ALPHA,
-        max_links=MAX_LINKS,
     )
     grid.bind(link)
-    p.apply(link)
+    p.apply(link, primitives=edges)
 
     blend_mode(ALPHA_OVER)
-    particles(edges, topology="lines")
+    particles(edges)
 
 
 run()
diff --git a/crates/processing_pyo3/src/color.rs b/crates/processing_pyo3/src/color.rs
index 6aef7072..bcba1b5d 100644
--- a/crates/processing_pyo3/src/color.rs
+++ b/crates/processing_pyo3/src/color.rs
@@ -124,6 +124,8 @@ fn components(color: &Color) -> [f32; 4] {
         Color::Lcha(c) => c.to_f32_array(),
         Color::Oklaba(c) => c.to_f32_array(),
         Color::Oklcha(c) => c.to_f32_array(),
+        Color::Okhsla(c) => c.to_f32_array(),
+        Color::Okhsva(c) => c.to_f32_array(),
         Color::Xyza(c) => c.to_f32_array(),
     }
 }
@@ -140,6 +142,8 @@ fn components_no_alpha(color: &Color) -> [f32; 3] {
         Color::Lcha(c) => c.to_f32_array_no_alpha(),
         Color::Oklaba(c) => c.to_f32_array_no_alpha(),
         Color::Oklcha(c) => c.to_f32_array_no_alpha(),
+        Color::Okhsla(c) => c.to_f32_array_no_alpha(),
+        Color::Okhsva(c) => c.to_f32_array_no_alpha(),
         Color::Xyza(c) => c.to_f32_array_no_alpha(),
     }
 }
diff --git a/crates/processing_pyo3/src/graphics.rs b/crates/processing_pyo3/src/graphics.rs
index beaf22b7..b2fb87a0 100644
--- a/crates/processing_pyo3/src/graphics.rs
+++ b/crates/processing_pyo3/src/graphics.rs
@@ -2203,10 +2203,36 @@ impl Graphics {
     #[pyo3(signature = (particles, geometry = None, topology = None))]
     pub fn particles(
         &self,
-        particles: &crate::particles::Particles,
+        particles: &Bound<'_, PyAny>,
         geometry: Option<&Geometry>,
         topology: Option<&str>,
     ) -> PyResult<()> {
+        // A dynamic-topology target knows its own topology and draws its
+        // internal expanded-vertex field.
+        if let Ok(prims) = particles.extract::<PyRef<crate::particles::Primitives>>() {
+            if geometry.is_some() || topology.is_some() {
+                return Err(PyValueError::new_err(
+                    "particles(primitives): geometry/topology come from the target",
+                ));
+            }
+            return graphics_record_command(
+                self.entity,
+                DrawCommand::Particles {
+                    particles: prims.field,
+                    geometry: None,
+                    topology: prims.topology,
+                },
+            )
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")));
+        }
+
+        let particles = particles
+            .extract::<PyRef<crate::particles::Particles>>()
+            .map_err(|_| {
+                pyo3::exceptions::PyTypeError::new_err(
+                    "particles(): expected a Particles or Primitives object",
+                )
+            })?;
         let topology = match topology {
             Some(s) => geometry::Topology::parse(s).ok_or_else(|| {
                 PyValueError::new_err(format!("particles(): unknown topology {s:?}"))
diff --git a/crates/processing_pyo3/src/lib.rs b/crates/processing_pyo3/src/lib.rs
index cc0608e9..768b0f00 100644
--- a/crates/processing_pyo3/src/lib.rs
+++ b/crates/processing_pyo3/src/lib.rs
@@ -451,6 +451,8 @@ mod mewnala {
     #[pymodule_export]
     use super::particles::Particles;
     #[pymodule_export]
+    use super::particles::Primitives;
+    #[pymodule_export]
     use super::surface::Surface;
 
     #[pymodule_init]
@@ -1187,7 +1189,7 @@ mod mewnala {
     #[pyo3(pass_module, signature = (particles, geometry = None, topology = None))]
     fn particles(
         module: &Bound<'_, PyModule>,
-        particles: &Bound<'_, super::particles::Particles>,
+        particles: &Bound<'_, PyAny>,
         geometry: Option<&Bound<'_, Geometry>>,
         topology: Option<&str>,
     ) -> PyResult<()> {
@@ -1195,11 +1197,7 @@ mod mewnala {
             Some(g) => Some(g.extract::<PyRef<Geometry>>()?),
             None => None,
         };
-        graphics!(module).particles(
-            &*particles.extract::<PyRef<super::particles::Particles>>()?,
-            geometry.as_deref(),
-            topology,
-        )
+        graphics!(module).particles(particles, geometry.as_deref(), topology)
     }
 
     #[pyfunction(name = "color")]
diff --git a/crates/processing_pyo3/src/particles.rs b/crates/processing_pyo3/src/particles.rs
index 5b706f10..f4a88b36 100644
--- a/crates/processing_pyo3/src/particles.rs
+++ b/crates/processing_pyo3/src/particles.rs
@@ -137,6 +137,39 @@ impl Grid {
     }
 }
 
+/// A dynamic-topology target: kernels add points, lines, or triangles to it
+/// via the WESL `processing::prims` module, and `particles(target)` draws
+/// whatever was added this frame. Created with `p.primitives(...)`.
+#[pyclass(unsendable)]
+pub struct Primitives {
+    pub(crate) target: Entity,
+    pub(crate) field: Entity,
+    pub(crate) topology: geometry::Topology,
+    pub(crate) capacity: u32,
+}
+
+#[pymethods]
+impl Primitives {
+    /// Capacity in primitives.
+    #[getter]
+    pub fn capacity(&self) -> u32 {
+        self.capacity
+    }
+
+    /// Primitives the kernels tried to add this frame, including any dropped
+    /// because the target was full. Reads back a small GPU stat; call it
+    /// when you want the number rather than every frame.
+    pub fn emitted(&self) -> PyResult<u32> {
+        particles_primitives_attempted(self.target).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    /// True when kernels tried to add more primitives than the capacity this
+    /// frame (the excess was dropped).
+    pub fn overflowed(&self) -> PyResult<bool> {
+        Ok(self.emitted()? > self.capacity)
+    }
+}
+
 static FLOCK_COMPUTE: std::sync::Mutex<Option<Entity>> = std::sync::Mutex::new(None);
 
 fn flock_compute() -> PyResult<Entity> {
@@ -782,19 +815,51 @@ impl Particles {
         particles_reset_indices(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    #[pyo3(signature = (kind, **kwargs))]
+    /// Creates a dynamic-topology target over this field: kernels applied
+    /// with `apply(kernel, primitives=target)` add points, lines, or
+    /// triangles to it via the WESL `processing::prims` module, and
+    /// `particles(target)` draws whatever was added this frame. `capacity`
+    /// is counted in primitives.
+    #[pyo3(signature = (topology, capacity))]
+    pub fn primitives(&self, topology: &str, capacity: u32) -> PyResult<Primitives> {
+        let topology = processing_render::geometry::Topology::parse(topology).ok_or_else(|| {
+            PyValueError::new_err(format!("primitives(): unknown topology {topology:?}"))
+        })?;
+        let target = particles_primitives_create(self.entity, topology, capacity)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        let field = processing_render::particles_primitives_field(target)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Primitives {
+            target,
+            field,
+            topology,
+            capacity,
+        })
+    }
+
+    #[pyo3(signature = (kind, primitives = None, **kwargs))]
     pub fn apply(
         &self,
         kind: &Bound<'_, PyAny>,
+        primitives: Option<PyRef<Primitives>>,
         kwargs: Option<&Bound<'_, PyDict>>,
     ) -> PyResult<()> {
         if let Ok(compute) = kind.extract::<PyRef<Compute>>() {
             if let Some(kwargs) = kwargs {
                 compute.set(Some(kwargs))?;
             }
+            if let Some(prims) = primitives {
+                return particles_primitives_apply(prims.target, compute.entity)
+                    .map_err(|e| PyRuntimeError::new_err(format!("{e}")));
+            }
             return particles_apply(self.entity, compute.entity)
                 .map_err(|e| PyRuntimeError::new_err(format!("{e}")));
         }
+        if primitives.is_some() {
+            return Err(PyTypeError::new_err(
+                "apply(primitives=...) requires a Compute kernel",
+            ));
+        }
         let name: String = kind.extract().map_err(|_| {
             PyTypeError::new_err(
                 "apply(): first argument must be an operation constant or a Compute",
diff --git a/crates/processing_render/Cargo.toml b/crates/processing_render/Cargo.toml
index 146a9bbe..d3af13b0 100644
--- a/crates/processing_render/Cargo.toml
+++ b/crates/processing_render/Cargo.toml
@@ -15,7 +15,7 @@ x11 = ["bevy/x11"]
 bevy = { workspace = true }
 bevy_naga_reflect = { workspace = true }
 # direct wgpu dep to reach `wgpu::util::TextureBlitter` (unifies to bevy's wgpu)
-wgpu = "29"
+wgpu = "30"
 naga = { workspace = true }
 wesl = { workspace = true }
 lyon = "1.0"
diff --git a/crates/processing_render/shaders/processing/prims.wesl b/crates/processing_render/shaders/processing/prims.wesl
new file mode 100644
index 00000000..a15d8c91
--- /dev/null
+++ b/crates/processing_render/shaders/processing/prims.wesl
@@ -0,0 +1,100 @@
+// processing::prims — GPU-authored dynamic topology.
+//
+// A kernel imports this module and adds primitives to a `p.primitives(...)`
+// target; the engine binds the target's buffers under the reserved names
+// below (group 0, bindings 50-52) and draws the result indirectly, so the
+// sketch never touches counts, draw arguments, or index buffers.
+//
+//     import { processing::prims };
+//
+//     var a = prims::vertex(pos_i);  a.color = vec4<f32>(rgb_i, alpha);
+//     var b = prims::vertex(pos_j);  b.color = vec4<f32>(rgb_j, alpha);
+//     prims::line(a, b);
+//
+// `line`/`tri`/`point` reserve vertex slots atomically, clamp against the
+// target's capacity (over-capacity primitives are dropped, never partially
+// written), and count every attempt so the sketch can poll
+// `target.emitted()` / `target.overflowed()`.
+
+// Indirect draw arguments with stats in the tail. The GPU's draw_indirect
+// reads only the first four words; `instance_count` stays 1 and is written
+// by the engine at frame reset.
+struct PrimsArgs {
+    vertex_count: atomic<u32>,
+    instance_count: u32,
+    first_vertex: u32,
+    first_instance: u32,
+    // Primitives kernels tried to add this frame (including dropped ones).
+    attempted: atomic<u32>,
+    // Capacity of the target, in vertices.
+    capacity_verts: u32,
+    // Vertices per primitive for the target's topology.
+    verts_per_prim: u32,
+    _pad: u32,
+}
+
+// Reserved bindings, filled by `apply(kernel, primitives=target)`.
+// Bindings 50-52 in group 0 are reserved for this module; user kernels
+// should number their own bindings below 50.
+@group(0) @binding(50) var<storage, read_write> prims_out_position: array<f32>;
+@group(0) @binding(51) var<storage, read_write> prims_out_color: array<f32>;
+@group(0) @binding(52) var<storage, read_write> prims_args: PrimsArgs;
+
+struct Vertex {
+    position: vec3<f32>,
+    color: vec4<f32>,
+}
+
+// A vertex at `p` with default white color; set `.color` before committing.
+fn vertex(p: vec3<f32>) -> Vertex {
+    return Vertex(p, vec4<f32>(1.0, 1.0, 1.0, 1.0));
+}
+
+const INVALID_SLOT: u32 = 0xffffffffu;
+
+// Reserves `n` contiguous vertex slots. Returns the base slot, or
+// INVALID_SLOT when the target is full (with the reservation rolled back so
+// the drawn count never exceeds what was actually written).
+fn reserve(n: u32) -> u32 {
+    atomicAdd(&prims_args.attempted, 1u);
+    let base = atomicAdd(&prims_args.vertex_count, n);
+    if base + n > prims_args.capacity_verts {
+        atomicSub(&prims_args.vertex_count, n);
+        return INVALID_SLOT;
+    }
+    return base;
+}
+
+fn write_vertex(slot: u32, v: Vertex) {
+    prims_out_position[slot * 3u + 0u] = v.position.x;
+    prims_out_position[slot * 3u + 1u] = v.position.y;
+    prims_out_position[slot * 3u + 2u] = v.position.z;
+    prims_out_color[slot * 4u + 0u] = v.color.x;
+    prims_out_color[slot * 4u + 1u] = v.color.y;
+    prims_out_color[slot * 4u + 2u] = v.color.z;
+    prims_out_color[slot * 4u + 3u] = v.color.w;
+}
+
+// Adds one point primitive to a POINTS target.
+fn point(a: Vertex) {
+    let base = reserve(1u);
+    if base == INVALID_SLOT { return; }
+    write_vertex(base, a);
+}
+
+// Adds one line segment to a LINES target.
+fn line(a: Vertex, b: Vertex) {
+    let base = reserve(2u);
+    if base == INVALID_SLOT { return; }
+    write_vertex(base, a);
+    write_vertex(base + 1u, b);
+}
+
+// Adds one triangle to a TRIANGLES target.
+fn tri(a: Vertex, b: Vertex, c: Vertex) {
+    let base = reserve(3u);
+    if base == INVALID_SLOT { return; }
+    write_vertex(base, a);
+    write_vertex(base + 1u, b);
+    write_vertex(base + 2u, c);
+}
diff --git a/crates/processing_render/src/compute.rs b/crates/processing_render/src/compute.rs
index 4b56fe6a..d9e98e10 100644
--- a/crates/processing_render/src/compute.rs
+++ b/crates/processing_render/src/compute.rs
@@ -155,7 +155,10 @@ pub fn read_buffer_gpu(
         .map_err(|e| ProcessingError::BufferMapError(format!("map channel closed: {e}")))?
         .map_err(|e| ProcessingError::BufferMapError(format!("map failed: {e}")))?;
 
-    let bytes = buffer_slice.get_mapped_range().to_vec();
+    let bytes = buffer_slice
+        .get_mapped_range()
+        .map_err(|e| ProcessingError::BufferMapError(format!("get_mapped_range failed: {e}")))?
+        .to_vec();
     readback_buffer.unmap();
     Ok(bytes)
 }
@@ -280,6 +283,7 @@ pub fn create_compute(app: &mut App, shader_entity: Entity) -> Result<Entity> {
         shader_defs: Vec::new(),
         entry_point: Some(entry_point.clone().into()),
         zero_initialize_workgroup_memory: true,
+        constants: default(),
     };
 
     let pipeline_id = app
diff --git a/crates/processing_render/src/graphics.rs b/crates/processing_render/src/graphics.rs
index 4fc9071b..2c4164fe 100644
--- a/crates/processing_render/src/graphics.rs
+++ b/crates/processing_render/src/graphics.rs
@@ -232,6 +232,12 @@ pub fn create(
         entity_commands.insert((Hdr, Bloom::NATURAL, Tonemapping::TonyMcMapface));
     }
 
+    // TEMP(bevy-020 debug): force direct drawing to bisect the indirect-args
+    // build for sorted instance batches.
+    if std::env::var("PROCESSING_NO_INDIRECT").is_ok() {
+        entity_commands.insert(bevy::render::view::NoIndirectDrawing);
+    }
+
     let entity = entity_commands.id();
 
     Ok(entity)
@@ -673,7 +679,10 @@ pub fn readback_raw(
 
     r.recv().expect("Failed to receive the map_async message");
 
-    let data = buffer_slice.get_mapped_range().to_vec();
+    let data = buffer_slice
+        .get_mapped_range()
+        .expect("Failed to get mapped range for readback")
+        .to_vec();
 
     graphics.readback_buffer.unmap();
 
diff --git a/crates/processing_render/src/image.rs b/crates/processing_render/src/image.rs
index 4945b3b5..9ff018de 100644
--- a/crates/processing_render/src/image.rs
+++ b/crates/processing_render/src/image.rs
@@ -310,7 +310,10 @@ pub fn readback(
 
     r.recv().expect("Failed to receive the map_async message");
 
-    let data = buffer_slice.get_mapped_range().to_vec();
+    let data = buffer_slice
+        .get_mapped_range()
+        .expect("Failed to get mapped range for readback")
+        .to_vec();
 
     let mut image = images
         .get_mut(&p_image.handle)
diff --git a/crates/processing_render/src/lib.rs b/crates/processing_render/src/lib.rs
index 6359c86f..8ddbd15e 100644
--- a/crates/processing_render/src/lib.rs
+++ b/crates/processing_render/src/lib.rs
@@ -35,17 +35,19 @@ pub use particles::{
     COMBINE_MIN, COMBINE_MUL, COMBINE_POW, COMBINE_SUB, FALLOFF_CONST, FALLOFF_CUBIC,
     FALLOFF_INVERSE, FALLOFF_LINEAR, FALLOFF_QUADRATIC, FALLOFF_SMOOTHSTEP, particles_apply,
     particles_attribute_add, particles_buffer, particles_capacity, particles_connectivity_indirect,
+    particles_primitives_apply, particles_primitives_attempted, particles_primitives_create,
+    particles_primitives_field,
     particles_create, particles_create_from_geometry, particles_destroy, particles_emit,
-    particles_emit_gpu, particles_ensure_attribute, particles_flock, particles_gather,
-    particles_kernel_age, particles_kernel_attr_combine, particles_kernel_attr_linear,
-    particles_kernel_attr_lookup1d, particles_kernel_attr_lookup2d, particles_kernel_attr_mix,
-    particles_kernel_attract, particles_kernel_bounds_box, particles_kernel_bounds_geometry,
-    particles_kernel_bounds_sphere, particles_kernel_drag, particles_kernel_field,
-    particles_kernel_flock, particles_kernel_force, particles_kernel_impulse,
-    particles_kernel_integrate, particles_kernel_noise, particles_kernel_orient,
-    particles_kernel_transform, particles_kernel_vortex, particles_reset_indices,
-    particles_scatter_create, particles_scatter_volume_create, particles_set_connectivity,
-    prefix_sum_u32,
+    particles_emit_gpu, particles_ensure_attribute, particles_flock, particles_flock_auto,
+    particles_gather, particles_kernel_age, particles_kernel_attr_combine,
+    particles_kernel_attr_linear, particles_kernel_attr_lookup1d, particles_kernel_attr_lookup2d,
+    particles_kernel_attr_mix, particles_kernel_attract, particles_kernel_bounds_box,
+    particles_kernel_bounds_geometry, particles_kernel_bounds_sphere, particles_kernel_drag,
+    particles_kernel_field, particles_kernel_flock, particles_kernel_force,
+    particles_kernel_impulse, particles_kernel_integrate, particles_kernel_noise,
+    particles_kernel_orient, particles_kernel_transform, particles_kernel_vortex,
+    particles_reset_indices, particles_scatter_create, particles_scatter_volume_create,
+    particles_set_connectivity, prefix_sum_u32,
 };
 
 use std::path::PathBuf;
@@ -1901,24 +1903,29 @@ fn material_set_particles_buffer(
             return Err(error::ProcessingError::MaterialNotFound);
         };
         let world = app.world_mut();
-        let preserved = {
+        let (preserved, prev_blend_state, prev_depth_write) = {
             let mut mats = world.resource_mut::<Assets<DefaultMat>>();
-            let base = mats
+            let mat = mats
                 .get(&handle)
-                .ok_or(error::ProcessingError::MaterialNotFound)?
-                .base
-                .clone();
+                .ok_or(error::ProcessingError::MaterialNotFound)?;
+            let base = mat.base.clone();
+            let blend_state = mat.extension.blend_state;
+            let depth_write = mat.extension.depth_write;
             mats.remove(&handle);
-            base
+            (base, blend_state, depth_write)
         };
         let extension = match slot {
             ParticlesBufferSlot::Albedo => ParticlesExtension {
                 colors: Some(buffer_handle),
                 emissive_colors: None,
+                blend_state: prev_blend_state,
+                depth_write: prev_depth_write,
             },
             ParticlesBufferSlot::Emissive => ParticlesExtension {
                 colors: None,
                 emissive_colors: Some(buffer_handle),
+                blend_state: prev_blend_state,
+                depth_write: prev_depth_write,
             },
         };
         let new_handle = world
@@ -2454,29 +2461,29 @@ pub fn compute_set(
 pub fn compute_dispatch(entity: Entity, x: u32, y: u32, z: u32) -> error::Result<()> {
     app_mut(|app| {
         app.update();
-
-        let args = {
-            let world = app.world();
-            let c = world
-                .get::<compute::Compute>(entity)
-                .ok_or(error::ProcessingError::ComputeNotFound)?;
-            let mesh_bindings = compute::resolve_mesh_bindings(world, c)?;
-            (
-                c.pipeline_id,
-                c.bind_group_layout_descriptors.clone(),
-                c.shader.clone(),
-                mesh_bindings,
-                x,
-                y,
-                z,
-            )
-        };
-        app.sub_app_mut(bevy::render::RenderApp)
-            .world_mut()
-            .run_system_cached_with(compute::dispatch, args)
-            .unwrap()
+        
+    let args = {
+        let world = app.world();
+        let c = world
+            .get::<compute::Compute>(entity)
+            .ok_or(error::ProcessingError::ComputeNotFound)?;
+        let mesh_bindings = compute::resolve_mesh_bindings(world, c)?;
+        (
+            c.pipeline_id,
+            c.bind_group_layout_descriptors.clone(),
+            c.shader.clone(),
+            mesh_bindings,
+            x,
+            y,
+            z,
+        )
+    };
+    app.sub_app_mut(bevy::render::RenderApp)
+        .world_mut()
+        .run_system_cached_with(compute::dispatch, args)
+                    .unwrap()
     })
-}
+            }
 
 pub fn compute_destroy(entity: Entity) -> error::Result<()> {
     app_mut(|app| {
diff --git a/crates/processing_render/src/material/custom.rs b/crates/processing_render/src/material/custom.rs
index f39de9d7..4ccd09b7 100644
--- a/crates/processing_render/src/material/custom.rs
+++ b/crates/processing_render/src/material/custom.rs
@@ -25,9 +25,9 @@ use bevy::{
     mesh::MeshVertexBufferLayoutRef,
     pbr::{
         DrawMaterial, EntitiesNeedingSpecialization, MainPassOpaqueDrawFunction,
-        MainPassTransparentDrawFunction, MaterialBindGroupAllocator, MaterialBindGroupAllocators,
-        MaterialFragmentShader, MaterialVertexShader, MeshPipelineKey, PreparedMaterial,
-        RenderMaterialBindings, RenderMaterialInstance, RenderMaterialInstances, base_specialize,
+        MainPassTransparentDrawFunction, MaterialFragmentShader, MaterialVertexShader,
+        MeshPipelineKey, PreparedMaterial, RenderMaterialInstance, RenderMaterialInstances,
+        base_specialize,
     },
     prelude::*,
     reflect::{PartialReflect, ReflectMut, ReflectRef, structs::Struct},
@@ -35,6 +35,9 @@ use bevy::{
         Extract, RenderApp, RenderStartup,
         camera::{DirtySpecializationSystems, DirtySpecializations},
         erased_render_asset::{ErasedRenderAsset, ErasedRenderAssetPlugin, PrepareAssetError},
+        material_bind_groups::{
+            MaterialBindGroupAllocator, MaterialBindGroupAllocators, RenderMaterialBindings,
+        },
         render_asset::RenderAssets,
         render_phase::DrawFunctions,
         render_resource::{
diff --git a/crates/processing_render/src/material/mod.rs b/crates/processing_render/src/material/mod.rs
index f449ab7d..43091660 100644
--- a/crates/processing_render/src/material/mod.rs
+++ b/crates/processing_render/src/material/mod.rs
@@ -316,9 +316,10 @@ pub fn set_depth_write(
                 mat.extension.depth_write = Some(value);
                 Ok(())
             }
-            MaterialMut::Particles(_) => Err(ProcessingError::InvalidArgument(
-                "depth-write is not yet configurable on particle materials".to_string(),
-            )),
+            MaterialMut::Particles(mat) => {
+                mat.extension.depth_write = Some(value);
+                Ok(())
+            }
             MaterialMut::Custom(mat) => {
                 mat.depth_write = Some(value);
                 Ok(())
@@ -346,9 +347,11 @@ pub fn set_custom_blend(
                 mat.base.alpha_mode = AlphaMode::Blend;
                 Ok(())
             }
-            MaterialMut::Particles(_) => Err(ProcessingError::InvalidArgument(
-                "custom blend is not yet configurable on particle materials".to_string(),
-            )),
+            MaterialMut::Particles(mat) => {
+                mat.extension.blend_state = Some(blend);
+                mat.base.alpha_mode = AlphaMode::Blend;
+                Ok(())
+            }
             MaterialMut::Custom(mat) => {
                 mat.blend_state = Some(blend);
                 mat.alpha_mode = AlphaMode::Blend;
diff --git a/crates/processing_render/src/particles/emit.rs b/crates/processing_render/src/particles/emit.rs
index f31fb5aa..f08a89af 100644
--- a/crates/processing_render/src/particles/emit.rs
+++ b/crates/processing_render/src/particles/emit.rs
@@ -6,11 +6,14 @@ use processing_core::app_mut;
 use processing_core::error;
 
 use crate::geometry;
-use crate::particles::grid::{Grid, grid_bind, grid_build};
+use crate::particles::grid::{Grid, GridParams, grid_bind, grid_build, grid_create};
 use crate::particles::kernels::KernelRequires;
 use crate::particles::{Particles, particles_ensure_attribute};
 use crate::shader_value::ShaderValue;
-use crate::{buffer_write_element, compute_create, compute_dispatch, compute_set, shader_load};
+use crate::{
+    buffer_write_element, compute_create, compute_dispatch, compute_set,
+    shader_load,
+};
 
 const WORKGROUP_SIZE: u32 = 64;
 
@@ -171,6 +174,107 @@ pub fn particles_flock(
     particles_apply(particles_entity, flock_entity)
 }
 
+#[derive(Component, Clone, Copy)]
+pub struct AutoFlockGrid(pub Grid);
+
+#[derive(Component, Clone, Copy)]
+pub struct NaiveFlockKernel(pub Entity);
+
+const FLOCK_PARAMS: [&str; 8] = [
+    "sep_distance",
+    "neighbor_distance",
+    "weight_separation",
+    "weight_alignment",
+    "weight_cohesion",
+    "max_speed",
+    "max_force",
+    "min_speed",
+];
+
+pub fn particles_flock_auto(particles_entity: Entity, flock_entity: Entity) -> error::Result<()> {
+    let (capacity, cell_size, cap, existing, naive) = app_mut(|app| {
+        let world = app.world();
+        let capacity = world
+            .get::<Particles>(particles_entity)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?
+            .capacity;
+        let compute = world.get::<crate::compute::Compute>(flock_entity);
+        let cell_size = compute
+            .and_then(|c| c.shader.get::<f32>("neighbor_distance").copied())
+            .unwrap_or(2.5)
+            .max(1e-3);
+        let cap = compute
+            .and_then(|c| c.shader.get::<u32>("max_neighbors").copied())
+            .unwrap_or(64);
+        let existing = world.get::<AutoFlockGrid>(flock_entity).map(|g| g.0);
+        let naive = world.get::<NaiveFlockKernel>(flock_entity).map(|n| n.0);
+        Ok((capacity, cell_size, cap, existing, naive))
+    })?;
+
+    if cap == 0 {
+        let naive = match naive {
+            Some(e) => e,
+            None => {
+                let e = crate::particles::kernels::particles_kernel_flock_naive()?;
+                app_mut(|app| {
+                    app.world_mut()
+                        .entity_mut(flock_entity)
+                        .insert(NaiveFlockKernel(e));
+                    Ok(())
+                })?;
+                e
+            }
+        };
+        let values: Vec<(usize, f32)> = app_mut(|app| {
+            let compute = app.world().get::<crate::compute::Compute>(flock_entity);
+            Ok(FLOCK_PARAMS
+                .iter()
+                .enumerate()
+                .filter_map(|(idx, name)| {
+                    compute
+                        .and_then(|c| c.shader.get::<f32>(name).copied())
+                        .map(|v| (idx, v))
+                })
+                .collect())
+        })?;
+        for (idx, v) in values {
+            compute_set(naive, FLOCK_PARAMS[idx], ShaderValue::Float(v))?;
+        }
+        return particles_apply(particles_entity, naive);
+    }
+
+    let reusable = existing.filter(|g| {
+        g.capacity == capacity && (g.params.cell_size - cell_size).abs() < f32::EPSILON
+    });
+    let grid = match reusable {
+        Some(g) => g,
+        None => {
+            if let Some(old) = existing {
+                let _ = crate::buffer_destroy(old.offsets);
+                let _ = crate::buffer_destroy(old.cursor);
+                let _ = crate::buffer_destroy(old.sorted);
+            }
+            const HALF: f32 = 40.0;
+            let dim = (((2.0 * HALF) / cell_size).ceil() as u32).clamp(1, 32);
+            let half_extent = dim as f32 * cell_size / 2.0;
+            let params = GridParams {
+                min: [-half_extent; 3],
+                cell_size,
+                dims: [dim; 3],
+            };
+            let g = grid_create(params, capacity)?;
+            app_mut(|app| {
+                app.world_mut()
+                    .entity_mut(flock_entity)
+                    .insert(AutoFlockGrid(g));
+                Ok(())
+            })?;
+            g
+        }
+    };
+    particles_flock(particles_entity, flock_entity, &grid)
+}
+
 static NEIGHBOR_COMPUTE: Mutex<Option<Entity>> = Mutex::new(None);
 
 fn neighbor_compute() -> error::Result<Entity> {
diff --git a/crates/processing_render/src/particles/kernels/flock.wgsl b/crates/processing_render/src/particles/kernels/flock.wgsl
index 56040c17..82acde6f 100644
--- a/crates/processing_render/src/particles/kernels/flock.wgsl
+++ b/crates/processing_render/src/particles/kernels/flock.wgsl
@@ -9,6 +9,7 @@ struct FlockParams {
     max_speed: f32,
     max_force: f32,
     min_speed: f32,
+    max_neighbors: u32,
 }
 
 struct GridParams {
@@ -71,35 +72,61 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     var coh_sum = vec3<f32>(0.0);
     var flock_count = 0u;
 
-    for (var dz = -1; dz <= 1; dz++) {
-        let cz = bz + dz;
+    let cap = fp.max_neighbors;
+
+    var starts: array<u32, 27>;
+    var counts: array<u32, 27>;
+    var total = 0u;
+    for (var m = 0u; m < 27u; m++) {
+        counts[m] = 0u;
+        let cx = bx + i32(m % 3u) - 1;
+        let cy = by + i32((m / 3u) % 3u) - 1;
+        let cz = bz + i32(m / 9u) - 1;
+        if cx < 0 || cx >= i32(gp.dims_x) { continue; }
+        if cy < 0 || cy >= i32(gp.dims_y) { continue; }
         if cz < 0 || cz >= i32(gp.dims_z) { continue; }
-        for (var dy = -1; dy <= 1; dy++) {
-            let cy = by + dy;
-            if cy < 0 || cy >= i32(gp.dims_y) { continue; }
-            for (var dx = -1; dx <= 1; dx++) {
-                let cx = bx + dx;
-                if cx < 0 || cx >= i32(gp.dims_x) { continue; }
-
-                let cell = cell_index(vec3<u32>(u32(cx), u32(cy), u32(cz)), dims);
-                let start = offsets[cell];
-                let end = offsets[cell + 1u];
-                for (var s = start; s < end; s++) {
-                    let j = sorted[s];
-                    if j == i { continue; }
-
-                    let diff = pos - load_pos(j);
-                    let d2 = dot(diff, diff);
-                    if d2 > 0.000001 && d2 < neighbor_d2 {
-                        if d2 < sep_d2 {
-                            sep_steer += diff / d2;
-                            sep_count += 1u;
-                        }
-                        ali_sum += load_vel(j);
-                        coh_sum += diff;
-                        flock_count += 1u;
-                    }
-                }
+        let cell = cell_index(vec3<u32>(u32(cx), u32(cy), u32(cz)), dims);
+        let start = offsets[cell];
+        starts[m] = start;
+        counts[m] = offsets[cell + 1u] - start;
+        total += counts[m];
+    }
+
+    var budget = total;
+    if cap > 0u {
+        budget = min(total, cap * 7u);
+    }
+    let phase = (i * 2654435761u) % max(total, 1u);
+
+    for (var t = 0u; t < budget; t++) {
+        var r: u32;
+        if budget == total {
+            r = t;
+        } else {
+            r = (phase + (t * total) / budget) % total;
+        }
+        var m = 0u;
+        var acc = 0u;
+        loop {
+            if r < acc + counts[m] { break; }
+            acc += counts[m];
+            m++;
+        }
+        let j = sorted[starts[m] + (r - acc)];
+        if j == i { continue; }
+
+        let diff = pos - load_pos(j);
+        let d2 = dot(diff, diff);
+        if d2 > 0.000001 && d2 < neighbor_d2 {
+            if d2 < sep_d2 {
+                sep_steer += diff / d2;
+                sep_count += 1u;
+            }
+            ali_sum += load_vel(j);
+            coh_sum += diff;
+            flock_count += 1u;
+            if cap > 0u && flock_count >= cap {
+                break;
             }
         }
     }
diff --git a/crates/processing_render/src/particles/kernels/mod.rs b/crates/processing_render/src/particles/kernels/mod.rs
index a552af51..0a36e0f5 100644
--- a/crates/processing_render/src/particles/kernels/mod.rs
+++ b/crates/processing_render/src/particles/kernels/mod.rs
@@ -252,6 +252,17 @@ pub fn particles_kernel_impulse() -> error::Result<Entity> {
     Ok(entity)
 }
 
+// TODO(WIP): tiled all-pairs exact flock kernel for the `max_neighbors == 0`
+// path in `particles_flock_auto`. Stubbed so the build stays green while the
+// kernel is written.
+pub fn particles_kernel_flock_naive() -> error::Result<Entity> {
+    Err(error::ProcessingError::InvalidArgument(
+        "the exact (all-pairs) flock kernel is not implemented yet; \
+         set max_neighbors > 0 to use the grid-accelerated path"
+            .to_string(),
+    ))
+}
+
 pub fn particles_kernel_flock() -> error::Result<Entity> {
     let shader = shader_load("embedded://processing_render/particles/kernels/flock.wgsl")?;
     let entity = compute_create(shader)?;
@@ -264,6 +275,7 @@ pub fn particles_kernel_flock() -> error::Result<Entity> {
     compute_set(entity, "max_speed", ShaderValue::Float(0.1))?;
     compute_set(entity, "max_force", ShaderValue::Float(0.003))?;
     compute_set(entity, "min_speed", ShaderValue::Float(0.02))?;
+    compute_set(entity, "max_neighbors", ShaderValue::UInt(64))?;
     Ok(entity)
 }
 
diff --git a/crates/processing_render/src/particles/material.rs b/crates/processing_render/src/particles/material.rs
index 90b55a98..0075a605 100644
--- a/crates/processing_render/src/particles/material.rs
+++ b/crates/processing_render/src/particles/material.rs
@@ -9,7 +9,7 @@ use bevy::pbr::{
 use bevy::prelude::*;
 use bevy::render::{
     mesh::MeshVertexBufferLayoutRef,
-    render_resource::{AsBindGroup, RenderPipelineDescriptor},
+    render_resource::{AsBindGroup, BlendState, RenderPipelineDescriptor},
     storage::ShaderBuffer,
 };
 use bevy::shader::ShaderRef;
@@ -31,6 +31,8 @@ pub type ParticlesMaterial = ExtendedMaterial<StandardMaterial, ParticlesExtensi
 pub struct ParticlesExtensionKey {
     pub has_albedo: bool,
     pub has_emissive: bool,
+    pub blend_state: Option<BlendState>,
+    pub depth_write: Option<bool>,
 }
 
 impl From<&ParticlesExtension> for ParticlesExtensionKey {
@@ -38,6 +40,8 @@ impl From<&ParticlesExtension> for ParticlesExtensionKey {
         Self {
             has_albedo: ext.colors.is_some(),
             has_emissive: ext.emissive_colors.is_some(),
+            blend_state: ext.blend_state,
+            depth_write: ext.depth_write,
         }
     }
 }
@@ -49,6 +53,10 @@ pub struct ParticlesExtension {
     pub colors: Option<Handle<ShaderBuffer>>,
     #[storage(101, read_only)]
     pub emissive_colors: Option<Handle<ShaderBuffer>>,
+    /// Custom blend override for the sketch's `blend_mode()`.
+    #[reflect(ignore)]
+    pub blend_state: Option<BlendState>,
+    pub depth_write: Option<bool>,
 }
 
 impl MaterialExtension for ParticlesExtension {
@@ -74,6 +82,11 @@ impl MaterialExtension for ParticlesExtension {
                 fragment.shader_defs.push("HAS_EMISSIVE_COLORS".into());
             }
         }
+        crate::material::apply_pipeline_state(
+            descriptor,
+            key.bind_group_data.blend_state,
+            key.bind_group_data.depth_write,
+        );
         Ok(())
     }
 }
diff --git a/crates/processing_render/src/particles/mod.rs b/crates/processing_render/src/particles/mod.rs
index 38034d73..7e61f41c 100644
--- a/crates/processing_render/src/particles/mod.rs
+++ b/crates/processing_render/src/particles/mod.rs
@@ -8,6 +8,7 @@ pub mod kernels;
 pub mod material;
 pub mod pack;
 pub mod point_render;
+pub mod prims;
 pub mod reduce;
 pub mod scan;
 mod scatter;
@@ -21,9 +22,14 @@ pub use algebra::{
 };
 pub use compact::compact;
 pub use emit::{
-    particles_apply, particles_emit, particles_emit_gpu, particles_flock, particles_gather,
+    AutoFlockGrid, particles_apply, particles_emit, particles_emit_gpu, particles_flock,
+    particles_flock_auto, particles_gather,
 };
 pub use grid::{Grid, GridParams, grid_bind, grid_build, grid_create};
+pub use prims::{
+    PrimitivesTarget, particles_primitives_apply, particles_primitives_attempted,
+    particles_primitives_create, particles_primitives_field,
+};
 pub use kernels::{
     BOUNDS_CLAMP, BOUNDS_REFLECT, BOUNDS_SOFT, BOUNDS_WRAP, COMBINE_ADD, COMBINE_DIV, COMBINE_MAX,
     COMBINE_MIN, COMBINE_MUL, COMBINE_POW, COMBINE_SUB, FALLOFF_CONST, FALLOFF_CUBIC,
@@ -96,11 +102,17 @@ pub struct Particles {
     pub connectivity: Option<Connectivity>,
     /// Ring-buffer write cursor; wraps at `capacity`.
     pub emit_head: u32,
+    /// Set by the raster draw path, consumed by the primitives-apply path so
+    /// a target's counts reset once per draw regardless of frame pacing.
+    pub drawn_since_apply: bool,
 }
 
 #[derive(Clone, Copy)]
 pub struct Connectivity {
-    pub index_buffer: Entity,
+    /// Index buffer, when the topology shares vertices (mesh-carry or a
+    /// GPU-generated index buffer). `None` for dynamic-topology targets,
+    /// whose vertices are unique by construction and draw non-indexed.
+    pub index_buffer: Option<Entity>,
     pub indirect_buffer: Entity,
 }
 
@@ -150,6 +162,7 @@ pub fn create(
             raster_draw_entity: None,
             connectivity: None,
             emit_head: 0,
+            drawn_since_apply: false,
         })
         .id();
     Ok(entity)
@@ -218,7 +231,7 @@ pub fn create_from_geometry(
             BufferUsages::INDIRECT,
         );
         Connectivity {
-            index_buffer,
+            index_buffer: Some(index_buffer),
             indirect_buffer,
         }
     });
@@ -231,6 +244,7 @@ pub fn create_from_geometry(
             raster_draw_entity: None,
             connectivity,
             emit_head: 0,
+            drawn_since_apply: false,
         })
         .id();
     Ok(entity)
@@ -254,12 +268,14 @@ pub fn particles_set_connectivity(
             .get_mut::<Particles>(particles_entity)
             .ok_or(error::ProcessingError::ParticlesNotFound)?;
         Ok(field.connectivity.replace(Connectivity {
-            index_buffer,
+            index_buffer: Some(index_buffer),
             indirect_buffer,
         }))
     })?;
     if let Some(previous) = previous {
-        crate::buffer_destroy(previous.index_buffer)?;
+        if let Some(previous_index) = previous.index_buffer {
+            crate::buffer_destroy(previous_index)?;
+        }
         crate::buffer_destroy(previous.indirect_buffer)?;
     }
     Ok(index_buffer)
@@ -384,7 +400,9 @@ pub fn destroy(
         commands.entity(raster_draw_entity).despawn();
     }
     if let Some(connectivity) = p.connectivity {
-        commands.entity(connectivity.index_buffer).despawn();
+        if let Some(index_buffer) = connectivity.index_buffer {
+            commands.entity(index_buffer).despawn();
+        }
         commands.entity(connectivity.indirect_buffer).despawn();
     }
     commands.entity(entity).despawn();
diff --git a/crates/processing_render/src/particles/pack.wgsl b/crates/processing_render/src/particles/pack.wgsl
index c1b0e460..ef24a8eb 100644
--- a/crates/processing_render/src/particles/pack.wgsl
+++ b/crates/processing_render/src/particles/pack.wgsl
@@ -11,6 +11,7 @@ struct MeshInput {
     timestamp: u32,
     tag: u32,
     morph_descriptor_index: u32,
+    metadata_index: u32,
 }
 
 struct MeshCullingData {
diff --git a/crates/processing_render/src/particles/particles.wgsl b/crates/processing_render/src/particles/particles.wgsl
index 05a7419d..990f05c0 100644
--- a/crates/processing_render/src/particles/particles.wgsl
+++ b/crates/processing_render/src/particles/particles.wgsl
@@ -13,6 +13,7 @@
 #import bevy_pbr::{
     forward_io::{VertexOutput, FragmentOutput},
     pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+    pbr_types::STANDARD_MATERIAL_FLAGS_UNLIT_BIT,
 }
 #endif
 
@@ -46,13 +47,21 @@ fn fragment(
     );
 #endif
 
-    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+    pbr_input.material.base_color = alpha_discard(
+        pbr_input.material.flags,
+        pbr_input.material.alpha_cutoff,
+        pbr_input.material.base_color
+    );
 
 #ifdef PREPASS_PIPELINE
     let out = deferred_output(in, pbr_input);
 #else
     var out: FragmentOutput;
-    out.color = apply_pbr_lighting(pbr_input);
+    if (pbr_input.material.flags & STANDARD_MATERIAL_FLAGS_UNLIT_BIT) == 0u {
+        out.color = apply_pbr_lighting(pbr_input);
+    } else {
+        out.color = pbr_input.material.base_color;
+    }
     out.color = main_pass_post_lighting_processing(pbr_input, out.color);
 #endif
 
diff --git a/crates/processing_render/src/particles/point_render.rs b/crates/processing_render/src/particles/point_render.rs
index 2e8db841..f1645255 100644
--- a/crates/processing_render/src/particles/point_render.rs
+++ b/crates/processing_render/src/particles/point_render.rs
@@ -71,6 +71,7 @@ impl Plugin for ParticlesPointRenderPlugin {
 }
 
 #[derive(Component, Clone, ExtractComponent)]
+#[extract_app(RenderApp)]
 #[require(VisibilityClass)]
 #[component(on_add = visibility::add_visibility_class::<ParticleRasterDraw>)]
 pub struct ParticleRasterDraw {
@@ -260,20 +261,19 @@ fn prepare_raster_bind_groups(
         let Some(position) = gpu_buffers.get(&draw.position) else {
             continue;
         };
-        let (index, indirect) = match (&draw.index, &draw.indirect) {
-            (Some(index_handle), Some(indirect_handle)) => {
-                let (Some(index_gpu), Some(indirect_gpu)) = (
-                    gpu_buffers.get(index_handle),
-                    gpu_buffers.get(indirect_handle),
-                ) else {
-                    continue;
-                };
-                (
-                    Some(index_gpu.buffer.clone()),
-                    Some(indirect_gpu.buffer.clone()),
-                )
-            }
-            _ => (None, None),
+        let indirect = match &draw.indirect {
+            Some(indirect_handle) => match gpu_buffers.get(indirect_handle) {
+                Some(indirect_gpu) => Some(indirect_gpu.buffer.clone()),
+                None => continue,
+            },
+            None => None,
+        };
+        let index = match (&draw.index, indirect.is_some()) {
+            (Some(index_handle), true) => match gpu_buffers.get(index_handle) {
+                Some(index_gpu) => Some(index_gpu.buffer.clone()),
+                None => continue,
+            },
+            _ => None,
         };
         let color_buffer = match &draw.color {
             Some(handle) => match gpu_buffers.get(handle) {
@@ -475,6 +475,8 @@ impl<P: PhaseItem> RenderCommand<P> for DrawParticleRaster {
                 pass.set_index_buffer(index.slice(..), IndexFormat::Uint32);
                 pass.draw_indexed_indirect(indirect, 0);
             }
+            // Dynamic-topology targets: unique vertices, GPU-written count.
+            (None, Some(indirect)) => pass.draw_indirect(indirect, 0),
             _ => pass.draw(0..entry.count, 0..1),
         }
         RenderCommandResult::Success
diff --git a/crates/processing_render/src/particles/prims.rs b/crates/processing_render/src/particles/prims.rs
new file mode 100644
index 00000000..128148f6
--- /dev/null
+++ b/crates/processing_render/src/particles/prims.rs
@@ -0,0 +1,214 @@
+//! Dynamic topology: primitives added by kernels via `processing::prims`.
+//!
+//! A primitives target owns an internal particle field (the expanded
+//! vertices — unique by construction, so no index buffer) plus a widened
+//! indirect-args buffer whose head is the GPU-read `DrawIndirect` arguments
+//! and whose tail carries stats the sketch can poll. `apply` binds the
+//! target's buffers under the `processing::prims` reserved names, resets the
+//! counts on the first apply of each frame, and dispatches the kernel over
+//! the source field. Drawing reuses the raster connectivity seam with
+//! `index_buffer: None` (non-indexed `draw_indirect`).
+
+use bevy::prelude::*;
+use bevy::render::render_resource::BufferUsages;
+use processing_core::{app_mut, error};
+
+use crate::geometry::Topology;
+use crate::particles::{Connectivity, Particles};
+use crate::shader_value::ShaderValue;
+
+/// Layout of the args buffer, in u32 words. The first four words are the
+/// non-indexed `DrawIndirect` arguments; the tail is stats + configuration
+/// for `processing::prims` (see `shaders/processing/prims.wesl`).
+const ARGS_WORDS: usize = 8;
+const ARGS_ATTEMPTED_OFFSET: u64 = 16;
+
+/// The reserved binding names declared by `processing::prims`. The WESL
+/// compiler mangles imported module bindings, so these are matched by
+/// suffix against the kernel's reflected parameter names.
+const RESERVED_POSITION: &str = "prims_out_position";
+const RESERVED_COLOR: &str = "prims_out_color";
+const RESERVED_ARGS: &str = "prims_args";
+
+#[derive(Component)]
+pub struct PrimitivesTarget {
+    /// The internal particle field holding the expanded vertices.
+    pub field: Entity,
+    /// The source field the kernels dispatch over.
+    pub source: Entity,
+    pub topology: Topology,
+    pub capacity_prims: u32,
+    pub verts_per_prim: u32,
+    /// The widened indirect-args buffer (also the field's connectivity).
+    pub args: Entity,
+}
+
+fn verts_per_prim(topology: Topology) -> error::Result<u32> {
+    match topology {
+        Topology::PointList => Ok(1),
+        Topology::LineList => Ok(2),
+        Topology::TriangleList => Ok(3),
+        _ => Err(error::ProcessingError::InvalidArgument(format!(
+            "primitives targets support POINTS, LINES, and TRIANGLES; \
+             strips have shared vertices — use an index buffer instead \
+             (got {topology:?})",
+        ))),
+    }
+}
+
+fn u32s_to_bytes(values: &[u32]) -> Vec<u8> {
+    values.iter().flat_map(|v| v.to_le_bytes()).collect()
+}
+
+/// Creates a primitives target over `source`. Backs `p.primitives(...)`.
+pub fn particles_primitives_create(
+    source: Entity,
+    topology: Topology,
+    capacity_prims: u32,
+) -> error::Result<Entity> {
+    let vpp = verts_per_prim(topology)?;
+    let capacity_verts = capacity_prims
+        .checked_mul(vpp)
+        .ok_or_else(|| error::ProcessingError::InvalidArgument("capacity overflow".to_string()))?;
+
+    let position = crate::geometry_attribute_position();
+    let color = crate::geometry_attribute_color();
+    let field = crate::particles_create(capacity_verts, vec![position, color])?;
+
+    let args = crate::buffer_create_with_usage(
+        ARGS_WORDS as u64 * 4,
+        BufferUsages::INDIRECT | BufferUsages::STORAGE,
+    )?;
+    crate::buffer_write(
+        args,
+        u32s_to_bytes(&[0, 1, 0, 0, 0, capacity_verts, vpp, 0]),
+    )?;
+
+    app_mut(|app| {
+        let mut field_data = app
+            .world_mut()
+            .get_mut::<Particles>(field)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        field_data.connectivity = Some(Connectivity {
+            index_buffer: None,
+            indirect_buffer: args,
+        });
+        Ok(app
+            .world_mut()
+            .spawn(PrimitivesTarget {
+                field,
+                source,
+                topology,
+                capacity_prims,
+                verts_per_prim: vpp,
+                args,
+            })
+            .id())
+    })
+}
+
+/// Resolves a reserved `processing::prims` binding to its mangled reflected
+/// name in the kernel, then binds the buffer through the normal path.
+fn set_reserved_buffer(
+    compute_entity: Entity,
+    reserved: &str,
+    buffer_entity: Entity,
+) -> error::Result<()> {
+    let actual = app_mut(|app| {
+        let compute = app
+            .world()
+            .get::<crate::compute::Compute>(compute_entity)
+            .ok_or(error::ProcessingError::ComputeNotFound)?;
+        let reflection = compute.shader.reflection();
+        let name = reflection
+            .parameters()
+            .filter_map(|p| p.name().map(String::from))
+            .find(|n| n == reserved || n.ends_with(reserved) || n.contains(reserved));
+        Ok(name)
+    })?;
+    let Some(actual) = actual else {
+        return Err(error::ProcessingError::InvalidArgument(format!(
+            "kernel does not import `processing::prims` (no `{reserved}` binding); \
+             add `import {{ processing::prims }};` to add primitives from a kernel",
+        )));
+    };
+    crate::compute_set(compute_entity, actual, ShaderValue::Buffer(buffer_entity))
+}
+
+/// Applies `kernel` over the target's source field with the target's buffers
+/// bound under the `processing::prims` reserved names. The first apply after
+/// the target was drawn resets the primitive count; further applies before
+/// the next draw append.
+pub fn particles_primitives_apply(
+    target_entity: Entity,
+    compute_entity: Entity,
+) -> error::Result<()> {
+    let (field, source, args, drawn) = app_mut(|app| {
+        let target = app
+            .world()
+            .get::<PrimitivesTarget>(target_entity)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        let (field, source, args) = (target.field, target.source, target.args);
+        let mut field_data = app
+            .world_mut()
+            .get_mut::<Particles>(field)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        let drawn = std::mem::take(&mut field_data.drawn_since_apply);
+        Ok((field, source, args, drawn))
+    })?;
+
+    if drawn {
+        // Reset draw count + attempted; instance_count stays 1, and the
+        // capacity/verts-per-prim tail is untouched.
+        crate::buffer_write_element(args, 0, u32s_to_bytes(&[0, 1, 0, 0, 0]))?;
+    }
+
+    let (position_buf, color_buf) = app_mut(|app| {
+        let world = app.world();
+        let attrs = world.resource::<crate::geometry::attribute::BuiltinAttributes>();
+        let (position_attr, color_attr) = (attrs.position, attrs.color);
+        let field_data = world
+            .get::<Particles>(field)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        let position = field_data
+            .buffer(position_attr)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        let color = field_data
+            .buffer(color_attr)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        Ok((position, color))
+    })?;
+
+    set_reserved_buffer(compute_entity, RESERVED_POSITION, position_buf)?;
+    set_reserved_buffer(compute_entity, RESERVED_COLOR, color_buf)?;
+    set_reserved_buffer(compute_entity, RESERVED_ARGS, args)?;
+
+    crate::particles::particles_apply(source, compute_entity)
+}
+
+/// The internal particle field holding a target's expanded vertices (what
+/// `particles(target)` draws).
+pub fn particles_primitives_field(target_entity: Entity) -> error::Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world()
+            .get::<PrimitivesTarget>(target_entity)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?
+            .field)
+    })
+}
+
+/// Primitives the kernels attempted to add this frame (including any dropped
+/// for capacity). Reads a 4-byte stat from the GPU; call it when you want
+/// the number, not every frame.
+pub fn particles_primitives_attempted(target_entity: Entity) -> error::Result<u32> {
+    let args = app_mut(|app| {
+        Ok(app
+            .world()
+            .get::<PrimitivesTarget>(target_entity)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?
+            .args)
+    })?;
+    let bytes = crate::buffer_read_element(args, ARGS_ATTEMPTED_OFFSET, 4)?;
+    Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
+}
diff --git a/crates/processing_render/src/render/material.rs b/crates/processing_render/src/render/material.rs
index d6ab6e4f..828f2862 100644
--- a/crates/processing_render/src/render/material.rs
+++ b/crates/processing_render/src/render/material.rs
@@ -105,7 +105,7 @@ impl MaterialKey {
         }
     }
 
-    fn to_standard_material(&self) -> StandardMaterial {
+    pub(crate) fn to_standard_material(&self) -> StandardMaterial {
         match self {
             MaterialKey::Color {
                 transparent,
diff --git a/crates/processing_render/src/render/mod.rs b/crates/processing_render/src/render/mod.rs
index 36561130..1a5c7323 100644
--- a/crates/processing_render/src/render/mod.rs
+++ b/crates/processing_render/src/render/mod.rs
@@ -984,20 +984,27 @@ pub fn flush_draw_commands(
                     };
                     let position = buffer.handle.clone();
                     let count = particles_data.capacity;
+                    particles_data.drawn_since_apply = true;
 
                     let (index, indirect) = match particles_data.connectivity {
                         Some(connectivity) => {
-                            let (Ok(index_buf), Ok(indirect_buf)) = (
-                                p_particle_buffers.get(connectivity.index_buffer),
-                                p_particle_buffers.get(connectivity.indirect_buffer),
-                            ) else {
+                            let Ok(indirect_buf) =
+                                p_particle_buffers.get(connectivity.indirect_buffer)
+                            else {
                                 warn!("connectivity buffers for {:?} not found", particles);
                                 continue;
                             };
-                            (
-                                Some(index_buf.handle.clone()),
-                                Some(indirect_buf.handle.clone()),
-                            )
+                            let index = match connectivity.index_buffer {
+                                Some(index_entity) => {
+                                    let Ok(index_buf) = p_particle_buffers.get(index_entity) else {
+                                        warn!("connectivity buffers for {:?} not found", particles);
+                                        continue;
+                                    };
+                                    Some(index_buf.handle.clone())
+                                }
+                                None => None,
+                            };
+                            (index, Some(indirect_buf.handle.clone()))
                         }
                         None => (None, None),
                     };
@@ -1084,13 +1091,24 @@ pub fn flush_draw_commands(
                                     warn!("Could not find material for entity {:?}", mat_entity);
                                     continue;
                                 };
-                                clone_custom_material_with_blend(
-                                    &mut res.custom_materials,
-                                    &untyped.0,
-                                    *blend_state,
-                                )
+                                clone_material_with_blend(&mut res, &untyped.0, *blend_state)
+                            }
+                            _ => {
+                                // map fill to the base color
+                                let mut base = material_key.to_standard_material();
+                                if let Some(color) = state.style.fill.color() {
+                                    base.base_color = color;
+                                }
+                                res.materials
+                                    .add(ProcessingExtendedMaterial {
+                                        base,
+                                        extension: ProcessingMaterial {
+                                            blend_state: material_key.blend_state(),
+                                            depth_write: None,
+                                        },
+                                    })
+                                    .untyped()
                             }
-                            _ => material_key.to_material(&mut res.materials),
                         }
                     };
 
@@ -1505,6 +1523,39 @@ fn clone_custom_material_with_blend(
     }
 }
 
+fn clone_material_with_blend(
+    res: &mut RenderResources,
+    original: &UntypedHandle,
+    blend_state: Option<BlendState>,
+) -> UntypedHandle {
+    let Some(bs) = blend_state else {
+        return original.clone();
+    };
+
+    if let Ok(handle) = original
+        .clone()
+        .try_typed::<crate::particles::material::ParticlesMaterial>()
+    {
+        if let Some(original_mat) = res.particles_materials.get(&handle) {
+            let mut variant = original_mat.clone();
+            variant.extension.blend_state = Some(bs);
+            variant.base.alpha_mode = AlphaMode::Blend;
+            return res.particles_materials.add(variant).untyped();
+        }
+    }
+
+    if let Ok(handle) = original.clone().try_typed::<ProcessingExtendedMaterial>() {
+        if let Some(original_mat) = res.materials.get(&handle) {
+            let mut variant = original_mat.clone();
+            variant.extension.blend_state = Some(bs);
+            variant.base.alpha_mode = AlphaMode::Blend;
+            return res.materials.add(variant).untyped();
+        }
+    }
+
+    clone_custom_material_with_blend(&mut res.custom_materials, original, Some(bs))
+}
+
 fn material_key_with_color(
     key: &MaterialKey,
     color: Color,
@@ -1553,6 +1604,8 @@ fn particles_fill_material(
         extension: ParticlesExtension {
             colors: Some(buf.handle.clone()),
             emissive_colors: None,
+            blend_state: None,
+            depth_write: None,
         },
     });
     Some(handle.untyped())
diff --git a/examples/particles_stress.rs b/examples/particles_stress.rs
index 281f4382..61c3f957 100644
--- a/examples/particles_stress.rs
+++ b/examples/particles_stress.rs
@@ -1,31 +1,79 @@
+//! One million spheres. Still the instancing stress test — tens of millions
+//! of triangles a frame, every position rebuilt analytically by a compute
+//! kernel each frame — as a sheet of silk.
+//!
+//! The million pearls are the threads of one wide veil, 1000 x 1000, lifted
+//! by three layered traveling waves plus a slow fold that bunches the cloth
+//! like wind does. Color is a single continuous pastel gradient woven across
+//! the sheet — peach to blush to lavender to sky — so the surface reads as
+//! one piece of fabric, never as scattered particles. Flat unlit shading on
+//! a warm cream ground.
+//!
+//! The camera breathes: a log-eased dolly that swoops from a wide view down
+//! to skim just above the rippling surface, then lifts back out, drifting
+//! around the sheet the whole time.
+
+use std::time::Instant;
+
 use processing_glfw::GlfwContext;
 
 use bevy::math::Vec3;
 use processing::prelude::*;
 use processing_render::render::command::DrawCommand;
 
-const GRID: u32 = 100; // GRID^3 particles
-const SPACING: f32 = 1.0;
+const COLS: u32 = 1000;
+const ROWS: u32 = 1000;
+const SHEET_W: f32 = 170.0; // world width of the veil
+const SHEET_D: f32 = 105.0; // world depth
+const AMP: f32 = 9.0; // wave amplitude
+
+const DIVE_PERIOD: f32 = 40.0; // seconds per in-and-out breath
+const AZIMUTH_RATE: f32 = 0.06; // radians/sec of orbital drift
 
-const SPIN_SHADER: &str = r#"
+const SILK_SHADER: &str = r#"
 struct Params {
-    dt: f32,
+    time: f32,
+    sheet_w: f32,
+    sheet_d: f32,
+    amp: f32,
 }
 
 @group(0) @binding(0) var<storage, read_write> position: array<f32>;
-@group(0) @binding(1) var<uniform> params: Params;
+// x = u (0..1 across), y = v (0..1 along), z/w = per-thread jitter
+@group(0) @binding(1) var<storage, read> seeds: array<vec4<f32>>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+const TAU: f32 = 6.28318530718;
 
 @compute @workgroup_size(64)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let i = gid.x;
     let count = arrayLength(&position) / 3u;
     if i >= count { return; }
-    let cs = cos(params.dt);
-    let sn = sin(params.dt);
-    let x = position[i * 3u + 0u];
-    let z = position[i * 3u + 2u];
-    position[i * 3u + 0u] = x * cs - z * sn;
-    position[i * 3u + 2u] = x * sn + z * cs;
+
+    let s = seeds[i];
+    let u = s.x;
+    let v = s.y;
+    let t = params.time;
+
+    // Three traveling waves at different scales and headings make the lift;
+    // their sum is the silk. Slow phases: fabric, not water.
+    let lift = 0.52 * sin(u * TAU * 1.7 + t * 0.50 + v * 2.3)
+             + 0.33 * sin(v * TAU * 1.1 - t * 0.36 + u * 3.1)
+             + 0.15 * sin((u + v) * TAU * 3.4 + t * 0.74);
+
+    // A gentle in-plane compression bunches the threads into folds where the
+    // cloth crests, the way real fabric gathers.
+    let fold_x = 2.6 * sin(v * TAU * 0.9 + t * 0.22);
+    let fold_z = 1.8 * sin(u * TAU * 1.3 - t * 0.17);
+
+    let x = (u - 0.5) * params.sheet_w + fold_x + s.z;
+    let z = (v - 0.5) * params.sheet_d + fold_z + s.w;
+    let y = lift * params.amp;
+
+    position[i * 3u + 0u] = x;
+    position[i * 3u + 1u] = y;
+    position[i * 3u + 2u] = z;
 }
 "#;
 
@@ -47,95 +95,132 @@ fn hash_unit(seed: u32) -> f32 {
     (hash_u32(seed) as f32) / (u32::MAX as f32)
 }
 
+fn lerp3(a: [f32; 3], b: [f32; 3], t: f32) -> [f32; 3] {
+    [
+        a[0] + (b[0] - a[0]) * t,
+        a[1] + (b[1] - a[1]) * t,
+        a[2] + (b[2] - a[2]) * t,
+    ]
+}
+
+/// One continuous pastel gradient across the sheet: bilinear blend of four
+/// corner colors, so neighboring threads always share their hue.
+fn silk_color(u: f32, v: f32) -> [f32; 3] {
+    const PEACH: [f32; 3] = [1.00, 0.83, 0.72]; // #FFD4B8
+    const BLUSH: [f32; 3] = [1.00, 0.68, 0.82]; // #FFAED1
+    const LAVENDER: [f32; 3] = [0.80, 0.71, 0.96]; // #CCB5F5
+    const SKY: [f32; 3] = [0.74, 0.88, 1.00]; // #BDE0FF
+    let top = lerp3(PEACH, BLUSH, u);
+    let bottom = lerp3(LAVENDER, SKY, u);
+    lerp3(top, bottom, v)
+}
+
 fn sketch() -> error::Result<()> {
-    let mut glfw_ctx = GlfwContext::new(900, 700)?;
+    let mut glfw_ctx = GlfwContext::new(900, 700, false)?;
     init(Config::default())?;
 
-    let surface = glfw_ctx.create_surface(900, 700)?;
+    let surface = glfw_ctx.create_surface(900, 700, false)?;
     let graphics = graphics_create(surface, 900, 700, TextureFormat::Rgba16Float)?;
 
     graphics_mode_3d(graphics)?;
-    let extent = (GRID as f32) * SPACING * 0.5;
-    transform_set_position(graphics, Vec3::new(0.0, extent * 0.6, extent * 2.5))?;
-    transform_look_at(graphics, Vec3::new(0.0, 0.0, 0.0))?;
-    graphics_orbit_camera(graphics)?;
-
-    let red = light_create_directional(graphics, bevy::color::Color::srgb(1.0, 0.0, 0.0), 1000.0)?;
-    transform_set_position(red, Vec3::new(1.0, 0.0, 0.0))?;
-    transform_look_at(red, Vec3::ZERO)?;
-
-    let green =
-        light_create_directional(graphics, bevy::color::Color::srgb(0.0, 1.0, 0.0), 1000.0)?;
-    transform_set_position(green, Vec3::new(0.0, 1.0, 0.0))?;
-    transform_look_at(green, Vec3::ZERO)?;
 
-    let blue = light_create_directional(graphics, bevy::color::Color::srgb(0.0, 0.0, 1.0), 1000.0)?;
-    transform_set_position(blue, Vec3::new(0.0, 0.0, 1.0))?;
-    transform_look_at(blue, Vec3::ZERO)?;
+    // Flat pastel rendering: no bloom, no filmic tonemapping, no lights —
+    // the material is unlit and the gradient carries everything.
+    graphics_remove_bloom(graphics)?;
 
-    let cube = geometry_box(0.35, 0.35, 0.35)?;
+    let pearl = geometry_sphere(0.16, 6, 4)?;
 
-    let capacity = GRID * GRID * GRID;
+    let count = COLS * ROWS;
     let position_attr = geometry_attribute_position();
     let color_attr = geometry_attribute_color();
-    let p = particles_create(capacity, vec![position_attr, color_attr])?;
-
-    let mut positions: Vec<f32> = Vec::with_capacity(capacity as usize * 3);
-    let mut colors: Vec<f32> = Vec::with_capacity(capacity as usize * 4);
-    let extent_half = (GRID as f32) * SPACING * 0.5;
-    for i in 0..capacity {
-        let rx = hash_unit(i.wrapping_mul(2654435761).wrapping_add(0x9E37));
-        let ry = hash_unit(i.wrapping_mul(40503).wrapping_add(0x68E1));
-        let rz = hash_unit(i.wrapping_mul(2246822519).wrapping_add(0xC2B2));
-        positions.push((rx * 2.0 - 1.0) * extent_half);
-        positions.push((ry * 2.0 - 1.0) * extent_half);
-        positions.push((rz * 2.0 - 1.0) * extent_half);
-        colors.push(rx);
-        colors.push(ry);
-        colors.push(rz);
-        colors.push(1.0);
+    let p = particles_create(count, vec![position_attr, color_attr])?;
+
+    let mut seeds: Vec<f32> = Vec::with_capacity(count as usize * 4);
+    let mut colors: Vec<f32> = Vec::with_capacity(count as usize * 4);
+
+    for i in 0..count {
+        let col = i % COLS;
+        let row = i / COLS;
+        // Sub-thread jitter keeps the weave from moiréing without ever
+        // moving a thread far from its neighbors.
+        let u = (col as f32 + hash_unit(i ^ 0x517C_C1B7) * 0.9) / COLS as f32;
+        let v = (row as f32 + hash_unit(i ^ 0x94D0_49BB) * 0.9) / ROWS as f32;
+        let jx = (hash_unit(i ^ 0xC2B2_AE35) - 0.5) * 0.25;
+        let jz = (hash_unit(i ^ 0x27D4_EB2F) - 0.5) * 0.25;
+        seeds.extend_from_slice(&[u, v, jx, jz]);
+
+        let c = silk_color(u, v);
+        colors.extend_from_slice(&[c[0], c[1], c[2], 1.0]);
     }
-    let position_buf =
-        particles_buffer(p, position_attr)?.ok_or(error::ProcessingError::ParticlesNotFound)?;
+
     let color_buf =
         particles_buffer(p, color_attr)?.ok_or(error::ProcessingError::ParticlesNotFound)?;
-    buffer_write(
-        position_buf,
-        positions.iter().flat_map(|f| f.to_le_bytes()).collect(),
-    )?;
+    let seed_buf = buffer_create(count as u64 * 4 * 4)?;
     buffer_write(
         color_buf,
         colors.iter().flat_map(|f| f.to_le_bytes()).collect(),
     )?;
+    buffer_write(
+        seed_buf,
+        seeds.iter().flat_map(|f| f.to_le_bytes()).collect(),
+    )?;
 
     let mat = {
-        let m = material_create_pbr()?;
+        let m = material_create_unlit()?;
         material_set_albedo_buffer(m, color_buf)?;
         m
     };
-    let spin_shader = shader_create(SPIN_SHADER)?;
-    let spin = compute_create(spin_shader)?;
 
-    eprintln!("{capacity} particles");
+    let silk_shader = shader_create(SILK_SHADER)?;
+    let silk = compute_create(silk_shader)?;
+    compute_set(silk, "seeds", shader_value::ShaderValue::Buffer(seed_buf))?;
+    compute_set(silk, "sheet_w", shader_value::ShaderValue::Float(SHEET_W))?;
+    compute_set(silk, "sheet_d", shader_value::ShaderValue::Float(SHEET_D))?;
+    compute_set(silk, "amp", shader_value::ShaderValue::Float(AMP))?;
+
+    eprintln!("{count} particles");
+
+    let start = Instant::now();
+    let far = SHEET_W * 0.95;
+    let near = AMP * 2.2; // skimming height at the bottom of the breath
 
     while glfw_ctx.poll_events() {
+        let time = start.elapsed().as_secs_f32();
+
+        // Breathing swoop: wide 3/4 view down to a low glide over the
+        // surface and back, log-eased so the descent feels constant-speed,
+        // drifting around the sheet all the while.
+        let phase = 0.5 - 0.5 * (std::f32::consts::TAU * time / DIVE_PERIOD).cos();
+        let dist = (far.ln() + (near.ln() - far.ln()) * phase).exp();
+        let az = time * AZIMUTH_RATE;
+        let height = AMP * 1.6 + dist * 0.55;
+        transform_set_position(
+            graphics,
+            Vec3::new(az.cos() * dist, height, az.sin() * dist),
+        )?;
+        // Look slightly past center so the low pass sweeps across the silk
+        // instead of pinning to one spot.
+        transform_look_at(graphics, Vec3::new(-az.sin() * 8.0, 0.0, az.cos() * 8.0))?;
+
         graphics_begin_draw(graphics)?;
         graphics_record_command(
             graphics,
-            DrawCommand::BackgroundColor(bevy::color::Color::srgb(0.04, 0.04, 0.07)),
+            // Warm cream ground.
+            DrawCommand::BackgroundColor(bevy::color::Color::srgb_u8(250, 245, 240)),
         )?;
         graphics_record_command(graphics, DrawCommand::Material(mat))?;
         graphics_record_command(
             graphics,
             DrawCommand::Particles {
                 particles: p,
-                geometry: cube,
+                geometry: Some(pearl),
+                topology: processing_render::geometry::Topology::TriangleList,
             },
         )?;
         graphics_end_draw(graphics)?;
 
-        compute_set(spin, "dt", shader_value::ShaderValue::Float(0.003))?;
-        particles_apply(p, spin)?;
+        compute_set(silk, "time", shader_value::ShaderValue::Float(time))?;
+        particles_apply(p, silk)?;
     }
 
     Ok(())
diff --git a/src/lib.rs b/src/lib.rs
index e86cd758..9e1cbd36 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -60,7 +60,8 @@ fn create_app(config: Config) -> App {
         });
 
     app.add_plugins(plugins);
-    app.add_plugins(processing_midi::MidiPlugin);
+    // TEMP(bevy-020): midi disabled
+    // app.add_plugins(processing_midi::MidiPlugin);
     app.add_plugins(processing_input::InputPlugin);
     app.add_plugins(processing_render::ProcessingRenderPlugin);
 
diff --git a/src/prelude.rs b/src/prelude.rs
index 34f95a3d..8ce57fee 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -4,11 +4,41 @@ pub use bevy::prelude::default;
 pub use bevy::render::render_resource::TextureFormat;
 pub use processing_core::{config::*, constants, error};
 pub use processing_input::*;
+// TEMP(bevy-020): processing_midi pins bevy 0.19; stubbed while the port is
+// in progress. Restore the re-export (plus Cargo.toml deps and the
+// MidiPlugin registration in lib.rs) once nannou_midi is ported.
 #[cfg(not(target_arch = "wasm32"))]
-pub use processing_midi::{
-    midi_connect, midi_disconnect, midi_list_ports, midi_note_off, midi_note_on, midi_play_notes,
-    midi_refresh_ports,
-};
+mod midi_stubs {
+    use processing_core::error::{ProcessingError, Result};
+    fn unavailable<T>() -> Result<T> {
+        Err(ProcessingError::InvalidArgument(
+            "midi support is temporarily disabled in this build".to_string(),
+        ))
+    }
+    pub fn midi_connect(_port: usize) -> Result<()> {
+        unavailable()
+    }
+    pub fn midi_disconnect() -> Result<()> {
+        unavailable()
+    }
+    pub fn midi_list_ports() -> Result<Vec<String>> {
+        unavailable()
+    }
+    pub fn midi_refresh_ports() -> Result<()> {
+        unavailable()
+    }
+    pub fn midi_play_notes(_note: u8, _duration: u64) -> Result<()> {
+        unavailable()
+    }
+    pub fn midi_note_on(_note: u8, _velocity: u8) -> Result<()> {
+        unavailable()
+    }
+    pub fn midi_note_off(_note: u8) -> Result<()> {
+        unavailable()
+    }
+}
+#[cfg(not(target_arch = "wasm32"))]
+pub use midi_stubs::*;
 pub use processing_render::{
     render::command::{
         ArcMode, BlendMode, DrawCommand, ShapeKind, ShapeMode, StrokeCapMode, StrokeJoinMode,

From d98a84e00dbee9f660681365d858253c344f2155 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Fri, 14 Aug 2026 20:53:11 -0700
Subject: [PATCH 11/14] .

---
 .../examples/particles_lissajous.py           | 20 +++--------
 crates/processing_render/src/lib.rs           | 34 ++++++++++++++++---
 .../processing_render/src/particles/emit.rs   |  5 +++
 .../processing_render/src/particles/grid.rs   | 10 +++---
 .../src/particles/kernels/mod.rs              |  1 +
 .../src/particles/kernels/prims_reset.wgsl    | 24 +++++++++++++
 .../processing_render/src/particles/prims.rs  | 22 ++++++++----
 .../processing_render/src/particles/scan.rs   |  6 ++--
 crates/processing_render/src/render/mod.rs    | 10 +++++-
 9 files changed, 98 insertions(+), 34 deletions(-)
 create mode 100644 crates/processing_render/src/particles/kernels/prims_reset.wgsl

diff --git a/crates/processing_pyo3/examples/particles_lissajous.py b/crates/processing_pyo3/examples/particles_lissajous.py
index efd7fa1f..5bfac1b8 100644
--- a/crates/processing_pyo3/examples/particles_lissajous.py
+++ b/crates/processing_pyo3/examples/particles_lissajous.py
@@ -1,24 +1,15 @@
 from mewnala import *
 from math import cos, sin
 
-ALPHA_OVER = BlendMode(
-    color_src=BlendMode.SRC_ALPHA,
-    color_dst=BlendMode.ONE_MINUS_SRC_ALPHA,
-    color_op=BlendMode.OP_ADD,
-    alpha_src=BlendMode.ONE,
-    alpha_dst=BlendMode.ONE_MINUS_SRC_ALPHA,
-    alpha_op=BlendMode.OP_ADD,
-)
-
 N = 10000
 SCALE = 10.0
 FX, FY, FZ = 3.0, 4.0, 5.0
 
-CONNECTION_RADIUS = 3.5  # link points closer than this
-CONNECTION_RAMP = 6.0    # alpha = (1/(d/R + 1))^ramp
-LINE_ALPHA = 0.5         # overall opacity scale
-MAX_LINES = 2_000_000    # capacity of the dynamic line set (extra dropped, see edges.overflowed())
-HUE_MIX = 0.0            # 0 = grayscale, 1 = rainbow
+CONNECTION_RADIUS = 3.5
+CONNECTION_RAMP = 6.0
+LINE_ALPHA = 0.5
+MAX_LINES = 2_000_000
+HUE_MIX = 0.0
 
 p = None
 edges = None
@@ -64,7 +55,6 @@ def draw():
     grid.bind(link)
     p.apply(link, primitives=edges)
 
-    blend_mode(ALPHA_OVER)
     particles(edges)
 
 
diff --git a/crates/processing_render/src/lib.rs b/crates/processing_render/src/lib.rs
index 8ddbd15e..072960e2 100644
--- a/crates/processing_render/src/lib.rs
+++ b/crates/processing_render/src/lib.rs
@@ -2461,7 +2461,34 @@ pub fn compute_set(
 pub fn compute_dispatch(entity: Entity, x: u32, y: u32, z: u32) -> error::Result<()> {
     app_mut(|app| {
         app.update();
-        
+        dispatch_inner(app, entity, x, y, z)
+    })
+}
+
+/// Dispatch without pumping a full `app.update()` first. Multi-pass GPU
+/// algorithms (grid build, prefix sum) and per-frame kernel chains issue
+/// many dispatches back to back; running the entire app schedule between
+/// each one costs an engine frame per dispatch and dwarfs the GPU work.
+/// Queue submission order already guarantees pass ordering. The one thing
+/// `update()` provides that a dispatch may genuinely need is pipeline
+/// compilation on first use — so on `PipelineNotReady` we pump once and
+/// retry.
+pub(crate) fn compute_dispatch_quiet(
+    entity: Entity,
+    x: u32,
+    y: u32,
+    z: u32,
+) -> error::Result<()> {
+    app_mut(|app| match dispatch_inner(app, entity, x, y, z) {
+        Err(error::ProcessingError::PipelineNotReady(_)) => {
+            app.update();
+            dispatch_inner(app, entity, x, y, z)
+        }
+        r => r,
+    })
+}
+
+fn dispatch_inner(app: &mut App, entity: Entity, x: u32, y: u32, z: u32) -> error::Result<()> {
     let args = {
         let world = app.world();
         let c = world
@@ -2481,9 +2508,8 @@ pub fn compute_dispatch(entity: Entity, x: u32, y: u32, z: u32) -> error::Result
     app.sub_app_mut(bevy::render::RenderApp)
         .world_mut()
         .run_system_cached_with(compute::dispatch, args)
-                    .unwrap()
-    })
-            }
+        .unwrap()
+}
 
 pub fn compute_destroy(entity: Entity) -> error::Result<()> {
     app_mut(|app| {
diff --git a/crates/processing_render/src/particles/emit.rs b/crates/processing_render/src/particles/emit.rs
index f08a89af..7203b650 100644
--- a/crates/processing_render/src/particles/emit.rs
+++ b/crates/processing_render/src/particles/emit.rs
@@ -374,6 +374,11 @@ pub fn particles_apply(particles_entity: Entity, compute_entity: Entity) -> erro
         }
     }
 
+    // Full dispatch (with app.update()) on purpose: user-facing applies must
+    // see resources created earlier in the same frame — the strong "set then
+    // apply just works" invariant. The quiet variant is reserved for the
+    // internal grid/scan passes, where no new resources can appear between
+    // dispatches.
     let workgroup_count = capacity.div_ceil(WORKGROUP_SIZE);
     compute_dispatch(compute_entity, workgroup_count, 1, 1)
 }
diff --git a/crates/processing_render/src/particles/grid.rs b/crates/processing_render/src/particles/grid.rs
index 0a31f069..45e6ae27 100644
--- a/crates/processing_render/src/particles/grid.rs
+++ b/crates/processing_render/src/particles/grid.rs
@@ -6,7 +6,7 @@ use processing_core::error::Result;
 
 use crate::particles::scan::prefix_sum_u32;
 use crate::shader_value::ShaderValue;
-use crate::{buffer_create, compute_create, compute_dispatch, compute_set, shader_load};
+use crate::{buffer_create, compute_create, compute_dispatch_quiet, compute_set, shader_load};
 
 const CLEAR_SHADER: &str = "embedded://processing_render/particles/kernels/grid_clear.wgsl";
 const COUNT_SHADER: &str = "embedded://processing_render/particles/kernels/grid_count.wgsl";
@@ -89,24 +89,24 @@ pub fn grid_build(grid: &Grid, position: Entity) -> Result<()> {
     let num_cells = grid.params.num_cells();
 
     compute_set(clear, "counts", ShaderValue::Buffer(grid.offsets))?;
-    compute_dispatch(clear, (num_cells + 1).div_ceil(CLEAR_WG), 1, 1)?;
+    compute_dispatch_quiet(clear, (num_cells + 1).div_ceil(CLEAR_WG), 1, 1)?;
 
     compute_set(count, "position", ShaderValue::Buffer(position))?;
     compute_set(count, "counts", ShaderValue::Buffer(grid.offsets))?;
     set_domain(count, &grid.params)?;
-    compute_dispatch(count, grid.capacity.div_ceil(PARTICLE_WG), 1, 1)?;
+    compute_dispatch_quiet(count, grid.capacity.div_ceil(PARTICLE_WG), 1, 1)?;
 
     prefix_sum_u32(grid.offsets)?;
 
     compute_set(copy, "starts", ShaderValue::Buffer(grid.offsets))?;
     compute_set(copy, "cursor", ShaderValue::Buffer(grid.cursor))?;
-    compute_dispatch(copy, num_cells.div_ceil(COPY_WG), 1, 1)?;
+    compute_dispatch_quiet(copy, num_cells.div_ceil(COPY_WG), 1, 1)?;
 
     compute_set(scatter, "position", ShaderValue::Buffer(position))?;
     compute_set(scatter, "cursor", ShaderValue::Buffer(grid.cursor))?;
     compute_set(scatter, "sorted", ShaderValue::Buffer(grid.sorted))?;
     set_domain(scatter, &grid.params)?;
-    compute_dispatch(scatter, grid.capacity.div_ceil(PARTICLE_WG), 1, 1)?;
+    compute_dispatch_quiet(scatter, grid.capacity.div_ceil(PARTICLE_WG), 1, 1)?;
 
     Ok(())
 }
diff --git a/crates/processing_render/src/particles/kernels/mod.rs b/crates/processing_render/src/particles/kernels/mod.rs
index 0a36e0f5..6c19bf3a 100644
--- a/crates/processing_render/src/particles/kernels/mod.rs
+++ b/crates/processing_render/src/particles/kernels/mod.rs
@@ -63,6 +63,7 @@ impl Plugin for ParticlesKernelsPlugin {
         embedded_asset!(app, "compact_scatter.wgsl");
         embedded_asset!(app, "reduce.wgsl");
         embedded_asset!(app, "neighbor.wgsl");
+        embedded_asset!(app, "prims_reset.wgsl");
     }
 }
 
diff --git a/crates/processing_render/src/particles/kernels/prims_reset.wgsl b/crates/processing_render/src/particles/kernels/prims_reset.wgsl
new file mode 100644
index 00000000..867ab63c
--- /dev/null
+++ b/crates/processing_render/src/particles/kernels/prims_reset.wgsl
@@ -0,0 +1,24 @@
+// Zeroes a primitives target's per-frame counts (drawn vertex count + the
+// attempted stat) on the GPU, so the reset is ordered in the command stream
+// ahead of the kernels that append — a CPU-side asset write would race the
+// dispatches. Layout mirrors PrimsArgs in shaders/processing/prims.wesl;
+// instance_count and the capacity tail are left untouched.
+
+struct PrimsArgs {
+    vertex_count: atomic<u32>,
+    instance_count: u32,
+    first_vertex: u32,
+    first_instance: u32,
+    attempted: atomic<u32>,
+    capacity_verts: u32,
+    verts_per_prim: u32,
+    _pad: u32,
+}
+
+@group(0) @binding(0) var<storage, read_write> prims_args: PrimsArgs;
+
+@compute @workgroup_size(1)
+fn main() {
+    atomicStore(&prims_args.vertex_count, 0u);
+    atomicStore(&prims_args.attempted, 0u);
+}
diff --git a/crates/processing_render/src/particles/prims.rs b/crates/processing_render/src/particles/prims.rs
index 128148f6..24182f05 100644
--- a/crates/processing_render/src/particles/prims.rs
+++ b/crates/processing_render/src/particles/prims.rs
@@ -41,6 +41,10 @@ pub struct PrimitivesTarget {
     pub verts_per_prim: u32,
     /// The widened indirect-args buffer (also the field's connectivity).
     pub args: Entity,
+    /// One-thread kernel that zeroes the per-frame counts in `args`. Reset
+    /// must happen on the GPU: a CPU-side asset write races the kernel
+    /// dispatches, silently clobbering a frame's output either way it lands.
+    pub reset_kernel: Entity,
 }
 
 fn verts_per_prim(topology: Topology) -> error::Result<u32> {
@@ -84,6 +88,12 @@ pub fn particles_primitives_create(
         u32s_to_bytes(&[0, 1, 0, 0, 0, capacity_verts, vpp, 0]),
     )?;
 
+    let reset_shader = crate::shader_load(
+        "embedded://processing_render/particles/kernels/prims_reset.wgsl",
+    )?;
+    let reset_kernel = crate::compute_create(reset_shader)?;
+    crate::compute_set(reset_kernel, "prims_args", ShaderValue::Buffer(args))?;
+
     app_mut(|app| {
         let mut field_data = app
             .world_mut()
@@ -102,6 +112,7 @@ pub fn particles_primitives_create(
                 capacity_prims,
                 verts_per_prim: vpp,
                 args,
+                reset_kernel,
             })
             .id())
     })
@@ -143,24 +154,23 @@ pub fn particles_primitives_apply(
     target_entity: Entity,
     compute_entity: Entity,
 ) -> error::Result<()> {
-    let (field, source, args, drawn) = app_mut(|app| {
+    let (field, source, args, reset_kernel, drawn) = app_mut(|app| {
         let target = app
             .world()
             .get::<PrimitivesTarget>(target_entity)
             .ok_or(error::ProcessingError::ParticlesNotFound)?;
-        let (field, source, args) = (target.field, target.source, target.args);
+        let (field, source, args, reset_kernel) =
+            (target.field, target.source, target.args, target.reset_kernel);
         let mut field_data = app
             .world_mut()
             .get_mut::<Particles>(field)
             .ok_or(error::ProcessingError::ParticlesNotFound)?;
         let drawn = std::mem::take(&mut field_data.drawn_since_apply);
-        Ok((field, source, args, drawn))
+        Ok((field, source, args, reset_kernel, drawn))
     })?;
 
     if drawn {
-        // Reset draw count + attempted; instance_count stays 1, and the
-        // capacity/verts-per-prim tail is untouched.
-        crate::buffer_write_element(args, 0, u32s_to_bytes(&[0, 1, 0, 0, 0]))?;
+        crate::compute_dispatch(reset_kernel, 1, 1, 1)?;
     }
 
     let (position_buf, color_buf) = app_mut(|app| {
diff --git a/crates/processing_render/src/particles/scan.rs b/crates/processing_render/src/particles/scan.rs
index bab519e7..6e36e376 100644
--- a/crates/processing_render/src/particles/scan.rs
+++ b/crates/processing_render/src/particles/scan.rs
@@ -6,7 +6,7 @@ use processing_core::error::Result;
 
 use crate::shader_value::ShaderValue;
 use crate::{
-    buffer_create, buffer_destroy, buffer_size, compute_create, compute_dispatch, compute_set,
+    buffer_create, buffer_destroy, buffer_size, compute_create, compute_dispatch_quiet, compute_set,
     shader_load,
 };
 
@@ -67,7 +67,7 @@ pub fn prefix_sum_u32(buffer: Entity) -> Result<()> {
 
         compute_set(block, "data", ShaderValue::Buffer(level_bufs[lvl]))?;
         compute_set(block, "block_sums", ShaderValue::Buffer(sums))?;
-        compute_dispatch(block, num_blocks as u32, 1, 1)?;
+        compute_dispatch_quiet(block, num_blocks as u32, 1, 1)?;
 
         level_bufs.push(sums);
         level_ns.push(num_blocks);
@@ -82,7 +82,7 @@ pub fn prefix_sum_u32(buffer: Entity) -> Result<()> {
         let num_blocks = level_ns[k].div_ceil(BLOCK).max(1);
         compute_set(add, "data", ShaderValue::Buffer(level_bufs[k]))?;
         compute_set(add, "block_sums", ShaderValue::Buffer(level_bufs[k + 1]))?;
-        compute_dispatch(add, num_blocks as u32, 1, 1)?;
+        compute_dispatch_quiet(add, num_blocks as u32, 1, 1)?;
     }
 
     Ok(())
diff --git a/crates/processing_render/src/render/mod.rs b/crates/processing_render/src/render/mod.rs
index 1a5c7323..bd892e9f 100644
--- a/crates/processing_render/src/render/mod.rs
+++ b/crates/processing_render/src/render/mod.rs
@@ -1023,6 +1023,14 @@ pub fn flush_draw_commands(
 
                     flush_batch(&mut res, &mut batch, &p_material_handles);
 
+                    // Processing parity: the default BLEND mode (style state
+                    // `None`) alpha-composites; REPLACE is the opaque
+                    // overwrite fast path.
+                    let blend = match state.style.blend_state {
+                        None => Some(BlendState::ALPHA_BLENDING),
+                        Some(bs) if bs == BlendState::REPLACE => None,
+                        other => other,
+                    };
                     let raster_draw = crate::particles::point_render::ParticleRasterDraw {
                         position,
                         count,
@@ -1031,7 +1039,7 @@ pub fn flush_draw_commands(
                         indirect,
                         color,
                         normal,
-                        blend: state.style.blend_state,
+                        blend,
                     };
                     match particles_data.raster_draw_entity {
                         Some(e) => {

From 6864a865069cf9a650b4d62062b4efc249754c1a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Sat, 15 Aug 2026 14:33:37 -0700
Subject: [PATCH 12/14] Particle draw topology and asset root FFI.

---
 crates/processing_ffi/src/lib.rs              | 203 +++++++++++++++++-
 .../src/particles/kernels/flock_naive.wgsl    | 124 +++++++++++
 2 files changed, 325 insertions(+), 2 deletions(-)
 create mode 100644 crates/processing_render/src/particles/kernels/flock_naive.wgsl

diff --git a/crates/processing_ffi/src/lib.rs b/crates/processing_ffi/src/lib.rs
index e69de277..46c0a480 100644
--- a/crates/processing_ffi/src/lib.rs
+++ b/crates/processing_ffi/src/lib.rs
@@ -27,6 +27,27 @@ pub extern "C" fn processing_init() {
     error::check(|| init(Config::default()));
 }
 
+/// Initialize libProcessing with an asset root directory. Relative paths
+/// passed to `processing_shader_load` (and image/gltf loads) resolve
+/// against this directory. Same constraints as `processing_init`.
+///
+/// SAFETY:
+/// - `asset_root` must be non-null.
+/// - This is called from the main thread if the platform requires it.
+/// - This can only be called once.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_init_with_asset_root(asset_root: *const std::ffi::c_char) {
+    error::clear_error();
+    error::check(|| {
+        let asset_root = unsafe { cstr_to_str(asset_root) }?;
+        let mut config = Config::default();
+        if !asset_root.is_empty() {
+            config.set(ConfigKey::AssetRootPath, asset_root.to_string());
+        }
+        init(config)
+    });
+}
+
 /// Create a WebGPU surface from a macOS NSWindow handle.
 ///
 /// SAFETY:
@@ -3833,6 +3854,172 @@ pub extern "C" fn processing_particles_draw(graphics_id: u64, particles_id: u64,
     });
 }
 
+fn topology_from_u32(topology: u32) -> Result<geometry::Topology, ProcessingError> {
+    match topology {
+        0 => Ok(geometry::Topology::PointList),
+        1 => Ok(geometry::Topology::LineList),
+        2 => Ok(geometry::Topology::LineStrip),
+        3 => Ok(geometry::Topology::TriangleList),
+        4 => Ok(geometry::Topology::TriangleStrip),
+        _ => Err(ProcessingError::InvalidArgument(format!(
+            "unknown topology {topology}"
+        ))),
+    }
+}
+
+/// Draw `particles` with an explicit topology. `geometry_id` 0 draws raw
+/// vertices with the given topology instead of instanced geometry.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_draw_topology(
+    graphics_id: u64,
+    particles_id: u64,
+    geometry_id: u64,
+    topology: u32,
+) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    error::check(|| {
+        graphics_record_command(
+            graphics_entity,
+            DrawCommand::Particles {
+                particles: Entity::from_bits(particles_id),
+                geometry: (geometry_id != 0).then(|| Entity::from_bits(geometry_id)),
+                topology: topology_from_u32(topology)?,
+            },
+        )
+    });
+}
+
+/// Grids are plain structs, not ECS entities, so the FFI keeps them in a
+/// handle table.
+static GRIDS: std::sync::Mutex<(u64, Option<std::collections::HashMap<u64, Grid>>)> =
+    std::sync::Mutex::new((0, None));
+
+fn grid_get(handle: u64) -> Result<Grid, ProcessingError> {
+    GRIDS
+        .lock()
+        .unwrap()
+        .1
+        .as_ref()
+        .and_then(|m| m.get(&handle).copied())
+        .ok_or_else(|| ProcessingError::InvalidArgument(format!("unknown grid handle {handle}")))
+}
+
+/// Create a spatial hash grid sized to `particles_id`'s capacity. Returns a
+/// grid handle (not an entity id), or 0 on error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_grid_create(
+    particles_id: u64,
+    min_x: f32,
+    min_y: f32,
+    min_z: f32,
+    cell_size: f32,
+    dims_x: u32,
+    dims_y: u32,
+    dims_z: u32,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        let capacity = particles_capacity(Entity::from_bits(particles_id))?;
+        let grid = grid_create(
+            GridParams {
+                min: [min_x, min_y, min_z],
+                cell_size,
+                dims: [dims_x, dims_y, dims_z],
+            },
+            capacity,
+        )?;
+        let mut guard = GRIDS.lock().unwrap();
+        guard.0 += 1;
+        let handle = guard.0;
+        guard.1.get_or_insert_with(Default::default).insert(handle, grid);
+        Ok(handle)
+    })
+    .unwrap_or(0)
+}
+
+/// Rebuild the grid's cell index from a position buffer.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_grid_build(grid_handle: u64, position_buf_id: u64) {
+    error::clear_error();
+    error::check(|| grid_build(&grid_get(grid_handle)?, Entity::from_bits(position_buf_id)));
+}
+
+/// Bind the grid's offsets/sorted buffers and domain uniforms onto `compute`.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_grid_bind(grid_handle: u64, compute_id: u64) {
+    error::clear_error();
+    error::check(|| grid_bind(&grid_get(grid_handle)?, Entity::from_bits(compute_id)));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_grid_destroy(grid_handle: u64) {
+    error::clear_error();
+    error::check(|| {
+        let grid = GRIDS
+            .lock()
+            .unwrap()
+            .1
+            .as_mut()
+            .and_then(|m| m.remove(&grid_handle))
+            .ok_or_else(|| {
+                ProcessingError::InvalidArgument(format!("unknown grid handle {grid_handle}"))
+            })?;
+        buffer_destroy(grid.offsets)?;
+        buffer_destroy(grid.cursor)?;
+        buffer_destroy(grid.sorted)
+    });
+}
+
+/// Create a dynamic-topology primitives target over `particles_id`.
+/// `topology` must be 0 (points), 1 (lines), or 3 (triangles); capacity is
+/// counted in primitives. Returns the target entity id, or 0 on error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_primitives_create(
+    particles_id: u64,
+    topology: u32,
+    capacity_prims: u32,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        particles_primitives_create(
+            Entity::from_bits(particles_id),
+            topology_from_u32(topology)?,
+            capacity_prims,
+        )
+    })
+    .map(|e| e.to_bits())
+    .unwrap_or(0)
+}
+
+/// Apply `compute` over the target's source field with the target's buffers
+/// bound under the `processing::prims` reserved names.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_primitives_apply(target_id: u64, compute_id: u64) {
+    error::clear_error();
+    error::check(|| {
+        particles_primitives_apply(Entity::from_bits(target_id), Entity::from_bits(compute_id))
+    });
+}
+
+/// The internal particle field holding the target's expanded vertices (what
+/// gets drawn), or 0 on error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_primitives_field(target_id: u64) -> u64 {
+    error::clear_error();
+    error::check(|| particles_primitives_field(Entity::from_bits(target_id)))
+        .map(|e| e.to_bits())
+        .unwrap_or(0)
+}
+
+/// Primitives the kernels attempted to add this frame, including any dropped
+/// for capacity. Reads a small stat back from the GPU.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_primitives_attempted(target_id: u64) -> u32 {
+    error::clear_error();
+    error::check(|| particles_primitives_attempted(Entity::from_bits(target_id))).unwrap_or(0)
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_fill_buffer(graphics_id: u64, buffer_id: u64) {
     error::clear_error();
@@ -4043,7 +4230,12 @@ pub extern "C" fn processing_input_scroll(surface_id: u64, x: f32, y: f32) {
 pub extern "C" fn processing_input_key(surface_id: u64, key_code: u32, pressed: bool) {
     error::clear_error();
     error::check(|| {
-        let kc = key_code_from_u32(key_code)?;
+        // Silently skip keys with no mapping (media keys, GLFW_KEY_UNKNOWN):
+        // matches the Rust GLFW runner's `if let Some(kc) = glfw_key_to_bevy`.
+        // An input callback must never take down the render loop.
+        let Ok(kc) = key_code_from_u32(key_code) else {
+            return Ok(());
+        };
         input_set_key(Entity::from_bits(surface_id), kc, pressed)
     });
 }
@@ -4052,7 +4244,14 @@ pub extern "C" fn processing_input_key(surface_id: u64, key_code: u32, pressed:
 pub extern "C" fn processing_input_char(surface_id: u64, key_code: u32, codepoint: u32) {
     error::clear_error();
     error::check(|| {
-        let kc = key_code_from_u32(key_code)?;
+        // 0 = no associated key: char events arrive separately from key
+        // events on GLFW. Matches the Rust GLFW runner, which sends
+        // KeyCode::Unidentified for WindowEvent::Char.
+        let kc = if key_code == 0 {
+            KeyCode::Unidentified(bevy::input::keyboard::NativeKeyCode::Unidentified)
+        } else {
+            key_code_from_u32(key_code)?
+        };
         let ch = char::from_u32(codepoint).ok_or_else(|| {
             ProcessingError::InvalidArgument(format!("invalid codepoint: {codepoint}"))
         })?;
diff --git a/crates/processing_render/src/particles/kernels/flock_naive.wgsl b/crates/processing_render/src/particles/kernels/flock_naive.wgsl
new file mode 100644
index 00000000..af196d1c
--- /dev/null
+++ b/crates/processing_render/src/particles/kernels/flock_naive.wgsl
@@ -0,0 +1,124 @@
+struct Params {
+    sep_distance: f32,
+    neighbor_distance: f32,
+    weight_separation: f32,
+    weight_alignment: f32,
+    weight_cohesion: f32,
+    max_speed: f32,
+    max_force: f32,
+    min_speed: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+const TILE: u32 = 64u;
+var<workgroup> s_pos: array<vec3<f32>, 64>;
+var<workgroup> s_vel: array<vec3<f32>, 64>;
+
+fn limit_mag(v: vec3<f32>, m: f32) -> vec3<f32> {
+    let len2 = dot(v, v);
+    if len2 > m * m { return v * (m * inverseSqrt(len2)); }
+    return v;
+}
+
+fn steer_toward(desired: vec3<f32>, vel: vec3<f32>, max_speed: f32, max_force: f32) -> vec3<f32> {
+    let m2 = dot(desired, desired);
+    if m2 < 0.00000001 { return vec3<f32>(0.0); }
+    return limit_mag(desired * (max_speed * inverseSqrt(m2)) - vel, max_force);
+}
+
+@compute @workgroup_size(64)
+fn main(
+    @builtin(global_invocation_id) gid: vec3<u32>,
+    @builtin(local_invocation_id) lid: vec3<u32>,
+) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    let alive = i < count;
+
+    let sep_d2 = params.sep_distance * params.sep_distance;
+    let neighbor_d2 = params.neighbor_distance * params.neighbor_distance;
+
+    var pos = vec3<f32>(0.0);
+    var vel = vec3<f32>(0.0);
+    if alive {
+        let pi = i * 3u;
+        pos = vec3<f32>(position[pi], position[pi + 1u], position[pi + 2u]);
+        vel = vec3<f32>(velocity[pi], velocity[pi + 1u], velocity[pi + 2u]);
+    }
+
+    var sep_steer = vec3<f32>(0.0);
+    var sep_count = 0u;
+    var ali_sum = vec3<f32>(0.0);
+    var coh_sum = vec3<f32>(0.0);
+    var flock_count = 0u;
+
+    let num_tiles = (count + TILE - 1u) / TILE;
+
+    for (var t = 0u; t < num_tiles; t++) {
+        let j = t * TILE + lid.x;
+        if j < count {
+            let pj = j * 3u;
+            s_pos[lid.x] = vec3<f32>(position[pj], position[pj + 1u], position[pj + 2u]);
+            s_vel[lid.x] = vec3<f32>(velocity[pj], velocity[pj + 1u], velocity[pj + 2u]);
+        }
+        workgroupBarrier();
+
+        if alive {
+            let tile_end = min(TILE, count - t * TILE);
+            for (var k = 0u; k < tile_end; k++) {
+                let global_j = t * TILE + k;
+                if global_j == i { continue; }
+
+                let diff = pos - s_pos[k];
+                let d2 = dot(diff, diff);
+
+                if d2 > 0.000001 && d2 < neighbor_d2 {
+                    if d2 < sep_d2 {
+                        sep_steer += diff / d2;
+                        sep_count += 1u;
+                    }
+                    ali_sum += s_vel[k];
+                    coh_sum += diff;
+                    flock_count += 1u;
+                }
+            }
+        }
+        workgroupBarrier();
+    }
+
+    if !alive { return; }
+
+    var force = vec3<f32>(0.0);
+    if sep_count > 0u {
+        force += steer_toward(sep_steer / f32(sep_count), vel,
+                              params.max_speed, params.max_force) * params.weight_separation;
+    }
+    if flock_count > 0u {
+        force += steer_toward(ali_sum / f32(flock_count), vel,
+                              params.max_speed, params.max_force) * params.weight_alignment;
+        force += steer_toward(-coh_sum / f32(flock_count), vel,
+                              params.max_speed, params.max_force) * params.weight_cohesion;
+    }
+
+    var new_vel = vel + force;
+    let speed2 = dot(new_vel, new_vel);
+    let max_speed_sq = params.max_speed * params.max_speed;
+    if speed2 > max_speed_sq {
+        new_vel = new_vel * (params.max_speed * inverseSqrt(speed2));
+    } else if params.min_speed > 0.0 {
+        let min_speed_sq = params.min_speed * params.min_speed;
+        if speed2 < min_speed_sq && speed2 > 0.0 {
+            new_vel = new_vel * sqrt(min_speed_sq / speed2);
+        }
+    }
+
+    // Steering only: position integration belongs to the INTEGRATE kernel,
+    // matching the grid flock's convention.
+    let pi = i * 3u;
+    velocity[pi]      = new_vel.x;
+    velocity[pi + 1u] = new_vel.y;
+    velocity[pi + 2u] = new_vel.z;
+}

From bbb935d4d33fe2fb89d893ea86a9f83c2d803cb2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 18 Aug 2026 16:30:31 -0700
Subject: [PATCH 13/14] Fixes.

---
 Cargo.lock                                    | 2660 ++++-------------
 crates/processing_ffi/Cargo.toml              |    4 +-
 crates/processing_ffi/src/lib.rs              |   54 +-
 crates/processing_ffi/src/video.rs            |  430 +++
 crates/processing_render/src/graphics.rs      |  439 ++-
 crates/processing_render/src/lib.rs           |   71 +
 .../processing_render/src/material/custom.rs  |   72 +-
 .../src/particles/kernels/mod.rs              |   23 +-
 crates/processing_video/src/lib.rs            |    4 +-
 crates/processing_video/src/record.rs         |  464 ++-
 crates/processing_video/tests/record.rs       |  117 +
 11 files changed, 2189 insertions(+), 2149 deletions(-)
 create mode 100644 crates/processing_ffi/src/video.rs

diff --git a/Cargo.lock b/Cargo.lock
index 67321bc5..9c471d42 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -255,7 +255,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -266,7 +266,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -518,33 +518,11 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
-[[package]]
-name = "bevy"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bfadbebfc6599aa59289b754ac30023959854304f3d393da2cf62bb3cd5df8f"
-dependencies = [
- "bevy_internal 0.19.1",
-]
-
 [[package]]
 name = "bevy"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_internal 0.20.0-dev",
-]
-
-[[package]]
-name = "bevy_a11y"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c02cd43f914ef7a0f5b16f8a3d88c378c07c92f1a8c32ac5ac4d4f73e55f9e2"
-dependencies = [
- "accesskit",
- "bevy_app 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_reflect 0.19.1",
+ "bevy_internal",
 ]
 
 [[package]]
@@ -552,19 +530,10 @@ name = "bevy_a11y"
 version = "0.20.0-dev"
 dependencies = [
  "accesskit",
- "bevy_app 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
-]
-
-[[package]]
-name = "bevy_android"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae5ea5245a845cefa8efb5ff7c2a8a36cdebfb99596068780f340f0b5aba6689"
-dependencies = [
- "android-activity",
+ "bevy_app",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_reflect",
 ]
 
 [[package]]
@@ -579,18 +548,18 @@ name = "bevy_animation"
 version = "0.20.0-dev"
 dependencies = [
  "bevy_animation_macros",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_utils",
  "blake3",
  "derive_more",
  "downcast-rs 2.0.2",
@@ -609,135 +578,48 @@ dependencies = [
 name = "bevy_animation_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_anti_alias"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dde973fc942cb596b03cae0dbece0a4d9dc2d2790bbc9852aa415affc1210d3a"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_math 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_utils 0.19.1",
- "tracing",
-]
-
 [[package]]
 name = "bevy_anti_alias"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_diagnostic",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_math",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_utils",
  "tracing",
 ]
 
-[[package]]
-name = "bevy_app"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd2aa472d43b4d081ef41d26300d17bd22cba6d68df2a223eb358782fa40bc6"
-dependencies = [
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_utils 0.19.1",
- "console_error_panic_hook",
- "ctrlc",
- "downcast-rs 2.0.2",
- "log",
- "thiserror 2.0.20",
- "variadics_please 1.1.0",
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "bevy_app"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_tasks",
+ "bevy_utils",
  "console_error_panic_hook",
  "ctrlc",
  "downcast-rs 2.0.2",
  "log",
  "thiserror 2.0.20",
- "variadics_please 2.0.0",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "bevy_asset"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1624eddbf2293441b2158506aba75e523432b898d9da26eb6ed3e20af4c7fd38"
-dependencies = [
- "async-broadcast",
- "async-channel",
- "async-fs",
- "async-io",
- "async-lock",
- "atomicow",
- "bevy_android 0.19.1",
- "bevy_app 0.19.1",
- "bevy_asset_macros 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_utils 0.19.1",
- "bitflags 2.13.1",
- "blake3",
- "crossbeam-channel",
- "derive_more",
- "disqualified",
- "downcast-rs 2.0.2",
- "either",
- "futures-io",
- "futures-lite",
- "futures-util",
- "js-sys",
- "ron",
- "serde",
- "stackfuture",
- "thiserror 2.0.20",
- "tracing",
- "uuid",
+ "variadics_please",
  "wasm-bindgen",
- "wasm-bindgen-futures",
  "web-sys",
 ]
 
@@ -751,15 +633,15 @@ dependencies = [
  "async-io",
  "async-lock",
  "atomicow",
- "bevy_android 0.20.0-dev",
- "bevy_app 0.20.0-dev",
- "bevy_asset_macros 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_android",
+ "bevy_app",
+ "bevy_asset_macros",
+ "bevy_diagnostic",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_tasks",
+ "bevy_utils",
  "bitflags 2.13.1",
  "blake3",
  "crossbeam-channel",
@@ -783,23 +665,11 @@ dependencies = [
  "web-sys",
 ]
 
-[[package]]
-name = "bevy_asset_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "735611c80e926e960d279cba2a6f6ab27a61291752ec3b26e76bf9a0957e11e1"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "bevy_asset_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -809,58 +679,32 @@ dependencies = [
 name = "bevy_audio"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_ecs",
+ "bevy_math",
+ "bevy_reflect",
+ "bevy_transform",
  "rodio",
  "tracing",
 ]
 
-[[package]]
-name = "bevy_camera"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96de20d0babfb51e3907eb4eb56f1e36096a6f8c77acd997f5de611df4ee067d"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bevy_window 0.19.1",
- "derive_more",
- "downcast-rs 2.0.2",
- "serde",
- "smallvec",
- "thiserror 2.0.20",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_camera"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_reflect",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
  "derive_more",
  "downcast-rs 2.0.2",
  "serde",
@@ -873,68 +717,37 @@ dependencies = [
 name = "bevy_camera_controller"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_window 0.20.0-dev",
-]
-
-[[package]]
-name = "bevy_clipboard"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a9792c7f2e8b5b71b9572a6d98fca4ee88ed186c8a02e164540c461ae3a92e"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_log 0.19.1",
- "bevy_platform 0.19.1",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
+ "bevy_app",
+ "bevy_camera",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_log",
+ "bevy_math",
+ "bevy_picking",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_window",
 ]
 
 [[package]]
 name = "bevy_clipboard"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_log",
+ "bevy_platform",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
 ]
 
-[[package]]
-name = "bevy_color"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e5370beae13bea2db64744f370bb33566aa770dff91c2beae245ce82217fbbc"
-dependencies = [
- "bevy_math 0.19.1",
- "bevy_reflect 0.19.1",
- "bytemuck",
- "derive_more",
- "encase",
- "serde",
- "thiserror 2.0.20",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_color"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_math 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
+ "bevy_math",
+ "bevy_reflect",
  "bytemuck",
  "derive_more",
  "encase",
@@ -943,57 +756,28 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_core_pipeline"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2564f1ba766532e8eeb20059133ff6703e8dd5c3864b92378d0d1c541096ef12"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_light 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bevy_window 0.19.1",
- "bitflags 2.13.1",
- "indexmap",
- "nonmax",
-]
-
 [[package]]
 name = "bevy_core_pipeline"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_light 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_diagnostic",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_light",
+ "bevy_log",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
  "bitflags 2.13.1",
  "indexmap",
  "nonmax",
@@ -1005,7 +789,7 @@ version = "0.1.0"
 source = "git+https://github.com/tychedelia/bevy_cuda#f1e63bb2811eddfb6ed13ff9920f7ae2be091da1"
 dependencies = [
  "ash",
- "bevy 0.20.0-dev",
+ "bevy",
  "cudarc",
  "thiserror 2.0.20",
  "wgpu 29.0.4",
@@ -1013,167 +797,79 @@ dependencies = [
  "windows 0.58.0",
 ]
 
-[[package]]
-name = "bevy_derive"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d2a03321f3bd8016a041b3ae6afe83e636b3540fbc61d571bf069a21fda3231"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "bevy_derive"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_dev_tools"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee5887919325facb6142d98de3e3d156c1b86c2375ac569e2e3547601ab05eaf"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_input 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_pbr 0.19.1",
- "bevy_picking 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_state 0.19.1",
- "bevy_text 0.19.1",
- "bevy_time 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_ui 0.19.1",
- "bevy_ui_render 0.19.1",
- "bevy_window 0.19.1",
- "tracing",
-]
-
 [[package]]
 name = "bevy_dev_tools"
 version = "0.20.0-dev"
 dependencies = [
  "bevy_animation",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
  "bevy_audio",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_light 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_pbr 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_sprite 0.20.0-dev",
- "bevy_state 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_ui 0.20.0-dev",
- "bevy_ui_render 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_diagnostic",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_input",
+ "bevy_light",
+ "bevy_log",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_pbr",
+ "bevy_picking",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_sprite",
+ "bevy_state",
+ "bevy_text",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_ui",
+ "bevy_ui_render",
+ "bevy_window",
  "bevy_world_serialization",
  "tracing",
 ]
 
-[[package]]
-name = "bevy_diagnostic"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07a3a736f15486650c4c6866798a78d625c7063c991a3cc7b13f1577d89c82ae"
-dependencies = [
- "atomic-waker",
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_time 0.19.1",
- "const-fnv1a-hash",
- "log",
- "serde",
-]
-
 [[package]]
 name = "bevy_diagnostic"
 version = "0.20.0-dev"
 dependencies = [
  "atomic-waker",
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_time 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_tasks",
+ "bevy_time",
  "const-fnv1a-hash",
  "log",
  "serde",
  "sysinfo",
 ]
 
-[[package]]
-name = "bevy_ecs"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a350b2e4c2e47f7903d688affb8a723b31bca63af9789f1da88703f1ba04e354"
-dependencies = [
- "arrayvec",
- "bevy_ecs_macros 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_ptr 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_utils 0.19.1",
- "bitflags 2.13.1",
- "bumpalo",
- "concurrent-queue",
- "derive_more",
- "fixedbitset",
- "indexmap",
- "log",
- "nonmax",
- "serde",
- "slotmap",
- "smallvec",
- "thiserror 2.0.20",
- "variadics_please 1.1.0",
-]
-
 [[package]]
 name = "bevy_ecs"
 version = "0.20.0-dev"
 dependencies = [
  "arrayvec",
- "bevy_ecs_macros 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_ptr 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_ecs_macros",
+ "bevy_platform",
+ "bevy_ptr",
+ "bevy_reflect",
+ "bevy_tasks",
+ "bevy_utils",
  "bitflags 2.13.1",
  "bumpalo",
  "concurrent-queue",
@@ -1186,39 +882,14 @@ dependencies = [
  "slotmap",
  "smallvec",
  "thiserror 2.0.20",
- "variadics_please 2.0.0",
-]
-
-[[package]]
-name = "bevy_ecs_macro_logic"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76a10fef45a3e7dad717ba03e8b5f7ecdf3b3fd1cd1c5e425793525938e90d5f"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
+ "variadics_please",
 ]
 
 [[package]]
 name = "bevy_ecs_macro_logic"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "bevy_ecs_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3916d712264b6f3ec9c964ba10719450ea371e537e202a2ffcfa9f6a5e68169d"
-dependencies = [
- "bevy_ecs_macro_logic 0.19.1",
- "bevy_macro_utils 0.19.1",
+ "bevy_macro_utils",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -1228,90 +899,48 @@ dependencies = [
 name = "bevy_ecs_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_ecs_macro_logic 0.20.0-dev",
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_ecs_macro_logic",
+ "bevy_macro_utils",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_encase_derive"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be03820f64f2279ae9d826c882e4ef764516ff75ab7bdc39bb40801891533b89"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "encase_derive_impl",
-]
-
 [[package]]
 name = "bevy_encase_derive"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "encase_derive_impl",
 ]
 
-[[package]]
-name = "bevy_feathers"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2bb6cfa726defd90add3eb71dc8b1ab32ca441f2531130679bfa880af2fb1f1"
-dependencies = [
- "accesskit",
- "bevy_a11y 0.19.1",
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_input 0.19.1",
- "bevy_input_focus 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_picking 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_scene 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_text 0.19.1",
- "bevy_ui 0.19.1",
- "bevy_ui_render 0.19.1",
- "bevy_ui_widgets 0.19.1",
- "bevy_window 0.19.1",
- "smol_str",
-]
-
 [[package]]
 name = "bevy_feathers"
 version = "0.20.0-dev"
 dependencies = [
  "accesskit",
- "bevy_a11y 0.20.0-dev",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_input_focus 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_scene 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_ui 0.20.0-dev",
- "bevy_ui_render 0.20.0-dev",
- "bevy_ui_widgets 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_a11y",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_input_focus",
+ "bevy_log",
+ "bevy_math",
+ "bevy_picking",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_scene",
+ "bevy_shader",
+ "bevy_text",
+ "bevy_ui",
+ "bevy_ui_render",
+ "bevy_ui_widgets",
+ "bevy_window",
  "smol_str",
 ]
 
@@ -1319,130 +948,69 @@ dependencies = [
 name = "bevy_gilrs"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_time 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_platform",
+ "bevy_time",
  "gilrs",
  "thiserror 2.0.20",
  "tracing",
 ]
 
-[[package]]
-name = "bevy_gizmos"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ac5bcad0b8d141ef64f4a89643f74f11827ea6ef48073192b39d69156ed1b92"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_gizmos_macros 0.19.1",
- "bevy_input 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_time 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bevy_window 0.19.1",
-]
-
 [[package]]
 name = "bevy_gizmos"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_gizmos_macros 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "bevy_window 0.20.0-dev",
-]
-
-[[package]]
-name = "bevy_gizmos_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b37bbaa6241480b119da406fc261c9cf85d435addad880ae564c9b0f54a89a28"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "quote",
- "syn 2.0.119",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_ecs",
+ "bevy_gizmos_macros",
+ "bevy_input",
+ "bevy_log",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_reflect",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
 ]
 
 [[package]]
 name = "bevy_gizmos_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_gizmos_render"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ea2b6266d210bca0aa3bcba7e17204e437b4e86cecd4021ab7dcd32da576a02"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_gizmos 0.19.1",
- "bevy_image 0.19.1",
- "bevy_log 0.19.1",
- "bevy_material 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bytemuck",
- "tracing",
-]
-
 [[package]]
 name = "bevy_gizmos_render"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_gizmos 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_material 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_pbr 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_sprite_render 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_ecs",
+ "bevy_gizmos",
+ "bevy_image",
+ "bevy_log",
+ "bevy_material",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_pbr",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_sprite_render",
+ "bevy_transform",
+ "bevy_utils",
  "bytemuck",
  "tracing",
 ]
@@ -1454,20 +1022,20 @@ dependencies = [
  "async-lock",
  "base64",
  "bevy_animation",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_light 0.20.0-dev",
- "bevy_material 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_light",
+ "bevy_material",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_tasks",
+ "bevy_transform",
  "bevy_world_serialization",
  "fixedbitset",
  "gltf",
@@ -1481,49 +1049,22 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_image"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca63218585b83f98831214431449e9344b363349dd5cab98dae0b8129f0a0e2f"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_color 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_utils 0.19.1",
- "bitflags 2.13.1",
- "bytemuck",
- "futures-lite",
- "guillotiere 0.6.2",
- "half",
- "image",
- "rectangle-pack",
- "serde",
- "thiserror 2.0.20",
- "tracing",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_image"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_color",
+ "bevy_ecs",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_utils",
  "bitflags 2.13.1",
  "bytemuck",
  "futures-lite",
- "guillotiere 0.7.0",
+ "guillotiere",
  "half",
  "image",
  "ktx2",
@@ -1535,234 +1076,117 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_input"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b22e8b1119ff5c0b551cc11b672d25732c4e3eda72aceabc380595bd0e7bbe88"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "derive_more",
- "log",
- "smol_str",
- "thiserror 2.0.20",
-]
-
 [[package]]
 name = "bevy_input"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
  "derive_more",
  "log",
  "smol_str",
  "thiserror 2.0.20",
 ]
 
-[[package]]
-name = "bevy_input_focus"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4d5573eb503387f73d12acde3010d49c808c790d34691e2fb410fc54b8c72b9"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_input 0.19.1",
- "bevy_math 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_window 0.19.1",
- "log",
- "thiserror 2.0.20",
-]
-
 [[package]]
 name = "bevy_input_focus"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_app",
+ "bevy_camera",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_math",
+ "bevy_picking",
+ "bevy_reflect",
+ "bevy_window",
  "log",
  "thiserror 2.0.20",
 ]
 
-[[package]]
-name = "bevy_internal"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ba99ca2e501f14f4af3322d66ae41b5c5b6ebd3aac4d00cda47dea4c00290ae"
-dependencies = [
- "bevy_a11y 0.19.1",
- "bevy_android 0.19.1",
- "bevy_anti_alias 0.19.1",
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_dev_tools 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_feathers 0.19.1",
- "bevy_gizmos 0.19.1",
- "bevy_gizmos_render 0.19.1",
- "bevy_image 0.19.1",
- "bevy_input 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_pbr 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_post_process 0.19.1",
- "bevy_ptr 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_sprite_render 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_time 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bevy_window 0.19.1",
-]
-
 [[package]]
 name = "bevy_internal"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_a11y 0.20.0-dev",
- "bevy_android 0.20.0-dev",
+ "bevy_a11y",
+ "bevy_android",
  "bevy_animation",
- "bevy_anti_alias 0.20.0-dev",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
+ "bevy_anti_alias",
+ "bevy_app",
+ "bevy_asset",
  "bevy_audio",
- "bevy_camera 0.20.0-dev",
+ "bevy_camera",
  "bevy_camera_controller",
- "bevy_clipboard 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_dev_tools 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_feathers 0.20.0-dev",
+ "bevy_clipboard",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_dev_tools",
+ "bevy_diagnostic",
+ "bevy_ecs",
+ "bevy_feathers",
  "bevy_gilrs",
- "bevy_gizmos 0.20.0-dev",
- "bevy_gizmos_render 0.20.0-dev",
+ "bevy_gizmos",
+ "bevy_gizmos_render",
  "bevy_gltf",
- "bevy_image 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_input_focus 0.20.0-dev",
- "bevy_light 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_material 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_pbr 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_post_process 0.20.0-dev",
- "bevy_ptr 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_scene 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_sprite 0.20.0-dev",
- "bevy_sprite_render 0.20.0-dev",
- "bevy_state 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_ui 0.20.0-dev",
- "bevy_ui_render 0.20.0-dev",
- "bevy_ui_widgets 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_image",
+ "bevy_input",
+ "bevy_input_focus",
+ "bevy_light",
+ "bevy_log",
+ "bevy_material",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_pbr",
+ "bevy_picking",
+ "bevy_platform",
+ "bevy_post_process",
+ "bevy_ptr",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_scene",
+ "bevy_shader",
+ "bevy_sprite",
+ "bevy_sprite_render",
+ "bevy_state",
+ "bevy_tasks",
+ "bevy_text",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_ui",
+ "bevy_ui_render",
+ "bevy_ui_widgets",
+ "bevy_utils",
+ "bevy_window",
  "bevy_winit",
  "bevy_world_serialization",
 ]
 
 [[package]]
 name = "bevy_light"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4f91fb900c2412c5cb7ff5083d428d8361a1d39b605df86eb259aff82f7ac45"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
+version = "0.20.0-dev"
+dependencies = [
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_ecs",
+ "bevy_gizmos",
+ "bevy_image",
+ "bevy_log",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_transform",
+ "bevy_utils",
  "half",
  "smallvec",
  "tracing",
- "wgpu-types 29.0.4",
-]
-
-[[package]]
-name = "bevy_light"
-version = "0.20.0-dev"
-dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_gizmos 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "half",
- "smallvec",
- "tracing",
- "wgpu-types 30.0.0",
-]
-
-[[package]]
-name = "bevy_log"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24488594832237c1e3abc823642823fa057b810c3a21e14e65bdbd15d1579d5"
-dependencies = [
- "android_log-sys",
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_utils 0.19.1",
- "tracing",
- "tracing-log",
- "tracing-oslog",
- "tracing-subscriber",
- "tracing-wasm",
+ "wgpu-types 30.0.0",
 ]
 
 [[package]]
@@ -1770,10 +1194,10 @@ name = "bevy_log"
 version = "0.20.0-dev"
 dependencies = [
  "android_log-sys",
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_utils",
  "tracing",
  "tracing-log",
  "tracing-oslog",
@@ -1781,18 +1205,6 @@ dependencies = [
  "tracing-wasm",
 ]
 
-[[package]]
-name = "bevy_macro_utils"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7164fe229422295bba15f1885048f34f4660db069aacb895208f996b0c7784fb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "toml_edit",
-]
-
 [[package]]
 name = "bevy_macro_utils"
 version = "0.20.0-dev"
@@ -1803,157 +1215,75 @@ dependencies = [
  "toml_edit",
 ]
 
-[[package]]
-name = "bevy_material"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3efcdb3ba04a57f6e05548884745684a2051e9692398915f57c5c276306b7f10"
-dependencies = [
- "bevy_asset 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_material_macros 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_utils 0.19.1",
- "encase",
- "smallvec",
- "thiserror 2.0.20",
- "tracing",
- "variadics_please 1.1.0",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_material"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_asset 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_material_macros 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_asset",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_material_macros",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_shader",
+ "bevy_utils",
  "encase",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
- "variadics_please 2.0.0",
+ "variadics_please",
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_material_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "854f95c8f3374ef6242790de50b5cb8f5a601c698772d1447bf856067b53ee64"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "bevy_material_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_math"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98ead494dcfaa9b4594eed7f09a27d868b7cc7fc9ebd655c5643322778f4a8a2"
-dependencies = [
- "approx",
- "arrayvec",
- "bevy_reflect 0.19.1",
- "derive_more",
- "glam 0.32.1",
- "itertools 0.14.0",
- "libm",
- "rand 0.10.2",
- "rand_distr",
- "serde",
- "thiserror 2.0.20",
- "variadics_please 1.1.0",
-]
-
 [[package]]
 name = "bevy_math"
 version = "0.20.0-dev"
 dependencies = [
  "approx",
  "arrayvec",
- "bevy_reflect 0.20.0-dev",
+ "bevy_reflect",
  "derive_more",
- "glam 0.33.3",
+ "glam",
  "itertools 0.14.0",
  "libm",
  "rand 0.10.2",
  "rand_distr",
  "serde",
  "thiserror 2.0.20",
- "variadics_please 2.0.0",
-]
-
-[[package]]
-name = "bevy_mesh"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2adbf8e5a5817c345986756eb0377e18a510e1d7685ef62d6c7bafcd3bab85e"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_encase_derive 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mikktspace",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_transform 0.19.1",
- "bitflags 2.13.1",
- "bytemuck",
- "derive_more",
- "encase",
- "glam 0.32.1",
- "half",
- "hexasphere 18.0.0",
- "thiserror 2.0.20",
- "tracing",
- "wgpu-types 29.0.4",
+ "variadics_please",
 ]
 
 [[package]]
 name = "bevy_mesh"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_encase_derive 0.20.0-dev",
- "bevy_math 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_encase_derive",
+ "bevy_math",
  "bevy_mikktspace",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_transform",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
  "encase",
- "glam 0.33.3",
+ "glam",
  "half",
- "hexasphere 19.0.0",
+ "hexasphere",
  "serde",
  "thiserror 2.0.20",
  "tracing",
@@ -1970,79 +1300,37 @@ checksum = "bff34eb29ff4b8a8688bc7299f14fb6b597461ca80fec03ed7d22939ab33e48f"
 name = "bevy_naga_reflect"
 version = "0.2.0"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "naga 29.0.4",
 ]
 
-[[package]]
-name = "bevy_pbr"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "244ae7d618b51a59c913c36b0564a295cd85ea91a5e777b542bb7bdb846a23d6"
-dependencies = [
- "arrayvec",
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_light 0.19.1",
- "bevy_log 0.19.1",
- "bevy_material 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bitflags 2.13.1",
- "bytemuck",
- "derive_more",
- "fixedbitset",
- "indexmap",
- "nonmax",
- "offset-allocator",
- "smallvec",
- "static_assertions",
- "thiserror 2.0.20",
- "tracing",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_pbr"
 version = "0.20.0-dev"
 dependencies = [
  "arrayvec",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_diagnostic",
+ "bevy_ecs",
  "bevy_gltf",
- "bevy_image 0.20.0-dev",
- "bevy_light 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_material 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_image",
+ "bevy_light",
+ "bevy_log",
+ "bevy_material",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_tasks",
+ "bevy_transform",
+ "bevy_utils",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
@@ -2057,72 +1345,28 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_picking"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "235d1ea0cd7d0ff2f37592f37b4d8504c597884296058ecadcb0d206d0258ab7"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_input 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_time 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_window 0.19.1",
- "tracing",
- "uuid",
-]
-
 [[package]]
 name = "bevy_picking"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_window",
  "crossbeam-channel",
  "tracing",
  "uuid",
 ]
 
-[[package]]
-name = "bevy_platform"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd610a417e7b4a3b9602cf11264d16cbbff8eabe689c5fed8be4e84c6a2680a3"
-dependencies = [
- "critical-section",
- "foldhash 0.2.0",
- "futures-channel",
- "futures-lite",
- "hashbrown 0.16.1",
- "js-sys",
- "portable-atomic",
- "portable-atomic-util",
- "serde",
- "spin 0.10.1",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-time",
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "bevy_platform"
 version = "0.20.0-dev"
@@ -2140,110 +1384,51 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-time",
- "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "bevy_post_process"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eb9340107f7a4292b3b1d138cffb2700f31cef580f5777f2e83f4f00eae4dc1"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_utils 0.19.1",
- "smallvec",
- "thiserror 2.0.20",
- "tracing",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "bevy_post_process"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_utils",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
 ]
 
-[[package]]
-name = "bevy_ptr"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1974de4b140f102fded747229ff4a61921acec07f02f0d1dcdadfe9ce177d0ff"
-
 [[package]]
 name = "bevy_ptr"
 version = "0.20.0-dev"
 
-[[package]]
-name = "bevy_reflect"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b76c3d056da3e299b84652ccf914c487b786857225d8ffbc8fc9509441a9e6b"
-dependencies = [
- "assert_type_match",
- "bevy_platform 0.19.1",
- "bevy_ptr 0.19.1",
- "bevy_reflect_derive 0.19.1",
- "bevy_utils 0.19.1",
- "derive_more",
- "disqualified",
- "downcast-rs 2.0.2",
- "erased-serde",
- "foldhash 0.2.0",
- "glam 0.32.1",
- "indexmap",
- "inventory",
- "serde",
- "smallvec",
- "smol_str",
- "thiserror 2.0.20",
- "uuid",
- "variadics_please 1.1.0",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_reflect"
 version = "0.20.0-dev"
 dependencies = [
  "assert_type_match",
- "bevy_platform 0.20.0-dev",
- "bevy_ptr 0.20.0-dev",
- "bevy_reflect_derive 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_platform",
+ "bevy_ptr",
+ "bevy_reflect_derive",
+ "bevy_utils",
  "derive_more",
  "disqualified",
  "downcast-rs 2.0.2",
  "erased-serde",
  "foldhash 0.2.0",
- "glam 0.33.3",
+ "glam",
  "indexmap",
  "inventory",
  "petgraph 0.8.3",
@@ -2252,29 +1437,15 @@ dependencies = [
  "smol_str",
  "thiserror 2.0.20",
  "uuid",
- "variadics_please 2.0.0",
+ "variadics_please",
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_reflect_derive"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fc5f820ee52afeca6d3bb83f15c1bf61ea6196c840a761a21a8bc266a3b166e"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "indexmap",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "uuid",
-]
-
 [[package]]
 name = "bevy_reflect_derive"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "indexmap",
  "proc-macro2",
  "quote",
@@ -2282,94 +1453,40 @@ dependencies = [
  "uuid",
 ]
 
-[[package]]
-name = "bevy_render"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc86a32b2eef9859e1e7d323c6d1a9150fe77aa17c30fd05abebc12f645929dc"
-dependencies = [
- "async-channel",
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_diagnostic 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_encase_derive 0.19.1",
- "bevy_image 0.19.1",
- "bevy_log 0.19.1",
- "bevy_material 0.19.1",
- "bevy_material_macros 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render_macros 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_time 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bevy_window 0.19.1",
- "bitflags 2.13.1",
- "bytemuck",
- "derive_more",
- "downcast-rs 2.0.2",
- "encase",
- "glam 0.32.1",
- "image",
- "indexmap",
- "itertools 0.14.0",
- "js-sys",
- "naga 29.0.4",
- "nonmax",
- "offset-allocator",
- "send_wrapper",
- "smallvec",
- "thiserror 2.0.20",
- "variadics_please 1.1.0",
- "wasm-bindgen",
- "weak-table",
- "web-sys",
- "wgpu 29.0.4",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_render"
 version = "0.20.0-dev"
 dependencies = [
  "async-channel",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_diagnostic 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_encase_derive 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_material 0.20.0-dev",
- "bevy_material_macros 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render_macros 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_diagnostic",
+ "bevy_ecs",
+ "bevy_encase_derive",
+ "bevy_image",
+ "bevy_log",
+ "bevy_material",
+ "bevy_material_macros",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render_macros",
+ "bevy_shader",
+ "bevy_tasks",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
  "downcast-rs 2.0.2",
  "encase",
- "glam 0.33.3",
+ "glam",
  "image",
  "indexmap",
  "itertools 0.14.0",
@@ -2381,7 +1498,7 @@ dependencies = [
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
- "variadics_please 2.0.0",
+ "variadics_please",
  "wasm-bindgen",
  "weak-table",
  "web-sys",
@@ -2389,121 +1506,56 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_render_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6be6eba0ce9770ae4576693804d6c605f8afd9c4769787414254efcf92196a90"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "bevy_render_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_macro_utils",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_scene"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33f6f4f24cd771c6fd67286a8f264a45a644dc798a36614252db220d4fbbd63b"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_log 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_scene_macros 0.19.1",
- "bevy_utils 0.19.1",
- "smallvec",
- "thiserror 2.0.20",
- "tracing",
- "variadics_please 1.1.0",
-]
-
 [[package]]
 name = "bevy_scene"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_scene_macros 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_log",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_scene_macros",
+ "bevy_utils",
  "smallvec",
  "thiserror 2.0.20",
  "tracing",
- "variadics_please 2.0.0",
-]
-
-[[package]]
-name = "bevy_scene_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc7844c3410e228581200f73be123467c424f62fc40499c3e869b641b582748"
-dependencies = [
- "bevy_ecs_macro_logic 0.19.1",
- "bevy_macro_utils 0.19.1",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
+ "variadics_please",
 ]
 
 [[package]]
 name = "bevy_scene_macros"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_ecs_macro_logic 0.20.0-dev",
- "bevy_macro_utils 0.20.0-dev",
+ "bevy_ecs_macro_logic",
+ "bevy_macro_utils",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "bevy_shader"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50ba4fa5c5102a9ad1b0508c5bf8a6d02a22d5dc13c23ba908ee6d3d16a357cd"
-dependencies = [
- "bevy_asset 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_utils 0.19.1",
- "naga 29.0.4",
- "naga_oil 0.22.0",
- "serde",
- "thiserror 2.0.20",
- "tracing",
- "wgpu-naga-bridge 29.0.4",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_shader"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_asset 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_asset",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_utils",
  "naga 30.0.0",
- "naga_oil 0.23.0",
+ "naga_oil",
  "serde",
  "thiserror 2.0.20",
  "tracing",
@@ -2512,111 +1564,53 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_sprite"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e93e631436ff9c08613843d46521ee60f2fcb2eb5f4754eec59591ca817a2ba0"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_text 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_window 0.19.1",
- "radsort",
- "tracing",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_sprite"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_log",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_picking",
+ "bevy_reflect",
+ "bevy_text",
+ "bevy_transform",
+ "bevy_window",
  "radsort",
  "tracing",
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_sprite_render"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c0a13c775880fe8fb3e7928921b2a1b549fd92c17571e7ca5e1250e53f0e56c"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_material 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_sprite 0.19.1",
- "bevy_text 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bitflags 2.13.1",
- "bytemuck",
- "derive_more",
- "fixedbitset",
- "nonmax",
- "tracing",
-]
-
 [[package]]
 name = "bevy_sprite_render"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_material 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_sprite 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_material",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_sprite",
+ "bevy_text",
+ "bevy_transform",
+ "bevy_utils",
  "bitflags 2.13.1",
  "bytemuck",
  "derive_more",
@@ -2627,71 +1621,27 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "bevy_state"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f69ce6a0066eb4626165e2f8c85d3cf4808cfe4cb2027df8840d5cbfe8a3428d"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_state_macros 0.19.1",
- "bevy_utils 0.19.1",
- "log",
- "variadics_please 1.1.0",
-]
-
 [[package]]
 name = "bevy_state"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_state_macros 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_state_macros",
+ "bevy_utils",
  "log",
- "variadics_please 2.0.0",
+ "variadics_please",
 ]
 
 [[package]]
 name = "bevy_state_macros"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a36dd49049023a0abbd0bd1e2b99580ed83a18c5351c64caba4c06e3b584cf9c"
-dependencies = [
- "bevy_macro_utils 0.19.1",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "bevy_state_macros"
-version = "0.20.0-dev"
-dependencies = [
- "bevy_macro_utils 0.20.0-dev",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "bevy_tasks"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f787d4ba7237b64b30bd2d690a8cbae1ba775e0eec326711c446654cb720e7c"
+version = "0.20.0-dev"
 dependencies = [
- "async-executor",
- "async-task",
- "atomic-waker",
- "bevy_platform 0.19.1",
- "crossbeam-queue",
- "derive_more",
- "futures-lite",
- "heapless",
- "web-task",
+ "bevy_macro_utils",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -2702,7 +1652,7 @@ dependencies = [
  "async-executor",
  "async-task",
  "atomic-waker",
- "bevy_platform 0.20.0-dev",
+ "bevy_platform",
  "concurrent-queue",
  "crossbeam-queue",
  "derive_more",
@@ -2711,51 +1661,22 @@ dependencies = [
  "web-task",
 ]
 
-[[package]]
-name = "bevy_text"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0b275f50fb01b1e2d411326a7750ecc2fe629c48b89997cf2a3c93fe786e076"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_clipboard 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_utils 0.19.1",
- "parley 0.9.0",
- "serde",
- "smallvec",
- "smol_str",
- "swash",
- "sys-locale",
- "thiserror 2.0.20",
- "tracing",
- "wgpu-types 29.0.4",
-]
-
 [[package]]
 name = "bevy_text"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_clipboard 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_clipboard",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_log",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_utils",
  "parley 0.11.0",
  "serde",
  "smallvec",
@@ -2767,130 +1688,60 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
-[[package]]
-name = "bevy_time"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6896d83d7ed32a2f89da127b7aeddf01eb702e603897cf5ddac231480a1870e"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "crossbeam-channel",
- "log",
- "serde",
-]
-
 [[package]]
 name = "bevy_time"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_reflect",
  "crossbeam-channel",
  "log",
  "serde",
 ]
 
-[[package]]
-name = "bevy_transform"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d94cc6065320ebeb58ae88a0863a4c4c2a642c6db698e283eb50be01a834ca5a"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_math 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_tasks 0.19.1",
- "bevy_utils 0.19.1",
- "derive_more",
- "serde",
- "thiserror 2.0.20",
-]
-
 [[package]]
 name = "bevy_transform"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_math",
+ "bevy_reflect",
+ "bevy_tasks",
+ "bevy_utils",
  "derive_more",
  "serde",
  "thiserror 2.0.20",
 ]
 
-[[package]]
-name = "bevy_ui"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a2f97c39dadfef97dbe295fc1ce212825bb9fda2becc8f558d1d7e7d7dbbedf"
-dependencies = [
- "accesskit",
- "bevy_a11y 0.19.1",
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_input 0.19.1",
- "bevy_input_focus 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_picking 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_sprite 0.19.1",
- "bevy_text 0.19.1",
- "bevy_time 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_utils 0.19.1",
- "bevy_window 0.19.1",
- "derive_more",
- "parley 0.9.0",
- "smallvec",
- "swash",
- "taffy",
- "thiserror 2.0.20",
- "tracing",
- "uuid",
-]
-
 [[package]]
 name = "bevy_ui"
 version = "0.20.0-dev"
 dependencies = [
  "accesskit",
- "bevy_a11y 0.20.0-dev",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_input_focus 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_sprite 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_a11y",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_input",
+ "bevy_input_focus",
+ "bevy_log",
+ "bevy_math",
+ "bevy_picking",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_sprite",
+ "bevy_text",
+ "bevy_time",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
  "derive_more",
  "parley 0.11.0",
  "smallvec",
@@ -2901,170 +1752,83 @@ dependencies = [
  "uuid",
 ]
 
-[[package]]
-name = "bevy_ui_render"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30a36be1c251417421ee070ecd1a393f0036631f7495564a8c9d4abb6042dc40"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_asset 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_color 0.19.1",
- "bevy_core_pipeline 0.19.1",
- "bevy_derive 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_image 0.19.1",
- "bevy_input_focus 0.19.1",
- "bevy_math 0.19.1",
- "bevy_mesh 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_render 0.19.1",
- "bevy_shader 0.19.1",
- "bevy_sprite 0.19.1",
- "bevy_sprite_render 0.19.1",
- "bevy_text 0.19.1",
- "bevy_transform 0.19.1",
- "bevy_ui 0.19.1",
- "bevy_utils 0.19.1",
- "bytemuck",
- "derive_more",
- "indexmap",
- "tracing",
-]
-
 [[package]]
 name = "bevy_ui_render"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_color 0.20.0-dev",
- "bevy_core_pipeline 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_input_focus 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_mesh 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_render 0.20.0-dev",
- "bevy_shader 0.20.0-dev",
- "bevy_sprite 0.20.0-dev",
- "bevy_sprite_render 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_ui 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_color",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_input_focus",
+ "bevy_math",
+ "bevy_mesh",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_shader",
+ "bevy_sprite",
+ "bevy_sprite_render",
+ "bevy_text",
+ "bevy_transform",
+ "bevy_ui",
+ "bevy_utils",
  "bytemuck",
  "derive_more",
  "indexmap",
  "tracing",
 ]
 
-[[package]]
-name = "bevy_ui_widgets"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a71063099a056a010bdbbcc1f1daf2d50bff517d69d62e5334d4c32d7bf9e9e0"
-dependencies = [
- "accesskit",
- "bevy_a11y 0.19.1",
- "bevy_app 0.19.1",
- "bevy_camera 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_input 0.19.1",
- "bevy_input_focus 0.19.1",
- "bevy_log 0.19.1",
- "bevy_math 0.19.1",
- "bevy_picking 0.19.1",
- "bevy_reflect 0.19.1",
- "bevy_text 0.19.1",
- "bevy_ui 0.19.1",
- "bevy_window 0.19.1",
- "parley 0.9.0",
- "smol_str",
-]
-
 [[package]]
 name = "bevy_ui_widgets"
 version = "0.20.0-dev"
 dependencies = [
  "accesskit",
- "bevy_a11y 0.20.0-dev",
- "bevy_app 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_input_focus 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_picking 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_text 0.20.0-dev",
- "bevy_time 0.20.0-dev",
- "bevy_ui 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_a11y",
+ "bevy_app",
+ "bevy_camera",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_input_focus",
+ "bevy_log",
+ "bevy_math",
+ "bevy_picking",
+ "bevy_reflect",
+ "bevy_text",
+ "bevy_time",
+ "bevy_ui",
+ "bevy_window",
  "parley 0.11.0",
  "smol_str",
 ]
 
-[[package]]
-name = "bevy_utils"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de51fa7ea2e95d4c2d1278c5629285d59eec951cc60c992964c03f30910ef5a1"
-dependencies = [
- "async-channel",
- "bevy_platform 0.19.1",
- "disqualified",
- "indexmap",
- "thread_local",
-]
-
 [[package]]
 name = "bevy_utils"
 version = "0.20.0-dev"
 dependencies = [
  "async-channel",
- "bevy_platform 0.20.0-dev",
+ "bevy_platform",
  "disqualified",
  "indexmap",
  "thread_local",
 ]
 
-[[package]]
-name = "bevy_window"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38373ee93a9248c14afe41d2025f4aa5e68b004b06ae7702816b180e72b39ea3"
-dependencies = [
- "bevy_app 0.19.1",
- "bevy_ecs 0.19.1",
- "bevy_input 0.19.1",
- "bevy_math 0.19.1",
- "bevy_platform 0.19.1",
- "bevy_reflect 0.19.1",
- "log",
- "raw-window-handle",
- "serde",
-]
-
 [[package]]
 name = "bevy_window"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_input",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
  "log",
  "raw-window-handle",
  "serde",
@@ -3077,21 +1841,21 @@ dependencies = [
  "accesskit",
  "accesskit_winit",
  "approx",
- "bevy_a11y 0.20.0-dev",
- "bevy_android 0.20.0-dev",
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_image 0.20.0-dev",
- "bevy_input 0.20.0-dev",
- "bevy_input_focus 0.20.0-dev",
- "bevy_log 0.20.0-dev",
- "bevy_math 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_tasks 0.20.0-dev",
- "bevy_window 0.20.0-dev",
+ "bevy_a11y",
+ "bevy_android",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_image",
+ "bevy_input",
+ "bevy_input_focus",
+ "bevy_log",
+ "bevy_math",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_tasks",
+ "bevy_window",
  "bytemuck",
  "js-sys",
  "tracing",
@@ -3105,15 +1869,15 @@ dependencies = [
 name = "bevy_world_serialization"
 version = "0.20.0-dev"
 dependencies = [
- "bevy_app 0.20.0-dev",
- "bevy_asset 0.20.0-dev",
- "bevy_camera 0.20.0-dev",
- "bevy_derive 0.20.0-dev",
- "bevy_ecs 0.20.0-dev",
- "bevy_platform 0.20.0-dev",
- "bevy_reflect 0.20.0-dev",
- "bevy_transform 0.20.0-dev",
- "bevy_utils 0.20.0-dev",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_camera",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_platform",
+ "bevy_reflect",
+ "bevy_transform",
+ "bevy_utils",
  "derive_more",
  "ron",
  "serde",
@@ -4115,7 +2879,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4286,15 +3050,6 @@ dependencies = [
  "bytemuck",
 ]
 
-[[package]]
-name = "font-types"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b38ad915f6dadd993ced50848a8291a543bd41ca62bc10740d5e64e2ab4cfd7"
-dependencies = [
- "bytemuck",
-]
-
 [[package]]
 name = "font-types"
 version = "0.12.3"
@@ -4327,20 +3082,6 @@ dependencies = [
  "yeslogic-fontconfig-sys",
 ]
 
-[[package]]
-name = "fontique"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c20b425addb8661e97fe1d51c4d8bcec3ec29ed6ad0db983976a7521276b8f7"
-dependencies = [
- "hashbrown 0.17.1",
- "linebender_resource_handle",
- "memmap2",
- "parlance",
- "read-fonts 0.39.2",
- "smallvec",
-]
-
 [[package]]
 name = "fontique"
 version = "0.11.0"
@@ -4594,7 +3335,7 @@ dependencies = [
  "vec_map",
  "wasm-bindgen",
  "web-sys",
- "windows 0.62.2",
+ "windows 0.58.0",
 ]
 
 [[package]]
@@ -4608,19 +3349,6 @@ dependencies = [
  "xml-rs",
 ]
 
-[[package]]
-name = "glam"
-version = "0.32.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0"
-dependencies = [
- "bytemuck",
- "encase",
- "libm",
- "rand 0.10.2",
- "serde_core",
-]
-
 [[package]]
 name = "glam"
 version = "0.33.3"
@@ -4753,7 +3481,7 @@ dependencies = [
  "log",
  "presser",
  "thiserror 2.0.20",
- "windows 0.62.2",
+ "windows 0.58.0",
 ]
 
 [[package]]
@@ -4782,16 +3510,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b40ca9252762c466af32d0b1002e91e4e1bc5398f77455e55474deb466355ff5"
 
-[[package]]
-name = "guillotiere"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62d5865c036cb1393e23c50693df631d3f5d7bcca4c04fe4cc0fd592e74a782"
-dependencies = [
- "euclid",
- "svg_fmt",
-]
-
 [[package]]
 name = "guillotiere"
 version = "0.7.0"
@@ -4828,19 +3546,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "harfrust"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "551ed25397e4b444e89686602877d5cf3a7f6e3d548dcac37a8357d1e195f4df"
-dependencies = [
- "bitflags 2.13.1",
- "bytemuck",
- "core_maths",
- "read-fonts 0.39.2",
- "smallvec",
-]
-
 [[package]]
 name = "harfrust"
 version = "0.10.0"
@@ -4916,17 +3621,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
-[[package]]
-name = "hexasphere"
-version = "18.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "177ea6330876de4ef08e184f827b98acc037614a4ce409902c5b0d53a9c2e951"
-dependencies = [
- "constgebra",
- "glam 0.32.1",
- "tinyvec",
-]
-
 [[package]]
 name = "hexasphere"
 version = "19.0.0"
@@ -4934,7 +3628,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "163385eff5a0cf606ebe2c10b3a44ab02f4306e83fbd068a64f5e1d72a3049ac"
 dependencies = [
  "constgebra",
- "glam 0.33.3",
+ "glam",
  "tinyvec",
 ]
 
@@ -5854,7 +4548,6 @@ dependencies = [
  "log",
  "num-traits",
  "once_cell",
- "pp-rs",
  "rustc-hash 1.1.0",
  "serde",
  "spirv",
@@ -5902,23 +4595,6 @@ dependencies = [
  "thiserror 2.0.20",
 ]
 
-[[package]]
-name = "naga_oil"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "319f03062940ed85c03da020042618356bb8ca5263020322930883b05e30208e"
-dependencies = [
- "codespan-reporting 0.12.0",
- "data-encoding",
- "indexmap",
- "naga 29.0.4",
- "regex",
- "rustc-hash 1.1.0",
- "thiserror 2.0.20",
- "tracing",
- "unicode-ident",
-]
-
 [[package]]
 name = "naga_oil"
 version = "0.23.0"
@@ -5939,9 +4615,9 @@ dependencies = [
 [[package]]
 name = "nannou_video"
 version = "0.1.0"
-source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f713c439c03b4e4614c2ef8ff899932efd0a1c44"
+source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f7f7f10bae536d4318c7a027aaa612886b8ac286"
 dependencies = [
- "bevy 0.19.1",
+ "bevy",
  "flume",
  "gloo-events",
  "js-sys",
@@ -5957,9 +4633,9 @@ dependencies = [
 [[package]]
 name = "nannou_webcam"
 version = "0.1.0"
-source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f713c439c03b4e4614c2ef8ff899932efd0a1c44"
+source = "git+https://github.com/nannou-org/nannou?branch=bevy-refactor#f7f7f10bae536d4318c7a027aaa612886b8ac286"
 dependencies = [
- "bevy 0.19.1",
+ "bevy",
  "console_error_panic_hook",
  "flume",
  "getrandom 0.3.4",
@@ -6203,7 +4879,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -6851,24 +5527,6 @@ dependencies = [
  "swash",
 ]
 
-[[package]]
-name = "parley"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fad031076f48f0d4d85ce1aea9b94b4e715a4d636a030a123038f8f5b5e4343"
-dependencies = [
- "fontique 0.9.0",
- "harfrust 0.6.2",
- "hashbrown 0.17.1",
- "icu_normalizer",
- "icu_properties",
- "icu_segmenter",
- "linebender_resource_handle",
- "parlance",
- "parley_data 0.9.0",
- "skrifa 0.42.1",
-]
-
 [[package]]
 name = "parley"
 version = "0.11.0"
@@ -6883,19 +5541,10 @@ dependencies = [
  "icu_segmenter",
  "linebender_resource_handle",
  "parlance",
- "parley_data 0.11.0",
+ "parley_data",
  "skrifa 0.43.2",
 ]
 
-[[package]]
-name = "parley_data"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19ab9ace3fad1b9ed603ddac5b595e69931fc50263d7e04e4055015b77b02da5"
-dependencies = [
- "icu_properties",
-]
-
 [[package]]
 name = "parley_data"
 version = "0.11.0"
@@ -7125,7 +5774,7 @@ dependencies = [
 name = "processing"
 version = "0.0.8"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "js-sys",
  "processing_core",
  "processing_cuda",
@@ -7145,7 +5794,7 @@ dependencies = [
 name = "processing_core"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "raw-window-handle",
  "thiserror 2.0.20",
  "tracing",
@@ -7155,7 +5804,7 @@ dependencies = [
 name = "processing_cuda"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "bevy_cuda",
  "processing_core",
  "processing_render",
@@ -7165,17 +5814,18 @@ dependencies = [
 name = "processing_ffi"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "cbindgen",
  "half",
  "processing",
+ "processing_video",
 ]
 
 [[package]]
 name = "processing_glfw"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "glfw",
  "processing_core",
  "processing_input",
@@ -7187,7 +5837,7 @@ dependencies = [
 name = "processing_input"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "processing_core",
 ]
 
@@ -7195,7 +5845,7 @@ dependencies = [
 name = "processing_pyo3"
 version = "0.0.8"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "png",
  "processing",
  "processing_cuda",
@@ -7212,7 +5862,7 @@ dependencies = [
 name = "processing_render"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "bevy_naga_reflect",
  "crossbeam-channel",
  "fontique 0.7.0",
@@ -7239,7 +5889,7 @@ dependencies = [
 name = "processing_video"
 version = "0.0.1"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "nannou_video",
  "processing_core",
  "processing_render",
@@ -7252,7 +5902,7 @@ dependencies = [
 name = "processing_wasm"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "console_error_panic_hook",
  "getrandom 0.2.17",
  "getrandom 0.3.4",
@@ -7268,7 +5918,7 @@ dependencies = [
 name = "processing_webcam"
 version = "0.0.5"
 dependencies = [
- "bevy 0.20.0-dev",
+ "bevy",
  "nannou_webcam",
  "processing_core",
  "processing_render",
@@ -7607,16 +6257,6 @@ dependencies = [
  "font-types 0.10.1",
 ]
 
-[[package]]
-name = "read-fonts"
-version = "0.39.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4ed38b89c2c77ff968c524145ad65fb010f38af5c7a224b53b81d47ac2daa81"
-dependencies = [
- "bytemuck",
- "font-types 0.11.3",
-]
-
 [[package]]
 name = "read-fonts"
 version = "0.40.2"
@@ -7628,17 +6268,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "read-fonts"
-version = "0.41.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
-dependencies = [
- "bytemuck",
- "font-types 0.12.3",
- "once_cell",
-]
-
 [[package]]
 name = "reborrow"
 version = "0.5.5"
@@ -7790,7 +6419,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -7803,7 +6432,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8017,16 +6646,6 @@ dependencies = [
  "read-fonts 0.35.0",
 ]
 
-[[package]]
-name = "skrifa"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c34617370ae968efb7161bb2beb517d9084659aae19e24b89e3db25b46e4564"
-dependencies = [
- "bytemuck",
- "read-fonts 0.39.2",
-]
-
 [[package]]
 name = "skrifa"
 version = "0.43.2"
@@ -8037,16 +6656,6 @@ dependencies = [
  "read-fonts 0.40.2",
 ]
 
-[[package]]
-name = "skrifa"
-version = "0.44.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68"
-dependencies = [
- "bytemuck",
- "read-fonts 0.41.0",
-]
-
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -8174,19 +6783,13 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "svg_fmt"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0193cc4331cfd2f3d2011ef287590868599a2f33c3e69bc22c1a3d3acf9e02fb"
-
 [[package]]
 name = "swash"
 version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e"
 dependencies = [
- "skrifa 0.44.0",
+ "skrifa 0.37.0",
  "yazi",
  "zeno",
 ]
@@ -8275,7 +6878,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8284,7 +6887,7 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8c27177b12a6399ffc08b98f76f7c9a1f4fe9fc967c784c5a071fa8d93cf7e1"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -8692,17 +7295,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
-[[package]]
-name = "variadics_please"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41b6d82be61465f97d42bd1d15bf20f3b0a3a0905018f38f9d6f6962055b0b5c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "variadics_please"
 version = "2.0.0"
@@ -9351,7 +7943,6 @@ dependencies = [
  "js-sys",
  "log",
  "raw-window-handle",
- "serde",
  "web-sys",
 ]
 
@@ -9434,7 +8025,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -9626,15 +8217,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.60.2"
diff --git a/crates/processing_ffi/Cargo.toml b/crates/processing_ffi/Cargo.toml
index 16d41364..8efc0f9d 100644
--- a/crates/processing_ffi/Cargo.toml
+++ b/crates/processing_ffi/Cargo.toml
@@ -11,14 +11,16 @@ name = "processing"
 crate-type = ["cdylib", "staticlib"]
 
 [features]
-default = []
+default = ["video"]
 wayland = ["processing/wayland"]
 x11 = ["processing/x11"]
 webcam = ["processing/webcam"]
 cuda = ["processing/cuda"]
+video = ["processing/video", "dep:processing_video"]
 
 [dependencies]
 processing = { workspace = true }
+processing_video = { workspace = true, optional = true }
 bevy = { workspace = true }
 half = "2.7"
 
diff --git a/crates/processing_ffi/src/lib.rs b/crates/processing_ffi/src/lib.rs
index 46c0a480..0596a15c 100644
--- a/crates/processing_ffi/src/lib.rs
+++ b/crates/processing_ffi/src/lib.rs
@@ -9,8 +9,12 @@ use crate::color::Color;
 
 mod color;
 mod error;
+#[cfg(feature = "video")]
+mod video;
 
-unsafe fn cstr_to_str<'a>(ptr: *const std::ffi::c_char) -> Result<&'a str, ProcessingError> {
+pub(crate) unsafe fn cstr_to_str<'a>(
+    ptr: *const std::ffi::c_char,
+) -> Result<&'a str, ProcessingError> {
     unsafe { std::ffi::CStr::from_ptr(ptr) }
         .to_str()
         .map_err(|_| ProcessingError::InvalidArgument("non-UTF8 C string".to_string()))
@@ -311,6 +315,8 @@ pub extern "C" fn processing_end_draw(graphics_id: u64) {
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_exit(exit_code: u8) {
     error::clear_error();
+    #[cfg(feature = "video")]
+    video::finish_on_exit();
     error::check(|| exit(exit_code));
 }
 
@@ -1975,6 +1981,27 @@ pub extern "C" fn processing_ortho(
     error::check(|| graphics_ortho(graphics_entity, left, right, bottom, top, near, far));
 }
 
+/// Set a glFrustum-style asymmetric (off-axis) perspective projection.
+/// `left`/`right`/`bottom`/`top` bound the view volume on the NEAR plane,
+/// matching classic Processing/OpenGL `frustum()`. Requires 0 < near < far.
+///
+/// SAFETY:
+/// - graphics_id is a valid ID returned from graphics_create.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_frustum(
+    graphics_id: u64,
+    left: f32,
+    right: f32,
+    bottom: f32,
+    top: f32,
+    near: f32,
+    far: f32,
+) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    error::check(|| graphics_frustum(graphics_entity, left, right, bottom, top, near, far));
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_transform_set_position(entity_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
@@ -2786,6 +2813,31 @@ pub extern "C" fn processing_geometry_sphere(radius: f32, sectors: u32, stacks:
         .unwrap_or(0)
 }
 
+/// Tessellate and extrude `text` into a 3D geometry, honoring the graphics
+/// context's current text font, size, and style. `x`/`y` position the
+/// baseline as in text(); `depth` is the extrusion depth. Returns the
+/// geometry entity, or 0 on error.
+///
+/// SAFETY:
+/// - graphics_id is a valid ID returned from graphics_create.
+/// - text is a valid, NUL-terminated C string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_graphics_text_to_geometry(
+    graphics_id: u64,
+    text: *const std::ffi::c_char,
+    x: f32,
+    y: f32,
+    depth: f32,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        let text = unsafe { cstr_to_str(text) }?;
+        let mesh = graphics_text_to_model(Entity::from_bits(graphics_id), text, x, y, depth)?;
+        Ok(geometry_create_from_mesh(mesh)?.to_bits())
+    })
+    .unwrap_or(0)
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_light_create_directional(
     graphics_id: u64,
diff --git a/crates/processing_ffi/src/video.rs b/crates/processing_ffi/src/video.rs
new file mode 100644
index 00000000..c3385e69
--- /dev/null
+++ b/crates/processing_ffi/src/video.rs
@@ -0,0 +1,430 @@
+//! Video playback and offline recording.
+
+use std::ffi::c_char;
+use std::sync::Mutex;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use bevy::color::{ColorToPacked, Srgba};
+use bevy::prelude::Entity;
+use bevy::render::render_resource::TextureFormat;
+use processing::prelude::{
+    error::ProcessingError, graphics, graphics_readback_enqueue, graphics_readback_fetch,
+    graphics_readback_pending, image,
+};
+use processing_video::{
+    PlaybackMode, RecorderCodec, RecorderPixelFormat, VideoRecorder, VideoRecorderConfig,
+    video_create, video_destroy, video_image, video_is_loaded, video_load, video_position,
+    video_resolution, video_seek, video_set_mode, video_set_paused, video_set_speed,
+};
+
+use crate::{cstr_to_str, error};
+
+// ── Playback ────────────────────────────────────────────────────────────────
+
+/// Load a video file and create a playback entity for it. The path resolves
+/// like other assets (relative to the configured asset root). Decoding starts
+/// in the background; poll `processing_video_is_loaded` before querying
+/// resolution or drawing frames. Returns the video entity, or 0 on error.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - path is a valid, NUL-terminated C string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_video_create(path: *const c_char) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        let path = unsafe { cstr_to_str(path) }?;
+        let handle = video_load(path)?;
+        let entity = video_create(handle)?;
+        Ok(entity.to_bits())
+    })
+    .unwrap_or(0)
+}
+
+/// Whether the video's first frame has been decoded and its output exists.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_is_loaded(video_id: u64) -> bool {
+    error::clear_error();
+    error::check(|| video_is_loaded(Entity::from_bits(video_id))).unwrap_or(false)
+}
+
+/// Image entity backed by the video's output texture, creating it on first
+/// call. The image tracks playback; draw it like any other image. Returns 0
+/// on error (including the video not yet being loaded).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_image(video_id: u64) -> u64 {
+    error::clear_error();
+    error::check(|| Ok(video_image(Entity::from_bits(video_id))?.to_bits())).unwrap_or(0)
+}
+
+/// Video frame width in pixels, 0 until loaded.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_width(video_id: u64) -> u32 {
+    error::clear_error();
+    error::check(|| Ok(video_resolution(Entity::from_bits(video_id))?.0)).unwrap_or(0)
+}
+
+/// Video frame height in pixels, 0 until loaded.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_height(video_id: u64) -> u32 {
+    error::clear_error();
+    error::check(|| Ok(video_resolution(Entity::from_bits(video_id))?.1)).unwrap_or(0)
+}
+
+/// Current playback position in seconds.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_position(video_id: u64) -> f64 {
+    error::clear_error();
+    error::check(|| video_position(Entity::from_bits(video_id))).unwrap_or(0.0)
+}
+
+/// Seek to a position in seconds.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_seek(video_id: u64, seconds: f64) {
+    error::clear_error();
+    error::check(|| video_seek(Entity::from_bits(video_id), seconds));
+}
+
+/// Pause or resume playback.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_set_paused(video_id: u64, paused: bool) {
+    error::clear_error();
+    error::check(|| video_set_paused(Entity::from_bits(video_id), paused));
+}
+
+/// Set the playback rate (1.0 = normal speed).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_set_speed(video_id: u64, speed: f32) {
+    error::clear_error();
+    error::check(|| video_set_speed(Entity::from_bits(video_id), speed));
+}
+
+/// Choose whether playback loops or stops at the end.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_set_loop(video_id: u64, looping: bool) {
+    error::clear_error();
+    error::check(|| {
+        let mode = if looping {
+            PlaybackMode::Loop
+        } else {
+            PlaybackMode::Once
+        };
+        video_set_mode(Entity::from_bits(video_id), mode)
+    });
+}
+
+/// Destroy the video player and its linked image.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_video_destroy(video_id: u64) {
+    error::clear_error();
+    error::check(|| video_destroy(Entity::from_bits(video_id)));
+}
+
+// ── Recording ───────────────────────────────────────────────────────────────
+
+const X264_PRESETS: [&str; 10] = [
+    "ultrafast",
+    "superfast",
+    "veryfast",
+    "faster",
+    "fast",
+    "medium",
+    "slow",
+    "slower",
+    "veryslow",
+    "placebo",
+];
+
+enum RecState {
+    /// The recorder is created on the first captured frame so its dimensions
+    /// match the actual readback.
+    Pending {
+        path: String,
+        fps: f64,
+        crf: Option<u8>,
+        preset: Option<String>,
+        codec: RecorderCodec,
+        bitrate: Option<u64>,
+    },
+    Active(VideoRecorder),
+}
+
+static RECORDER: Mutex<Option<RecState>> = Mutex::new(None);
+
+/// The graphics whose frames the active recording captures — set on the
+/// first capture so the end/exit paths can drain in-flight async readbacks.
+static ACTIVE_GRAPHICS: AtomicU64 = AtomicU64::new(0);
+
+fn record_err(e: impl std::fmt::Display) -> ProcessingError {
+    ProcessingError::InvalidArgument(format!("video record: {e}"))
+}
+
+/// Convert a raw readback into encoder input. 8-bit sRGB surfaces (RGBA or
+/// BGRA) pass through untouched — swscale converts to the encoder's 4:2:0
+/// layout far faster than a per-pixel CPU loop; anything else takes the slow
+/// LinearRgba conversion path.
+fn recorder_pixels(
+    raw: graphics::ReadbackData,
+) -> Result<(Vec<u8>, RecorderPixelFormat), ProcessingError> {
+    match raw.format {
+        TextureFormat::Rgba8UnormSrgb | TextureFormat::Rgba8Unorm => {
+            Ok((raw.bytes, RecorderPixelFormat::Rgba8))
+        }
+        TextureFormat::Bgra8UnormSrgb | TextureFormat::Bgra8Unorm => {
+            Ok((raw.bytes, RecorderPixelFormat::Bgra8))
+        }
+        _ => {
+            let px = image::pixel_size(raw.format)?;
+            let pixels = image::bytes_to_pixels(
+                &raw.bytes,
+                raw.format,
+                raw.width,
+                raw.height,
+                raw.width as usize * px,
+            )?;
+            Ok((
+                pixels
+                    .iter()
+                    .flat_map(|pixel| Srgba::from(*pixel).to_u8_array())
+                    .collect(),
+                RecorderPixelFormat::Rgba8,
+            ))
+        }
+    }
+}
+
+/// Feed one fetched frame to the recorder, creating it on the first frame so
+/// its dimensions and pixel format match the actual readback.
+fn feed_frame(state: &mut RecState, raw: graphics::ReadbackData) -> Result<(), ProcessingError> {
+    let (width, height) = (raw.width, raw.height);
+    let (pixels, pixel_format) = recorder_pixels(raw)?;
+    if let RecState::Pending {
+        path,
+        fps,
+        crf,
+        preset,
+        codec,
+        bitrate,
+    } = state
+    {
+        let mut config =
+            VideoRecorderConfig::new(width, height, *fps).with_pixel_format(pixel_format);
+        config.crf = *crf;
+        config.preset = preset.clone();
+        config.codec = *codec;
+        config.bitrate = *bitrate;
+        let recorder = VideoRecorder::new(&*path, config).map_err(record_err)?;
+        *state = RecState::Active(recorder);
+    }
+    let RecState::Active(recorder) = state else {
+        unreachable!("state was just made Active");
+    };
+    recorder.record_frame(pixels).map_err(record_err)
+}
+
+/// Blocking-drain every in-flight async readback into the recorder.
+fn drain_ring(state: &mut RecState) -> Result<(), ProcessingError> {
+    let bits = ACTIVE_GRAPHICS.load(Ordering::Relaxed);
+    if bits == 0 {
+        return Ok(());
+    }
+    let entity = Entity::from_bits(bits);
+    while graphics_readback_pending(entity)? > 0 {
+        match graphics_readback_fetch(entity, true)? {
+            Some(raw) => feed_frame(state, raw)?,
+            None => break,
+        }
+    }
+    Ok(())
+}
+
+/// Start recording captured frames into a video file (container chosen by
+/// the path extension). Frame timestamps come from the frame index and
+/// `fps`, never wall-clock time. `crf` is 0 (lossless) to 51 (worst); pass a
+/// negative value for the encoder default (23). `preset` is an x264 speed
+/// preset (`ultrafast` .. `placebo`); pass null or an empty string for
+/// `medium`. `codec` selects the encoder: 0 = software x264, 1 = hardware
+/// H.264 via VideoToolbox (macOS), 2 = hardware HEVC via VideoToolbox.
+/// `crf`/`preset` apply to x264 only; the VideoToolbox encoders are
+/// rate-controlled by `bitrate_bps` (bits per second; pass 0 or negative for
+/// an automatic choice of ~0.1 bits/pixel/frame). Frames are queued with
+/// `processing_record_capture` and the file is finalized by
+/// `processing_record_end`.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - path is a valid, NUL-terminated C string.
+/// - preset is null or a valid, NUL-terminated C string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_record_begin(
+    path: *const c_char,
+    fps: f64,
+    crf: i32,
+    preset: *const c_char,
+    codec: u8,
+    bitrate_bps: i64,
+) {
+    error::clear_error();
+    error::check(|| {
+        let path = unsafe { cstr_to_str(path) }?.to_string();
+        let preset = if preset.is_null() {
+            None
+        } else {
+            match unsafe { cstr_to_str(preset) }? {
+                "" => None,
+                p => Some(p.to_string()),
+            }
+        };
+        if let Some(ref preset) = preset
+            && !X264_PRESETS.contains(&preset.as_str())
+        {
+            return Err(ProcessingError::InvalidArgument(format!(
+                "unknown preset {preset:?}; expected one of {X264_PRESETS:?}"
+            )));
+        }
+        if !(fps.is_finite() && fps > 0.0 && fps <= 1_000_000.0) {
+            return Err(ProcessingError::InvalidArgument(format!(
+                "fps must be a positive number no greater than 1000000, got {fps}"
+            )));
+        }
+        let crf = match crf {
+            i32::MIN..0 => None,
+            0..=51 => Some(crf as u8),
+            _ => {
+                return Err(ProcessingError::InvalidArgument(format!(
+                    "crf must be between 0 (lossless) and 51 (worst quality), got {crf}"
+                )));
+            }
+        };
+        let codec = match codec {
+            0 => RecorderCodec::X264,
+            1 => RecorderCodec::H264VideoToolbox,
+            2 => RecorderCodec::HevcVideoToolbox,
+            other => {
+                return Err(ProcessingError::InvalidArgument(format!(
+                    "unknown codec {other}; expected 0 (x264), 1 (h264_videotoolbox), \
+                     or 2 (hevc_videotoolbox)"
+                )));
+            }
+        };
+        let bitrate = (bitrate_bps > 0).then_some(bitrate_bps as u64);
+        let mut slot = RECORDER.lock().unwrap();
+        if slot.is_some() {
+            return Err(ProcessingError::InvalidArgument(
+                "already recording; call processing_record_end first".to_string(),
+            ));
+        }
+        *slot = Some(RecState::Pending {
+            path,
+            fps,
+            crf,
+            preset,
+            codec,
+            bitrate,
+        });
+        Ok(())
+    });
+}
+
+/// Capture the graphics canvas as one video frame. A no-op when not
+/// recording. The copy is submitted asynchronously into a bounded ring so
+/// the render loop overlaps the next frame with this frame's readback;
+/// completed frames are drained to the encoder in order. The recorder is
+/// created on the first completed frame, sized to the readback; a failed
+/// capture stops the recording and reports the error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_record_capture(graphics_id: u64) {
+    error::clear_error();
+    error::check(|| {
+        let mut slot = RECORDER.lock().unwrap();
+        let Some(state) = slot.as_mut() else {
+            return Ok(());
+        };
+        ACTIVE_GRAPHICS.store(graphics_id, Ordering::Relaxed);
+        let entity = Entity::from_bits(graphics_id);
+        let result = (|| {
+            let timing = std::env::var_os("PROCESSING_RECORD_TIMING").is_some();
+            let t0 = std::time::Instant::now();
+            graphics_readback_enqueue(entity)?;
+            let t1 = std::time::Instant::now();
+            let mut fetched = 0u32;
+            while let Some(raw) = graphics_readback_fetch(entity, false)? {
+                feed_frame(state, raw)?;
+                fetched += 1;
+            }
+            let t2 = std::time::Instant::now();
+            // Ring at capacity: block on the oldest copy so the ring never
+            // overflows — render stays paced by readback+encode throughput.
+            let mut blocked = false;
+            if graphics_readback_pending(entity)? >= graphics::READBACK_RING_DEPTH {
+                if let Some(raw) = graphics_readback_fetch(entity, true)? {
+                    feed_frame(state, raw)?;
+                    blocked = true;
+                }
+            }
+            if timing {
+                eprintln!(
+                    "capture: enqueue={:?} fetch={:?}({fetched}) block={:?}({blocked})",
+                    t1 - t0,
+                    t2 - t1,
+                    t2.elapsed(),
+                );
+            }
+            Ok(())
+        })();
+        if result.is_err() {
+            *slot = None;
+            ACTIVE_GRAPHICS.store(0, Ordering::Relaxed);
+        }
+        result
+    });
+}
+
+/// Whether a recording is in progress.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_record_active() -> bool {
+    error::clear_error();
+    RECORDER.lock().unwrap().is_some()
+}
+
+/// Finish the recording, finalize the file, and return the number of frames
+/// encoded (0 on error).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_record_end() -> u64 {
+    error::clear_error();
+    error::check(|| {
+        let taken = RECORDER.lock().unwrap().take();
+        match taken {
+            None => Err(ProcessingError::InvalidArgument(
+                "not recording; call processing_record_begin first".to_string(),
+            )),
+            Some(mut state) => {
+                let drained = drain_ring(&mut state);
+                ACTIVE_GRAPHICS.store(0, Ordering::Relaxed);
+                drained?;
+                match state {
+                    RecState::Pending { .. } => Err(ProcessingError::InvalidArgument(
+                        "no frames were captured between processing_record_begin and \
+                         processing_record_end"
+                            .to_string(),
+                    )),
+                    RecState::Active(recorder) => recorder.finish().map_err(record_err),
+                }
+            }
+        }
+    })
+    .unwrap_or(0)
+}
+
+/// Closing the window mid-recording still leaves a playable file.
+pub(crate) fn finish_on_exit() {
+    if let Ok(mut slot) = RECORDER.lock()
+        && let Some(mut state) = slot.take()
+    {
+        let _ = drain_ring(&mut state);
+        if let RecState::Active(recorder) = state {
+            let _ = recorder.finish();
+        }
+    }
+    ACTIVE_GRAPHICS.store(0, Ordering::Relaxed);
+}
diff --git a/crates/processing_render/src/graphics.rs b/crates/processing_render/src/graphics.rs
index 2c4164fe..bce83fa7 100644
--- a/crates/processing_render/src/graphics.rs
+++ b/crates/processing_render/src/graphics.rs
@@ -150,6 +150,74 @@ impl CameraProjection for ProcessingProjection {
     }
 }
 
+/// Off-axis (asymmetric) perspective projection — classic OpenGL/Processing
+/// `frustum()`. `left`/`right`/`bottom`/`top` bound the view volume on the
+/// near plane, in view-space units.
+#[derive(Debug, Clone, Reflect)]
+pub struct FrustumProjection {
+    pub left: f32,
+    pub right: f32,
+    pub bottom: f32,
+    pub top: f32,
+    pub near: f32,
+    pub far: f32,
+}
+
+impl CameraProjection for FrustumProjection {
+    fn get_clip_from_view(&self) -> Mat4 {
+        // The standard glFrustum matrix, except depth is REVERSED (near → 1,
+        // far → 0) to match the rest of the pipeline — bevy's perspective is
+        // infinite-reverse and its ortho swaps near/far for the same reason.
+        // An ortho can reverse by swapping near/far in the standard formula;
+        // a frustum cannot (near also sets the x/y scale), so the z column is
+        // derived directly: it hits 1 at z_view = −near and 0 at z_view = −far.
+        let (l, r, b, t, n, f) = (
+            self.left,
+            self.right,
+            self.bottom,
+            self.top,
+            self.near,
+            self.far,
+        );
+        Mat4::from_cols(
+            Vec4::new(2.0 * n / (r - l), 0.0, 0.0, 0.0),
+            Vec4::new(0.0, 2.0 * n / (t - b), 0.0, 0.0),
+            Vec4::new((r + l) / (r - l), (t + b) / (t - b), n / (f - n), -1.0),
+            Vec4::new(0.0, 0.0, n * f / (f - n), 0.0),
+        )
+    }
+
+    fn get_clip_from_view_for_sub(&self, _sub_view: &bevy::camera::SubCameraView) -> Mat4 {
+        self.get_clip_from_view()
+    }
+
+    fn update(&mut self, _width: f32, _height: f32) {
+        // Explicit view-volume bounds don't track the window size.
+    }
+
+    fn far(&self) -> f32 {
+        self.far
+    }
+
+    fn get_frustum_corners(&self, z_near: f32, z_far: f32) -> [Vec3A; 8] {
+        // The near-plane bounds scale linearly with distance along the rays.
+        let sn = z_near.abs() / self.near;
+        let sf = z_far.abs() / self.near;
+        [
+            // near plane
+            Vec3A::new(self.right * sn, self.bottom * sn, z_near), // bottom-right
+            Vec3A::new(self.right * sn, self.top * sn, z_near),    // top-right
+            Vec3A::new(self.left * sn, self.top * sn, z_near),     // top-left
+            Vec3A::new(self.left * sn, self.bottom * sn, z_near),  // bottom-left
+            // far plane
+            Vec3A::new(self.right * sf, self.bottom * sf, z_far), // bottom-right
+            Vec3A::new(self.right * sf, self.top * sf, z_far),    // top-right
+            Vec3A::new(self.left * sf, self.top * sf, z_far),     // top-left
+            Vec3A::new(self.left * sf, self.bottom * sf, z_far),  // bottom-left
+        ]
+    }
+}
+
 pub fn create(
     In((width, height, surface_entity, texture_format)): In<(u32, u32, Entity, TextureFormat)>,
     mut commands: Commands,
@@ -373,7 +441,7 @@ pub fn perspective(
             aspect_ratio,
             near,
             far,
-            near_clip_plane,
+            near_clip_plane: _,
         },
     )): In<(Entity, PerspectiveProjection)>,
     mut projections: Query<&mut Projection>,
@@ -382,12 +450,22 @@ pub fn perspective(
         .get_mut(entity)
         .map_err(|_| ProcessingError::GraphicsNotFound)?;
 
-    *projection = Projection::Perspective(PerspectiveProjection {
-        fov,
-        aspect_ratio,
+    // An explicit perspective() must honor ALL its parameters — including a
+    // deliberately anamorphic aspect ratio. Bevy's PerspectiveProjection
+    // cannot: its update() overwrites aspect_ratio with the viewport aspect
+    // on every render-area pass, silently discarding the caller's value. So
+    // express the same view volume as the equivalent symmetric frustum,
+    // whose update() is inert. The window-tracking default stays with
+    // mode_3d's Projection::Perspective.
+    let top = near * (fov / 2.0).tan();
+    let right = top * aspect_ratio;
+    *projection = Projection::custom(FrustumProjection {
+        left: -right,
+        right,
+        bottom: -top,
+        top,
         near,
         far,
-        near_clip_plane,
     });
 
     Ok(())
@@ -432,6 +510,53 @@ pub fn ortho(
     Ok(())
 }
 
+pub struct FrustumArgs {
+    pub left: f32,
+    pub right: f32,
+    pub bottom: f32,
+    pub top: f32,
+    pub near: f32,
+    pub far: f32,
+}
+
+/// glFrustum-style asymmetric perspective: the bounds are on the NEAR plane.
+pub fn frustum(
+    In((
+        entity,
+        FrustumArgs {
+            left,
+            right,
+            bottom,
+            top,
+            near,
+            far,
+        },
+    )): In<(Entity, FrustumArgs)>,
+    mut projections: Query<&mut Projection>,
+) -> Result<()> {
+    let mut projection = projections
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::GraphicsNotFound)?;
+
+    if !(near > 0.0 && far > near && right != left && top != bottom) {
+        return Err(ProcessingError::InvalidArgument(format!(
+            "frustum requires 0 < near < far and non-empty bounds, \
+             got left={left} right={right} bottom={bottom} top={top} near={near} far={far}"
+        )));
+    }
+
+    *projection = Projection::custom(FrustumProjection {
+        left,
+        right,
+        bottom,
+        top,
+        near,
+        far,
+    });
+
+    Ok(())
+}
+
 pub fn world_from_screen(
     In((entity, sx, sy, depth)): In<(Entity, f32, f32, f32)>,
     cameras: Query<(&bevy::camera::Camera, &GlobalTransform)>,
@@ -706,6 +831,310 @@ pub fn readback_raw(
     })
 }
 
+// ── Asynchronous readback ring ──────────────────────────────────────────────
+// The synchronous readback above stalls the caller for a full pipeline flush
+// plus the GPU→CPU copy every call — at 3840×4320 that is most of a frame's
+// wall time and dominates recording. The ring splits the operation: `enqueue`
+// submits the copy and returns immediately; `fetch` hands back frames whose
+// map has completed, in submission order. With a few frames in flight the
+// copy of frame N overlaps the render of frame N+1 and readback mostly
+// leaves the critical path. Consumers that tolerate a frame or two of
+// latency (the video recorder) use this; point queries keep the sync path.
+
+/// Frames allowed in flight before `readback_ring_enqueue` refuses. Bounds
+/// memory (one full frame each — ~66MB at 3840×4320) and bounds how far the
+/// producer can run ahead.
+pub const READBACK_RING_DEPTH: usize = 3;
+
+struct PendingReadback {
+    buffer: bevy::render::render_resource::Buffer,
+    ready: std::sync::Arc<std::sync::atomic::AtomicBool>,
+    /// The copy's own submission, so a blocking fetch waits for exactly this
+    /// copy — waiting for "the most recent submission" would drain the whole
+    /// queue (including newer copies and the in-flight render) and serialize
+    /// the pipeline into burst-stall cycles.
+    submission: wgpu::SubmissionIndex,
+    padded_bytes_per_row: usize,
+    bytes_per_row: usize,
+    format: TextureFormat,
+    width: u32,
+    height: u32,
+}
+
+/// GPU-side format conversion in front of the readback: HDR (or any
+/// non-8-bit) surfaces are blitted into an 8-bit sRGB texture BEFORE the
+/// copy, so the readback moves half the bytes and the CPU never touches a
+/// float pixel. (A 3840×4320 Rgba16Float frame is 132MB and a per-pixel CPU
+/// conversion of it costs ~350ms — it, not the copy, was the recording
+/// bottleneck.)
+struct ConvertPass {
+    texture: wgpu::Texture,
+    view: wgpu::TextureView,
+    blitter: wgpu::util::TextureBlitter,
+    width: u32,
+    height: u32,
+}
+
+/// Per-graphics async readback state; created lazily on first enqueue.
+#[derive(Component, Default)]
+pub struct ReadbackRing {
+    free: Vec<(bevy::render::render_resource::Buffer, u64)>,
+    pending: std::collections::VecDeque<PendingReadback>,
+    convert: Option<ConvertPass>,
+}
+
+pub fn readback_ring_enqueue(
+    In((entity, texture)): In<(Entity, Texture)>,
+    world: &mut World,
+) -> Result<()> {
+    let render_device = world.resource::<RenderDevice>().clone();
+    let render_queue = world.resource::<RenderQueue>().clone();
+    let (source_format, size) = {
+        let graphics = world
+            .get::<Graphics>(entity)
+            .ok_or(ProcessingError::GraphicsNotFound)?;
+        (graphics.texture_format, graphics.size)
+    };
+    // 8-bit surfaces read back as they are; everything else converts on the
+    // GPU to 8-bit sRGB first (see ConvertPass).
+    let needs_convert = !matches!(
+        source_format,
+        TextureFormat::Rgba8UnormSrgb
+            | TextureFormat::Rgba8Unorm
+            | TextureFormat::Bgra8UnormSrgb
+            | TextureFormat::Bgra8Unorm
+    );
+    let format = if needs_convert {
+        TextureFormat::Rgba8UnormSrgb
+    } else {
+        source_format
+    };
+    let px_size = pixel_size(format)?;
+    let bytes_per_row = size.width as usize * px_size;
+    let padded_bytes_per_row = RenderDevice::align_copy_bytes_per_row(bytes_per_row);
+    let buffer_size = padded_bytes_per_row as u64 * size.height as u64;
+
+    if world.get::<ReadbackRing>(entity).is_none() {
+        world.entity_mut(entity).insert(ReadbackRing::default());
+    }
+    {
+        let ring = world.get::<ReadbackRing>(entity).unwrap();
+        if ring.pending.len() >= READBACK_RING_DEPTH {
+            return Err(ProcessingError::InvalidArgument(
+                "readback ring full; fetch completed frames first".to_string(),
+            ));
+        }
+    }
+
+    // Reuse a free buffer of the right size; a resize just retires old ones.
+    let buffer = {
+        let mut ring = world.get_mut::<ReadbackRing>(entity).unwrap();
+        ring.free.retain(|(_, sz)| *sz == buffer_size);
+        match ring.free.pop() {
+            Some((b, _)) => b,
+            None => create_readback_buffer(
+                &render_device,
+                size.width,
+                size.height,
+                format,
+                "async readback ring buffer",
+            )?,
+        }
+    };
+
+    if needs_convert {
+        let stale = match world.get::<ReadbackRing>(entity).unwrap().convert {
+            Some(ref c) => c.width != size.width || c.height != size.height,
+            None => true,
+        };
+        if stale {
+            let device = render_device.wgpu_device();
+            let tex = device.create_texture(&wgpu::TextureDescriptor {
+                label: Some("async readback convert target"),
+                size: wgpu::Extent3d {
+                    width: size.width,
+                    height: size.height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: TextureFormat::Rgba8UnormSrgb,
+                usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::COPY_SRC,
+                view_formats: &[],
+            });
+            let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
+            let blitter =
+                wgpu::util::TextureBlitter::new(device, TextureFormat::Rgba8UnormSrgb);
+            world.get_mut::<ReadbackRing>(entity).unwrap().convert = Some(ConvertPass {
+                texture: tex,
+                view,
+                blitter,
+                width: size.width,
+                height: size.height,
+            });
+        }
+    }
+
+    let mut encoder = render_device.create_command_encoder(&CommandEncoderDescriptor::default());
+    let copy_src = if needs_convert {
+        let src_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let ring = world.get::<ReadbackRing>(entity).unwrap();
+        let convert = ring.convert.as_ref().unwrap();
+        convert
+            .blitter
+            .copy(render_device.wgpu_device(), &mut encoder, &src_view, &convert.view);
+        convert.texture.clone()
+    } else {
+        // bevy's Texture derefs to the raw wgpu texture.
+        wgpu::Texture::clone(&texture)
+    };
+    encoder.copy_texture_to_buffer(
+        copy_src.as_image_copy(),
+        TexelCopyBufferInfo {
+            buffer: &buffer,
+            layout: TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(
+                    std::num::NonZero::<u32>::new(padded_bytes_per_row as u32)
+                        .unwrap()
+                        .into(),
+                ),
+                rows_per_image: None,
+            },
+        },
+        size,
+    );
+    let submission = render_queue.submit(std::iter::once(encoder.finish()));
+
+    let ready = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let ready_cb = std::sync::Arc::clone(&ready);
+    buffer.slice(..).map_async(MapMode::Read, move |r| {
+        r.expect("Failed to map async readback buffer");
+        ready_cb.store(true, std::sync::atomic::Ordering::Release);
+    });
+
+    world
+        .get_mut::<ReadbackRing>(entity)
+        .unwrap()
+        .pending
+        .push_back(PendingReadback {
+            buffer,
+            ready,
+            submission,
+            padded_bytes_per_row,
+            bytes_per_row,
+            format,
+            width: size.width,
+            height: size.height,
+        });
+    Ok(())
+}
+
+/// Number of enqueued readbacks not yet fetched.
+pub fn readback_ring_pending(In(entity): In<Entity>, world: &mut World) -> Result<usize> {
+    Ok(world
+        .get::<ReadbackRing>(entity)
+        .map(|r| r.pending.len())
+        .unwrap_or(0))
+}
+
+/// Fetch the oldest enqueued readback if (or, blocking, once) its copy has
+/// completed. Returns `None` when nothing is pending, or when non-blocking
+/// and the oldest copy is still in flight.
+pub fn readback_ring_fetch(
+    In((entity, blocking)): In<(Entity, bool)>,
+    world: &mut World,
+) -> Result<Option<ReadbackData>> {
+    let render_device = world.resource::<RenderDevice>().clone();
+    {
+        let Some(ring) = world.get::<ReadbackRing>(entity) else {
+            return Ok(None);
+        };
+        if ring.pending.is_empty() {
+            return Ok(None);
+        }
+    }
+
+    // Pump the device so map_async callbacks can fire; block only if asked,
+    // and then only until THIS copy's submission completes — never the whole
+    // queue.
+    loop {
+        let (ready, submission) = {
+            let ring = world.get::<ReadbackRing>(entity).unwrap();
+            let front = ring.pending.front().unwrap();
+            (
+                front.ready.load(std::sync::atomic::Ordering::Acquire),
+                front.submission.clone(),
+            )
+        };
+        if ready {
+            break;
+        }
+        if blocking {
+            render_device
+                .poll(PollType::Wait {
+                    submission_index: Some(submission),
+                    timeout: None,
+                })
+                .expect("Failed to poll device for async readback");
+        } else {
+            render_device
+                .poll(PollType::Poll)
+                .expect("Failed to poll device for async readback");
+            let ready_now = {
+                let ring = world.get::<ReadbackRing>(entity).unwrap();
+                ring.pending
+                    .front()
+                    .unwrap()
+                    .ready
+                    .load(std::sync::atomic::Ordering::Acquire)
+            };
+            if !ready_now {
+                return Ok(None);
+            }
+        }
+    }
+
+    let pr = world
+        .get_mut::<ReadbackRing>(entity)
+        .unwrap()
+        .pending
+        .pop_front()
+        .unwrap();
+    let data = pr
+        .buffer
+        .slice(..)
+        .get_mapped_range()
+        .expect("Failed to get mapped range for async readback")
+        .to_vec();
+    pr.buffer.unmap();
+
+    let unpadded = if pr.padded_bytes_per_row != pr.bytes_per_row {
+        data.chunks_exact(pr.padded_bytes_per_row)
+            .take(pr.height as usize)
+            .flat_map(|row| &row[..pr.bytes_per_row])
+            .copied()
+            .collect()
+    } else {
+        data
+    };
+
+    let buffer_size = pr.padded_bytes_per_row as u64 * pr.height as u64;
+    world
+        .get_mut::<ReadbackRing>(entity)
+        .unwrap()
+        .free
+        .push((pr.buffer, buffer_size));
+
+    Ok(Some(ReadbackData {
+        bytes: unpadded,
+        format: pr.format,
+        width: pr.width,
+        height: pr.height,
+    }))
+}
+
 pub fn update_region_write(
     In((entity, texture, x, y, width, height, data, px_size)): In<(
         Entity,
diff --git a/crates/processing_render/src/lib.rs b/crates/processing_render/src/lib.rs
index 072960e2..7eb9649b 100644
--- a/crates/processing_render/src/lib.rs
+++ b/crates/processing_render/src/lib.rs
@@ -666,6 +666,45 @@ pub fn graphics_readback_raw(graphics_entity: Entity) -> error::Result<graphics:
     })
 }
 
+/// Submit an asynchronous readback of the current graphics surface into the
+/// per-graphics ring (bounded at [`graphics::READBACK_RING_DEPTH`] frames in
+/// flight). Returns immediately; collect results with
+/// [`graphics_readback_fetch`]. The copy of one frame overlaps the render of
+/// the next, keeping readback off the critical path for streaming consumers
+/// like the video recorder.
+pub fn graphics_readback_enqueue(graphics_entity: Entity) -> error::Result<()> {
+    app_mut(|app| {
+        graphics::flush(app, graphics_entity)?;
+        let vt = graphics::view_target(app, graphics_entity)?;
+        let texture = vt.main_texture().clone();
+        app.world_mut()
+            .run_system_cached_with(graphics::readback_ring_enqueue, (graphics_entity, texture))
+            .unwrap()
+    })
+}
+
+/// Fetch the oldest completed asynchronous readback, in submission order.
+/// Non-blocking unless `blocking`; `None` when nothing is ready/pending.
+pub fn graphics_readback_fetch(
+    graphics_entity: Entity,
+    blocking: bool,
+) -> error::Result<Option<graphics::ReadbackData>> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(graphics::readback_ring_fetch, (graphics_entity, blocking))
+            .unwrap()
+    })
+}
+
+/// Asynchronous readbacks submitted but not yet fetched.
+pub fn graphics_readback_pending(graphics_entity: Entity) -> error::Result<usize> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(graphics::readback_ring_pending, graphics_entity)
+            .unwrap()
+    })
+}
+
 /// Read back pixel data from the graphics surface as LinearRgba.
 pub fn graphics_readback(graphics_entity: Entity) -> error::Result<Vec<LinearRgba>> {
     let raw = graphics_readback_raw(graphics_entity)?;
@@ -932,6 +971,38 @@ pub fn graphics_ortho(
     })
 }
 
+/// glFrustum-style asymmetric perspective projection; the bounds are on the
+/// near plane, matching classic Processing/OpenGL `frustum()`.
+pub fn graphics_frustum(
+    graphics_entity: Entity,
+    left: f32,
+    right: f32,
+    bottom: f32,
+    top: f32,
+    near: f32,
+    far: f32,
+) -> error::Result<()> {
+    app_mut(|app| {
+        flush(app, graphics_entity)?;
+        app.world_mut()
+            .run_system_cached_with(
+                graphics::frustum,
+                (
+                    graphics_entity,
+                    graphics::FrustumArgs {
+                        left,
+                        right,
+                        bottom,
+                        top,
+                        near,
+                        far,
+                    },
+                ),
+            )
+            .unwrap()
+    })
+}
+
 pub fn graphics_world_from_screen(
     graphics_entity: Entity,
     sx: f32,
diff --git a/crates/processing_render/src/material/custom.rs b/crates/processing_render/src/material/custom.rs
index 4ccd09b7..286ef490 100644
--- a/crates/processing_render/src/material/custom.rs
+++ b/crates/processing_render/src/material/custom.rs
@@ -11,7 +11,7 @@ wesl::wesl_pkg!(lygia);
 
 use bevy::{
     asset::{AsAssetId, AssetEventSystems},
-    core_pipeline::core_3d::Opaque3d,
+    core_pipeline::core_3d::{AlphaMask3d, Opaque3d, Transparent3d},
     ecs::system::{
         SystemParamItem,
         lifetimeless::{SRes, SResMut},
@@ -24,10 +24,10 @@ use bevy::{
     },
     mesh::MeshVertexBufferLayoutRef,
     pbr::{
-        DrawMaterial, EntitiesNeedingSpecialization, MainPassOpaqueDrawFunction,
-        MainPassTransparentDrawFunction, MaterialFragmentShader, MaterialVertexShader,
-        MeshPipelineKey, PreparedMaterial, RenderMaterialInstance, RenderMaterialInstances,
-        base_specialize,
+        DrawMaterial, EntitiesNeedingSpecialization, MainPassAlphaMaskDrawFunction,
+        MainPassOpaqueDrawFunction, MainPassTransparentDrawFunction, MaterialFragmentShader,
+        MaterialVertexShader, MeshPipelineKey, PreparedMaterial, RenderMaterialInstance,
+        RenderMaterialInstances, base_specialize,
     },
     prelude::*,
     reflect::{PartialReflect, ReflectMut, ReflectRef, structs::Struct},
@@ -576,6 +576,8 @@ impl ErasedRenderAsset for CustomMaterial {
     type ErasedAsset = PreparedMaterial;
     type Param = (
         SRes<DrawFunctions<Opaque3d>>,
+        SRes<DrawFunctions<AlphaMask3d>>,
+        SRes<DrawFunctions<Transparent3d>>,
         SRes<AssetServer>,
         SRes<RenderDevice>,
         SResMut<MaterialBindGroupAllocators>,
@@ -589,6 +591,8 @@ impl ErasedRenderAsset for CustomMaterial {
         asset_id: AssetId<Self::SourceAsset>,
         (
             opaque_draw_functions,
+            alpha_mask_draw_functions,
+            transparent_draw_functions,
             _asset_server,
             render_device,
             bind_group_allocators,
@@ -631,9 +635,34 @@ impl ErasedRenderAsset for CustomMaterial {
                 .insert(bind_group_allocator.allocate_unprepared(unprepared, &bind_group_layout)),
         };
 
-        let draw_function = opaque_draw_functions.read().id::<DrawMaterial>();
+        // A `DrawFunctionId` is an index into a PER-PHASE registry — each
+        // phase label must carry its own registry's id, never a reused one.
+        let draw_opaque = opaque_draw_functions.read().id::<DrawMaterial>();
+        let draw_alpha_mask = alpha_mask_draw_functions.read().id::<DrawMaterial>();
+        let draw_transparent = transparent_draw_functions.read().id::<DrawMaterial>();
 
         let blend_state = source_asset.blend_state;
+        // A custom blend forces the sorted transparent phase (an arbitrary
+        // blend equation can't be assumed commutative); otherwise honor the
+        // explicitly-set alpha mode.
+        let alpha_mode = if blend_state.is_some() {
+            AlphaMode::Blend
+        } else {
+            source_asset.alpha_mode
+        };
+        // The queue phase must follow the effective alpha mode (as
+        // bevy_pbr's Material impl derives it) — a Blend material left in
+        // the default Opaque binned phase draws before Transparent3d and is
+        // erased by the background quad, which is itself a Transparent3d
+        // REPLACE draw.
+        let render_phase_type = match alpha_mode {
+            AlphaMode::Blend
+            | AlphaMode::Premultiplied
+            | AlphaMode::Add
+            | AlphaMode::Multiply => bevy::material::RenderPhaseType::Transparent,
+            AlphaMode::Mask(_) => bevy::material::RenderPhaseType::AlphaMask,
+            _ => bevy::material::RenderPhaseType::Opaque,
+        };
         let mut properties = MaterialProperties {
             mesh_pipeline_key_bits: ErasedMeshPipelineKey::new(MeshPipelineKey::empty()),
             base_specialize: Some(base_specialize),
@@ -644,18 +673,13 @@ impl ErasedRenderAsset for CustomMaterial {
                 depth_write: source_asset.depth_write,
             }),
             user_specialize: Some(specialize),
-            // A custom blend forces the sorted transparent phase (an arbitrary
-            // blend equation can't be assumed commutative); otherwise honor the
-            // explicitly-set alpha mode.
-            alpha_mode: if blend_state.is_some() {
-                AlphaMode::Blend
-            } else {
-                source_asset.alpha_mode
-            },
+            alpha_mode,
+            render_phase_type,
             ..Default::default()
         };
-        properties.add_draw_function(MainPassOpaqueDrawFunction, draw_function);
-        properties.add_draw_function(MainPassTransparentDrawFunction, draw_function);
+        properties.add_draw_function(MainPassOpaqueDrawFunction, draw_opaque);
+        properties.add_draw_function(MainPassAlphaMaskDrawFunction, draw_alpha_mask);
+        properties.add_draw_function(MainPassTransparentDrawFunction, draw_transparent);
         if source_asset.has_vertex {
             properties.add_shader(MaterialVertexShader, source_asset.shader_handle.clone());
         }
@@ -668,6 +692,22 @@ impl ErasedRenderAsset for CustomMaterial {
             properties: Arc::new(properties),
         })
     }
+
+    fn unload_asset(
+        source_asset: AssetId<Self::SourceAsset>,
+        (_, _, _, _, _, bind_group_allocators, render_material_bindings, _, _): &mut SystemParamItem<
+            Self::Param,
+        >,
+    ) {
+        // Mirror bevy_pbr's Material unload: without this the per-frame
+        // blend-state clones leak a RenderMaterialBindings entry and a
+        // bind-group slot every frame.
+        if let Some(binding) = render_material_bindings.remove(&source_asset.untyped())
+            && let Some(allocator) = bind_group_allocators.get_mut(&TypeId::of::<CustomMaterial>())
+        {
+            allocator.free(binding);
+        }
+    }
 }
 
 fn extract_custom_materials(
diff --git a/crates/processing_render/src/particles/kernels/mod.rs b/crates/processing_render/src/particles/kernels/mod.rs
index 6c19bf3a..c8816f08 100644
--- a/crates/processing_render/src/particles/kernels/mod.rs
+++ b/crates/processing_render/src/particles/kernels/mod.rs
@@ -43,6 +43,7 @@ impl Plugin for ParticlesKernelsPlugin {
         embedded_asset!(app, "bounds_box.wgsl");
         embedded_asset!(app, "impulse.wgsl");
         embedded_asset!(app, "flock.wgsl");
+        embedded_asset!(app, "flock_naive.wgsl");
         embedded_asset!(app, "orient.wgsl");
         embedded_asset!(app, "field.wgsl");
         embedded_asset!(app, "attr_linear.wgsl");
@@ -253,15 +254,21 @@ pub fn particles_kernel_impulse() -> error::Result<Entity> {
     Ok(entity)
 }
 
-// TODO(WIP): tiled all-pairs exact flock kernel for the `max_neighbors == 0`
-// path in `particles_flock_auto`. Stubbed so the build stays green while the
-// kernel is written.
+// Tiled all-pairs exact flock for the `max_neighbors == 0` path in
+// `particles_flock_auto`. Velocity-only, like the grid kernel.
 pub fn particles_kernel_flock_naive() -> error::Result<Entity> {
-    Err(error::ProcessingError::InvalidArgument(
-        "the exact (all-pairs) flock kernel is not implemented yet; \
-         set max_neighbors > 0 to use the grid-accelerated path"
-            .to_string(),
-    ))
+    let shader = shader_load("embedded://processing_render/particles/kernels/flock_naive.wgsl")?;
+    let entity = compute_create(shader)?;
+    set_requires(entity, &["position", "velocity"])?;
+    compute_set(entity, "sep_distance", ShaderValue::Float(1.2))?;
+    compute_set(entity, "neighbor_distance", ShaderValue::Float(2.5))?;
+    compute_set(entity, "weight_separation", ShaderValue::Float(1.5))?;
+    compute_set(entity, "weight_alignment", ShaderValue::Float(1.0))?;
+    compute_set(entity, "weight_cohesion", ShaderValue::Float(1.0))?;
+    compute_set(entity, "max_speed", ShaderValue::Float(0.1))?;
+    compute_set(entity, "max_force", ShaderValue::Float(0.003))?;
+    compute_set(entity, "min_speed", ShaderValue::Float(0.0))?;
+    Ok(entity)
 }
 
 pub fn particles_kernel_flock() -> error::Result<Entity> {
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
index 967ea238..5f1fbf6b 100644
--- a/crates/processing_video/src/lib.rs
+++ b/crates/processing_video/src/lib.rs
@@ -10,7 +10,9 @@ pub use nannou_video::{
 };
 
 mod record;
-pub use record::{RecorderPixelFormat, VideoRecordError, VideoRecorder, VideoRecorderConfig};
+pub use record::{
+    RecorderCodec, RecorderPixelFormat, VideoRecordError, VideoRecorder, VideoRecorderConfig,
+};
 
 use processing_core::app_mut;
 use processing_core::error::{ProcessingError, Result};
diff --git a/crates/processing_video/src/record.rs b/crates/processing_video/src/record.rs
index 6d25d717..bb18924c 100644
--- a/crates/processing_video/src/record.rs
+++ b/crates/processing_video/src/record.rs
@@ -1,15 +1,28 @@
 //! Offline video recording. Frame timestamps come from the frame index and
 //! configured fps, never wall-clock time.
+//!
+//! The capture→encode queue is bounded ([`QUEUE_DEPTH`] frames) with a
+//! blocking submit, so the render loop is paced by the encoder and memory
+//! stays flat (at 8K RGBA a queued frame is ~130MB). Finalize drains at most
+//! the queued frames plus the encoder's internal lookahead; progress is
+//! logged so a slow software drain is distinguishable from a hang.
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::Once;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::mpsc::{Receiver, SyncSender, sync_channel};
+use std::sync::Arc;
 use std::thread;
 
-use video_rs::encode::{Encoder, Settings};
-use video_rs::frame::{PixelFormat, RawFrame};
-use video_rs::time::Time;
+use bevy::log::info;
+use video_rs::ffmpeg;
+use video_rs::ffmpeg::util::mathematics::rescale::TIME_BASE;
+
+/// Bounded frame queue between the render thread and the encoder thread.
+/// Submit blocks when full — the render loop runs at encode speed rather
+/// than piling frames up in memory.
+const QUEUE_DEPTH: usize = 3;
 
 /// Pixel layout of the frames passed to [`VideoRecorder::record_frame`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -29,6 +42,63 @@ impl RecorderPixelFormat {
             RecorderPixelFormat::Rgb8 => 3,
         }
     }
+
+    fn av_pixel(self) -> ffmpeg::format::Pixel {
+        match self {
+            RecorderPixelFormat::Rgba8 => ffmpeg::format::Pixel::RGBA,
+            RecorderPixelFormat::Bgra8 => ffmpeg::format::Pixel::BGRA,
+            RecorderPixelFormat::Rgb8 => ffmpeg::format::Pixel::RGB24,
+        }
+    }
+}
+
+/// Which encoder produces the output stream.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum RecorderCodec {
+    /// Software x264. Portable and quality-tunable (`crf`/`preset`), but
+    /// slow at high resolutions (~1 fps at 8K on an M-series CPU).
+    #[default]
+    X264,
+    /// Hardware H.264 via VideoToolbox (macOS). Many× realtime at 4K+;
+    /// rate-controlled by `bitrate` instead of `crf`.
+    H264VideoToolbox,
+    /// Hardware HEVC via VideoToolbox (macOS). Same speed class as H.264
+    /// hardware encode, better compression at high resolutions.
+    HevcVideoToolbox,
+}
+
+impl RecorderCodec {
+    fn ffmpeg_name(self) -> &'static str {
+        match self {
+            RecorderCodec::X264 => "libx264",
+            RecorderCodec::H264VideoToolbox => "h264_videotoolbox",
+            RecorderCodec::HevcVideoToolbox => "hevc_videotoolbox",
+        }
+    }
+
+    fn is_videotoolbox(self) -> bool {
+        matches!(
+            self,
+            RecorderCodec::H264VideoToolbox | RecorderCodec::HevcVideoToolbox
+        )
+    }
+
+    /// Encoder-side pixel format. x264 needs planar 4:2:0 (software swscale
+    /// conversion). VideoToolbox accepts BGRA directly and converts to 4:2:0
+    /// in hardware — for a BGRA source that removes the CPU swscale pass
+    /// entirely, which at high resolutions is otherwise the pipeline's
+    /// slowest single-threaded stage (~350ms/frame at 3840×4320); other
+    /// sources hand it NV12.
+    fn target_pixel(self, source: RecorderPixelFormat) -> ffmpeg::format::Pixel {
+        if self.is_videotoolbox() {
+            match source {
+                RecorderPixelFormat::Bgra8 => ffmpeg::format::Pixel::BGRA,
+                _ => ffmpeg::format::Pixel::NV12,
+            }
+        } else {
+            ffmpeg::format::Pixel::YUV420P
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -37,16 +107,22 @@ pub struct VideoRecorderConfig {
     pub height: u32,
     pub fps: f64,
     pub pixel_format: RecorderPixelFormat,
+    pub codec: RecorderCodec,
     /// Use the encoder's realtime preset (faster encode, larger output).
+    /// x264 only.
     pub realtime: bool,
     /// Keyframe interval in frames. `None` uses the encoder default.
     pub keyframe_interval: Option<u64>,
     /// Constant Rate Factor, 0 (lossless) to 51 (worst quality). `None` uses
-    /// x264's default of 23; ~18 is visually lossless.
+    /// x264's default of 23; ~18 is visually lossless. x264 only — ignored
+    /// (with a log line) by the VideoToolbox encoders.
     pub crf: Option<u8>,
     /// x264 speed/compression preset (`ultrafast` .. `veryslow`). Slower
     /// presets compress better at the same quality. `None` uses `medium`.
     pub preset: Option<String>,
+    /// Target bitrate in bits per second. VideoToolbox only; `None` picks
+    /// ~0.1 bits/pixel/frame from the resolution and fps.
+    pub bitrate: Option<u64>,
 }
 
 impl VideoRecorderConfig {
@@ -56,10 +132,12 @@ impl VideoRecorderConfig {
             height,
             fps,
             pixel_format: RecorderPixelFormat::Rgba8,
+            codec: RecorderCodec::default(),
             realtime: false,
             keyframe_interval: None,
             crf: None,
             preset: None,
+            bitrate: None,
         }
     }
 
@@ -68,6 +146,11 @@ impl VideoRecorderConfig {
         self
     }
 
+    pub fn with_codec(mut self, codec: RecorderCodec) -> Self {
+        self.codec = codec;
+        self
+    }
+
     pub fn with_realtime(mut self, realtime: bool) -> Self {
         self.realtime = realtime;
         self
@@ -87,18 +170,38 @@ impl VideoRecorderConfig {
         self.preset = Some(preset.into());
         self
     }
+
+    pub fn with_bitrate(mut self, bits_per_second: u64) -> Self {
+        self.bitrate = Some(bits_per_second);
+        self
+    }
+
+    /// Default VideoToolbox bitrate: ~0.1 bits per pixel per frame, clamped
+    /// to a sane range. 3840×4320@60 ≈ 100 Mbps, 7680×4320@60 ≈ 200 Mbps.
+    fn auto_bitrate(&self) -> u64 {
+        let bps = self.width as f64 * self.height as f64 * self.fps * 0.1;
+        (bps as u64).clamp(5_000_000, 800_000_000)
+    }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum VideoRecordError {
     #[error("invalid recorder config: {0}")]
     InvalidConfig(String),
-    #[error("failed to create encoder: {0}")]
-    Create(video_rs::Error),
+    #[error("encoder {name} is not available in the linked ffmpeg ({hint})")]
+    CodecUnavailable { name: String, hint: String },
+    #[error("failed to create {name} encoder at {width}x{height}: {source}{hint}")]
+    Create {
+        name: &'static str,
+        width: u32,
+        height: u32,
+        source: ffmpeg::Error,
+        hint: &'static str,
+    },
     #[error("failed to encode frame {frame}: {source}")]
-    Encode { frame: u64, source: video_rs::Error },
+    Encode { frame: u64, source: ffmpeg::Error },
     #[error("failed to finalize video: {0}")]
-    Finish(video_rs::Error),
+    Finish(ffmpeg::Error),
     #[error("frame has {got} bytes but {expected} were expected ({width}x{height} {format:?})")]
     FrameSize {
         expected: usize,
@@ -113,15 +216,253 @@ pub enum VideoRecordError {
     WorkerDied,
 }
 
-/// Encodes pixel frames into a video file (H.264; container chosen by the path
-/// extension). Dropping without [`finish`](Self::finish) finalizes best-effort
-/// and swallows errors.
+/// The actual ffmpeg encode + mux pipeline: codec-selectable, unlike
+/// video-rs's `Encoder` (which hardcodes libx264).
+struct FrameEncoder {
+    output: ffmpeg::format::context::Output,
+    encoder: ffmpeg::codec::encoder::video::Encoder,
+    stream_index: usize,
+    encoder_time_base: ffmpeg::Rational,
+    scaler: Option<ffmpeg::software::scaling::Context>,
+}
+
+// The scaler wraps a raw SwsContext pointer without a Send bound. The whole
+// FrameEncoder is created on the caller thread (so creation errors surface
+// synchronously) and then moved to the encoder thread, which is its sole
+// user from then on — same justification as video-rs's own
+// `unsafe impl Send for Encoder`.
+unsafe impl Send for FrameEncoder {}
+
+impl FrameEncoder {
+    fn new(path: &Path, config: &VideoRecorderConfig) -> Result<Self, VideoRecordError> {
+        let name = config.codec.ffmpeg_name();
+        let codec = ffmpeg::encoder::find_by_name(name)
+            .or_else(|| {
+                // Fall back to any H264 encoder for the software path only.
+                match config.codec {
+                    RecorderCodec::X264 => ffmpeg::encoder::find(ffmpeg::codec::Id::H264),
+                    _ => None,
+                }
+            })
+            .ok_or_else(|| VideoRecordError::CodecUnavailable {
+                name: name.to_string(),
+                hint: if config.codec.is_videotoolbox() {
+                    "VideoToolbox encoders need an ffmpeg built on macOS".to_string()
+                } else {
+                    "ffmpeg was built without libx264".to_string()
+                },
+            })?;
+
+        let create_err = |source: ffmpeg::Error| VideoRecordError::Create {
+            name,
+            width: config.width,
+            height: config.height,
+            source,
+            hint: if config.codec == RecorderCodec::H264VideoToolbox
+                && (config.width > 4096 || config.height > 4096)
+            {
+                " (the hardware H.264 encoder rejects dimensions above 4096px — use hevc_videotoolbox)"
+            } else {
+                ""
+            },
+        };
+
+        let mut output = ffmpeg::format::output(&path).map_err(create_err)?;
+        let global_header = output
+            .format()
+            .flags()
+            .contains(ffmpeg::format::Flags::GLOBAL_HEADER);
+        let stream_index = {
+            let stream = output
+                .add_stream(codec)
+                .map_err(create_err)?;
+            stream.index()
+        };
+
+        let mut context = ffmpeg::codec::Context::new_with_codec(codec);
+        if global_header {
+            context.set_flags(ffmpeg::codec::Flags::GLOBAL_HEADER);
+        }
+        let mut video = context
+            .encoder()
+            .video()
+            .map_err(create_err)?;
+        video.set_width(config.width);
+        video.set_height(config.height);
+        video.set_format(config.codec.target_pixel(config.pixel_format));
+        video.set_time_base(TIME_BASE);
+        video.set_frame_rate(Some(ffmpeg::Rational::new(config.fps.round() as i32, 1)));
+        if let Some(interval) = config.keyframe_interval {
+            video.set_gop(interval as u32);
+        }
+
+        let mut options = HashMap::new();
+        if config.codec.is_videotoolbox() {
+            let bitrate = config.bitrate.unwrap_or_else(|| config.auto_bitrate());
+            video.set_bit_rate(bitrate as usize);
+            if config.crf.is_some() {
+                info!(
+                    "recorder: crf is x264-only, ignored by {name}; \
+                     rate is controlled by bitrate ({} Mbps)",
+                    bitrate / 1_000_000
+                );
+            }
+        } else {
+            options.insert(
+                "preset".to_string(),
+                config
+                    .preset
+                    .clone()
+                    .unwrap_or_else(|| "medium".to_string()),
+            );
+            if config.realtime {
+                options.insert("tune".to_string(), "zerolatency".to_string());
+            }
+            if let Some(crf) = config.crf {
+                options.insert("crf".to_string(), crf.to_string());
+            }
+        }
+        let dict: ffmpeg::Dictionary = options.iter().map(|(k, v)| (&**k, &**v)).collect();
+
+        let encoder = video.open_with(dict).map_err(create_err)?;
+        // The encoder may adjust its time base on open; read it back.
+        let encoder_time_base = unsafe { (*encoder.0.as_ptr()).time_base.into() };
+
+        output
+            .stream_mut(stream_index)
+            .expect("stream was just added")
+            .set_parameters(&encoder);
+        output.write_header().map_err(create_err)?;
+
+        // No scaler when the encoder takes the source format as-is (the
+        // VideoToolbox BGRA path): frames are filled directly.
+        let target = config.codec.target_pixel(config.pixel_format);
+        let scaler = if target == config.pixel_format.av_pixel() {
+            None
+        } else {
+            Some(
+                ffmpeg::software::scaling::Context::get(
+                    config.pixel_format.av_pixel(),
+                    config.width,
+                    config.height,
+                    target,
+                    config.width,
+                    config.height,
+                    ffmpeg::software::scaling::Flags::empty(),
+                )
+                .map_err(create_err)?,
+            )
+        };
+
+        Ok(Self {
+            output,
+            encoder,
+            stream_index,
+            encoder_time_base,
+            scaler,
+        })
+    }
+
+    /// Encode one frame of tightly packed pixels in the configured source
+    /// format, stamped at `frame_index / fps` seconds.
+    fn encode(
+        &mut self,
+        pixels: &[u8],
+        frame_index: u64,
+        config: &VideoRecorderConfig,
+    ) -> Result<(), ffmpeg::Error> {
+        let src_pixel = config.pixel_format.av_pixel();
+        let mut frame = match &mut self.scaler {
+            None => {
+                // Encoder consumes the source format directly.
+                let mut frame =
+                    ffmpeg::frame::Video::new(src_pixel, config.width, config.height);
+                copy_packed_rows(&mut frame, pixels, config);
+                frame
+            }
+            Some(scaler) => {
+                let mut src = ffmpeg::frame::Video::new(src_pixel, config.width, config.height);
+                copy_packed_rows(&mut src, pixels, config);
+                let mut frame = ffmpeg::frame::Video::new(
+                    config.codec.target_pixel(config.pixel_format),
+                    config.width,
+                    config.height,
+                );
+                scaler.run(&src, &mut frame)?;
+                frame
+            }
+        };
+
+        let tb = self.encoder_time_base;
+        let pts = (frame_index as f64 / config.fps * tb.denominator() as f64
+            / tb.numerator() as f64)
+            .round() as i64;
+        frame.set_pts(Some(pts));
+
+        self.encoder.send_frame(&frame)?;
+        self.drain_packets()
+    }
+
+    fn drain_packets(&mut self) -> Result<(), ffmpeg::Error> {
+        let stream_time_base = self
+            .output
+            .stream(self.stream_index)
+            .expect("output stream exists")
+            .time_base();
+        loop {
+            let mut packet = ffmpeg::Packet::empty();
+            match self.encoder.receive_packet(&mut packet) {
+                Ok(()) => {
+                    packet.set_stream(self.stream_index);
+                    packet.set_position(-1);
+                    packet.rescale_ts(self.encoder_time_base, stream_time_base);
+                    packet.write_interleaved(&mut self.output)?;
+                }
+                Err(ffmpeg::Error::Other { errno }) if errno == ffmpeg::util::error::EAGAIN => {
+                    return Ok(());
+                }
+                Err(ffmpeg::Error::Eof) => return Ok(()),
+                Err(e) => return Err(e),
+            }
+        }
+    }
+
+    /// Flush the encoder's internal lookahead and finalize the container.
+    fn finish(mut self) -> Result<(), ffmpeg::Error> {
+        self.encoder.send_eof()?;
+        self.drain_packets()?;
+        self.output.write_trailer()
+    }
+}
+
+/// Copy tightly packed rows into a (possibly padded) ffmpeg frame.
+fn copy_packed_rows(frame: &mut ffmpeg::frame::Video, pixels: &[u8], config: &VideoRecorderConfig) {
+    let width = config.width as usize;
+    let height = config.height as usize;
+    let bpp = config.pixel_format.bytes_per_pixel();
+    let src_stride = width * bpp;
+    let dst_stride = frame.stride(0);
+    let data = frame.data_mut(0);
+    if src_stride == dst_stride {
+        data[..src_stride * height].copy_from_slice(&pixels[..src_stride * height]);
+    } else {
+        for y in 0..height {
+            data[y * dst_stride..y * dst_stride + src_stride]
+                .copy_from_slice(&pixels[y * src_stride..(y + 1) * src_stride]);
+        }
+    }
+}
+
+/// Encodes pixel frames into a video file (container chosen by the path
+/// extension). Dropping without [`finish`](Self::finish) finalizes
+/// best-effort and swallows errors.
 pub struct VideoRecorder {
     frame_tx: Option<SyncSender<Vec<u8>>>,
     handle: Option<thread::JoinHandle<Result<u64, VideoRecordError>>>,
     expected_len: usize,
     config: VideoRecorderConfig,
     frames_sent: u64,
+    frames_encoded: Arc<AtomicU64>,
 }
 
 impl VideoRecorder {
@@ -155,38 +496,24 @@ impl VideoRecorder {
             let _ = video_rs::init();
         });
 
-        let mut options = HashMap::new();
-        options.insert(
-            "preset".to_string(),
-            config
-                .preset
-                .clone()
-                .unwrap_or_else(|| "medium".to_string()),
+        let encoder = FrameEncoder::new(path.as_ref(), &config)?;
+        info!(
+            "recorder: started {}x{} @ {} fps, {} → {}",
+            config.width,
+            config.height,
+            config.fps,
+            config.codec.ffmpeg_name(),
+            path.as_ref().display()
         );
-        if config.realtime {
-            options.insert("tune".to_string(), "zerolatency".to_string());
-        }
-        if let Some(crf) = config.crf {
-            options.insert("crf".to_string(), crf.to_string());
-        }
-        let mut settings = Settings::preset_h264_custom(
-            config.width as usize,
-            config.height as usize,
-            PixelFormat::YUV420P,
-            options.into(),
-        );
-        if let Some(interval) = config.keyframe_interval {
-            settings.set_keyframe_interval(interval);
-        }
-
-        let encoder = Encoder::new(path.as_ref(), settings).map_err(VideoRecordError::Create)?;
 
-        let (frame_tx, frame_rx) = sync_channel(3);
+        let (frame_tx, frame_rx) = sync_channel(QUEUE_DEPTH);
+        let frames_encoded = Arc::new(AtomicU64::new(0));
         let worker_config = config.clone();
+        let worker_encoded = Arc::clone(&frames_encoded);
         let dest = path.as_ref().to_path_buf();
         let handle = thread::Builder::new()
             .name("processing_video_encode".to_string())
-            .spawn(move || encode_main(encoder, worker_config, frame_rx, dest))
+            .spawn(move || encode_main(encoder, worker_config, frame_rx, worker_encoded, dest))
             .expect("failed to spawn video encoder thread");
 
         let expected_len =
@@ -197,11 +524,13 @@ impl VideoRecorder {
             expected_len,
             config,
             frames_sent: 0,
+            frames_encoded,
         })
     }
 
     /// Queue one frame: tightly packed rows in the configured pixel format,
-    /// top row first. Blocks while the encoder is a few frames behind.
+    /// top row first. Blocks while the encoder is [`QUEUE_DEPTH`] frames
+    /// behind — the render loop is paced by encode speed.
     pub fn record_frame(&mut self, pixels: Vec<u8>) -> Result<(), VideoRecordError> {
         if pixels.len() != self.expected_len {
             return Err(VideoRecordError::FrameSize {
@@ -246,6 +575,13 @@ impl VideoRecorder {
     }
 
     fn join_worker(&mut self) -> Result<u64, VideoRecordError> {
+        let pending = self
+            .frames_sent
+            .saturating_sub(self.frames_encoded.load(Ordering::Relaxed));
+        info!(
+            "recorder: finalizing — draining {pending} queued frames, \
+             then flushing the encoder"
+        );
         // Closing the channel signals the worker to flush and finish.
         drop(self.frame_tx.take());
         match self.handle.take() {
@@ -264,30 +600,26 @@ impl Drop for VideoRecorder {
 }
 
 fn encode_main(
-    mut encoder: Encoder,
+    mut encoder: FrameEncoder,
     config: VideoRecorderConfig,
     frame_rx: Receiver<Vec<u8>>,
+    frames_encoded: Arc<AtomicU64>,
     dest: PathBuf,
 ) -> Result<u64, VideoRecordError> {
-    let time_base = encoder.time_base();
     let mut frame_index: u64 = 0;
 
     while let Ok(pixels) = frame_rx.recv() {
-        let mut frame = RawFrame::new(PixelFormat::RGB24, config.width, config.height);
-        fill_rgb24(&mut frame, &pixels, &config);
-
-        let pts = Time::from_secs_f64(frame_index as f64 / config.fps)
-            .with_time_base(time_base)
-            .into_value();
-        frame.set_pts(pts);
-
         encoder
-            .encode_raw(frame)
+            .encode(&pixels, frame_index, &config)
             .map_err(|source| VideoRecordError::Encode {
                 frame: frame_index,
                 source,
             })?;
         frame_index += 1;
+        frames_encoded.store(frame_index, Ordering::Relaxed);
+        if frame_index % 300 == 0 {
+            info!("recorder: {frame_index} frames encoded");
+        }
     }
 
     if frame_index == 0 {
@@ -296,35 +628,11 @@ fn encode_main(
         return Err(VideoRecordError::NoFrames);
     }
 
+    info!("recorder: queue drained, flushing encoder ({frame_index} frames)");
     encoder.finish().map_err(VideoRecordError::Finish)?;
+    info!(
+        "recorder: wrote {frame_index} frames to {}",
+        dest.display()
+    );
     Ok(frame_index)
 }
-
-fn fill_rgb24(frame: &mut RawFrame, pixels: &[u8], config: &VideoRecorderConfig) {
-    let width = config.width as usize;
-    let height = config.height as usize;
-    let bpp = config.pixel_format.bytes_per_pixel();
-    let src_stride = width * bpp;
-    let dst_stride = frame.stride(0);
-    let data = frame.data_mut(0);
-
-    for y in 0..height {
-        let src_row = &pixels[y * src_stride..(y + 1) * src_stride];
-        let dst_row = &mut data[y * dst_stride..y * dst_stride + width * 3];
-        match config.pixel_format {
-            RecorderPixelFormat::Rgb8 => dst_row.copy_from_slice(src_row),
-            RecorderPixelFormat::Rgba8 => {
-                for (dst, src) in dst_row.chunks_exact_mut(3).zip(src_row.chunks_exact(4)) {
-                    dst.copy_from_slice(&src[..3]);
-                }
-            }
-            RecorderPixelFormat::Bgra8 => {
-                for (dst, src) in dst_row.chunks_exact_mut(3).zip(src_row.chunks_exact(4)) {
-                    dst[0] = src[2];
-                    dst[1] = src[1];
-                    dst[2] = src[0];
-                }
-            }
-        }
-    }
-}
diff --git a/crates/processing_video/tests/record.rs b/crates/processing_video/tests/record.rs
index df2e18c4..1f6309c1 100644
--- a/crates/processing_video/tests/record.rs
+++ b/crates/processing_video/tests/record.rs
@@ -96,3 +96,120 @@ fn crf_controls_output_size() {
         sizes[1]
     );
 }
+
+/// VideoToolbox hardware encode: macOS-only, so gate on the codec actually
+/// being present in the linked ffmpeg rather than on the platform.
+#[test]
+fn videotoolbox_roundtrip() {
+    use processing_video::RecorderCodec;
+
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("out_vt.mp4");
+
+    let config = VideoRecorderConfig::new(WIDTH, HEIGHT, FPS)
+        .with_codec(RecorderCodec::H264VideoToolbox)
+        .with_bitrate(2_000_000);
+    let mut recorder = match VideoRecorder::new(&path, config) {
+        Ok(r) => r,
+        Err(processing_video::VideoRecordError::CodecUnavailable { .. }) => {
+            eprintln!("h264_videotoolbox not available; skipping");
+            return;
+        }
+        Err(e) => panic!("recorder create failed: {e}"),
+    };
+    for i in 0..FRAMES {
+        recorder.record_frame(gradient_frame(i)).unwrap();
+    }
+    assert_eq!(recorder.finish().unwrap(), FRAMES);
+
+    let mut decoder = video_rs::Decoder::new(path.as_path()).unwrap();
+    assert_eq!(decoder.size(), (WIDTH, HEIGHT));
+    let mut decoded = 0u64;
+    loop {
+        match decoder.decode_raw() {
+            Ok(_) => decoded += 1,
+            Err(video_rs::Error::DecodeExhausted | video_rs::Error::ReadExhausted) => break,
+            Err(e) => panic!("decode error after {decoded} frames: {e}"),
+        }
+    }
+    assert_eq!(decoded, FRAMES);
+}
+
+/// Hardware-encoder session creation at Deep Space delivery resolutions.
+/// Apple's hardware H.264 encoder rejects dimensions above 4096px (session
+/// error -12903), which includes the 3840x4320 per-surface files — those are
+/// allowed to fail with a Create error. HEVC must work at both delivery
+/// sizes.
+#[test]
+fn videotoolbox_delivery_resolutions() {
+    use processing_video::{RecorderCodec, VideoRecordError};
+
+    let dir = tempfile::tempdir().unwrap();
+    let cases = [
+        (RecorderCodec::H264VideoToolbox, 3840u32, 4320u32),
+        (RecorderCodec::HevcVideoToolbox, 3840, 4320),
+        (RecorderCodec::HevcVideoToolbox, 7680, 4320),
+    ];
+    for (i, (codec, w, h)) in cases.into_iter().enumerate() {
+        let path = dir.path().join(format!("delivery_{i}.mp4"));
+        let config = VideoRecorderConfig::new(w, h, 60.0).with_codec(codec);
+        let mut recorder = match VideoRecorder::new(&path, config) {
+            Ok(r) => r,
+            Err(VideoRecordError::CodecUnavailable { .. }) => {
+                eprintln!("{codec:?} not available; skipping");
+                continue;
+            }
+            Err(e @ VideoRecordError::Create { .. })
+                if codec == RecorderCodec::H264VideoToolbox =>
+            {
+                // Hardware-dependent: Apple's H.264 encoder caps at 4096px.
+                eprintln!("{codec:?} at {w}x{h}: {e}");
+                continue;
+            }
+            Err(e) => panic!("{codec:?} at {w}x{h}: {e}"),
+        };
+        let frame = vec![128u8; w as usize * h as usize * 4];
+        for _ in 0..3 {
+            recorder.record_frame(frame.clone()).unwrap();
+        }
+        assert_eq!(recorder.finish().unwrap(), 3, "{codec:?} at {w}x{h}");
+    }
+}
+
+/// The VideoToolbox BGRA fast path (no swscale — hardware colorspace
+/// conversion) must produce a decodable file like the NV12 path.
+#[test]
+fn videotoolbox_bgra_direct_roundtrip() {
+    use processing_video::{RecorderCodec, RecorderPixelFormat};
+
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("out_bgra.mp4");
+    let config = VideoRecorderConfig::new(WIDTH, HEIGHT, FPS)
+        .with_codec(RecorderCodec::H264VideoToolbox)
+        .with_pixel_format(RecorderPixelFormat::Bgra8)
+        .with_bitrate(2_000_000);
+    let mut recorder = match VideoRecorder::new(&path, config) {
+        Ok(r) => r,
+        Err(processing_video::VideoRecordError::CodecUnavailable { .. }) => {
+            eprintln!("h264_videotoolbox not available; skipping");
+            return;
+        }
+        Err(e) => panic!("recorder create failed: {e}"),
+    };
+    for i in 0..FRAMES {
+        recorder.record_frame(gradient_frame(i)).unwrap(); // bytes reinterpreted as BGRA — fine for a roundtrip
+    }
+    assert_eq!(recorder.finish().unwrap(), FRAMES);
+
+    let mut decoder = video_rs::Decoder::new(path.as_path()).unwrap();
+    assert_eq!(decoder.size(), (WIDTH, HEIGHT));
+    let mut decoded = 0u64;
+    loop {
+        match decoder.decode_raw() {
+            Ok(_) => decoded += 1,
+            Err(video_rs::Error::DecodeExhausted | video_rs::Error::ReadExhausted) => break,
+            Err(e) => panic!("decode error after {decoded} frames: {e}"),
+        }
+    }
+    assert_eq!(decoded, FRAMES);
+}

From db0d107d7305632a3dd4e898bb2f0ef630917cf6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?charlotte=20=F0=9F=8C=B8?= <charlotte.c.mcelwain@gmail.com>
Date: Tue, 8 Sep 2026 18:40:49 -0700
Subject: [PATCH 14/14] .

---
 Cargo.lock                                    | 581 ++++++++++++-
 Cargo.toml                                    |   8 +-
 crates/processing_ffi/Cargo.toml              |   4 +-
 crates/processing_ffi/build.rs                |   6 +-
 crates/processing_ffi/src/canvas.rs           | 179 ++++
 crates/processing_ffi/src/lib.rs              | 248 ++++++
 crates/processing_ffi/src/physics.rs          | 291 +++++++
 crates/processing_ffi/src/texture3d.rs        | 133 +++
 crates/processing_ffi/src/video.rs            |  77 +-
 crates/processing_ffi/src/video_macos.rs      | 134 +++
 crates/processing_glfw/src/lib.rs             |   7 +-
 crates/processing_input/src/lib.rs            |  13 +-
 crates/processing_physics/Cargo.toml          |  19 +
 crates/processing_physics/src/lib.rs          | 480 +++++++++++
 crates/processing_pyo3/src/material.rs        |   1 +
 crates/processing_render/Cargo.toml           |   2 +
 crates/processing_render/src/animation.rs     | 163 ++++
 crates/processing_render/src/capture_macos.rs | 197 +++++
 crates/processing_render/src/compute.rs       |  18 +
 crates/processing_render/src/gltf.rs          |  59 ++
 crates/processing_render/src/graphics.rs      | 774 +++++++++++++++---
 crates/processing_render/src/image.rs         | 191 +++++
 crates/processing_render/src/lib.rs           | 373 ++++++++-
 crates/processing_render/src/light.rs         |  93 ++-
 .../processing_render/src/material/custom.rs  |  51 ++
 crates/processing_render/src/material/mod.rs  |  49 ++
 .../src/particles/material.rs                 |  15 -
 crates/processing_render/src/particles/mod.rs |  33 +-
 .../processing_render/src/particles/pack.rs   | 114 ++-
 .../processing_render/src/particles/pack.wgsl |  18 +-
 .../src/particles/point.wgsl                  |  14 +-
 .../src/particles/point_render.rs             |  18 +-
 .../processing_render/src/particles/prims.rs  |  26 +
 crates/processing_render/src/render/filter.rs |   1 +
 .../processing_render/src/render/material.rs  |  40 +-
 crates/processing_render/src/render/mod.rs    | 153 +++-
 .../src/render/primitive/mod.rs               |   4 +-
 .../src/render/primitive/shape3d.rs           |  10 +-
 crates/processing_render/src/surface.rs       |  68 +-
 crates/processing_video/Cargo.toml            |  14 +
 crates/processing_video/src/lib.rs            |   4 +
 crates/processing_video/src/macos.rs          | 660 +++++++++++++++
 crates/processing_video/src/record.rs         |  28 +-
 src/lib.rs                                    |   3 +
 44 files changed, 5142 insertions(+), 232 deletions(-)
 create mode 100644 crates/processing_ffi/src/canvas.rs
 create mode 100644 crates/processing_ffi/src/physics.rs
 create mode 100644 crates/processing_ffi/src/texture3d.rs
 create mode 100644 crates/processing_ffi/src/video_macos.rs
 create mode 100644 crates/processing_physics/Cargo.toml
 create mode 100644 crates/processing_physics/src/lib.rs
 create mode 100644 crates/processing_render/src/animation.rs
 create mode 100644 crates/processing_render/src/capture_macos.rs
 create mode 100644 crates/processing_video/src/macos.rs

diff --git a/Cargo.lock b/Cargo.lock
index 9c471d42..42fe8b02 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -208,6 +208,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
 [[package]]
 name = "annotate-snippets"
 version = "0.12.16"
@@ -255,7 +261,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -266,7 +272,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -290,6 +296,12 @@ version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 
+[[package]]
+name = "arbitrary-chunks"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ad8689a486416c401ea15715a4694de30054248ec627edbf31f49cb64ee4086"
+
 [[package]]
 name = "arg_enum_proc_macro"
 version = "0.3.4"
@@ -503,6 +515,39 @@ dependencies = [
  "v_frame",
 ]
 
+[[package]]
+name = "avian3d"
+version = "0.8.0-dev"
+dependencies = [
+ "approx",
+ "avian_derive",
+ "bevy",
+ "bevy_heavy",
+ "bevy_math",
+ "bevy_transform_interpolation",
+ "bitflags 2.13.1",
+ "derive_more",
+ "disqualified",
+ "glam_matrix_extras",
+ "itertools 0.15.0",
+ "obvhs",
+ "parry3d",
+ "parry3d-f64",
+ "smallvec",
+ "thiserror 2.0.20",
+ "thread_local",
+]
+
+[[package]]
+name = "avian_derive"
+version = "0.2.3"
+dependencies = [
+ "proc-macro-error3",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "avif-serialize"
 version = "0.8.9"
@@ -1049,6 +1094,15 @@ dependencies = [
  "wgpu-types 30.0.0",
 ]
 
+[[package]]
+name = "bevy_heavy"
+version = "0.6.0-dev"
+dependencies = [
+ "bevy_math",
+ "bevy_reflect",
+ "glam_matrix_extras",
+]
+
 [[package]]
 name = "bevy_image"
 version = "0.20.0-dev"
@@ -1384,7 +1438,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-time",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1657,7 +1711,7 @@ dependencies = [
  "crossbeam-queue",
  "derive_more",
  "futures-lite",
- "heapless",
+ "heapless 0.9.3",
  "web-task",
 ]
 
@@ -1716,6 +1770,13 @@ dependencies = [
  "thiserror 2.0.20",
 ]
 
+[[package]]
+name = "bevy_transform_interpolation"
+version = "0.6.0-dev"
+dependencies = [
+ "bevy",
+]
+
 [[package]]
 name = "bevy_ui"
 version = "0.20.0-dev"
@@ -2025,6 +2086,16 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-pseudorand"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2097358495d244a0643746f4d13eedba4608137008cf9dec54e53a3b700115a6"
+dependencies = [
+ "chiapos-chacha8",
+ "nanorand 0.6.1",
+]
+
 [[package]]
 name = "block2"
 version = "0.5.1"
@@ -2132,6 +2203,12 @@ dependencies = [
  "wayland-client",
 ]
 
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
 [[package]]
 name = "cbindgen"
 version = "0.29.4"
@@ -2207,6 +2284,42 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
+[[package]]
+name = "chiapos-chacha8"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33f8be573a85f6c2bc1b8e43834c07e32f95e489b914bf856c0549c3c269cd0a"
+dependencies = [
+ "rayon",
+]
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.9.1"
@@ -2576,6 +2689,42 @@ dependencies = [
  "cfg-if 1.0.4",
 ]
 
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools 0.10.5",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools 0.10.5",
+]
+
 [[package]]
 name = "critical-section"
 version = "1.2.0"
@@ -2879,7 +3028,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3019,7 +3168,7 @@ checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
 dependencies = [
  "futures-core",
  "futures-sink",
- "nanorand",
+ "nanorand 0.7.0",
  "spin 0.9.9",
 ]
 
@@ -3335,7 +3484,7 @@ dependencies = [
  "vec_map",
  "wasm-bindgen",
  "web-sys",
- "windows 0.58.0",
+ "windows 0.62.2",
 ]
 
 [[package]]
@@ -3355,6 +3504,7 @@ version = "0.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7360bd2cd76e0cd9032d42cf2922155cecea2685b0cfa4630c3246df030bcfd6"
 dependencies = [
+ "approx",
  "bytemuck",
  "encase",
  "libm",
@@ -3362,6 +3512,26 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "glam_matrix_extras"
+version = "0.4.0-dev"
+dependencies = [
+ "bevy_reflect",
+ "glam",
+]
+
+[[package]]
+name = "glamx"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9847f980afb0628849bcd6a406cdffd29eb9d53fca83e1646005901a9acd4c5c"
+dependencies = [
+ "approx",
+ "glam",
+ "num-traits",
+ "simba",
+]
+
 [[package]]
 name = "glfw"
 version = "0.60.0"
@@ -3481,7 +3651,7 @@ dependencies = [
  "log",
  "presser",
  "thiserror 2.0.20",
- "windows 0.58.0",
+ "windows 0.62.2",
 ]
 
 [[package]]
@@ -3598,6 +3768,16 @@ dependencies = [
  "foldhash 0.2.0",
 ]
 
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "heapless"
 version = "0.9.3"
@@ -3894,12 +4074,32 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "is-terminal"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -3918,6 +4118,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -4644,6 +4853,12 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "nanorand"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "729eb334247daa1803e0a094d0a5c55711b85571179f5ec6e53eccfdf7008958"
+
 [[package]]
 name = "nanorand"
 version = "0.7.0"
@@ -4879,7 +5094,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5062,6 +5277,29 @@ dependencies = [
  "objc2-foundation 0.3.2",
 ]
 
+[[package]]
+name = "objc2-av-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "478ae33fcac9df0a18db8302387c666b8ef08a3e2d62b510ca4fc278a384b6c0"
+dependencies = [
+ "bitflags 2.13.1",
+ "block2 0.6.2",
+ "dispatch2",
+ "objc2 0.6.4",
+ "objc2-avf-audio",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image 0.3.2",
+ "objc2-core-media",
+ "objc2-core-video",
+ "objc2-foundation 0.3.2",
+ "objc2-image-io",
+ "objc2-media-toolbox",
+ "objc2-quartz-core 0.3.2",
+]
+
 [[package]]
 name = "objc2-avf-audio"
 version = "0.3.2"
@@ -5213,6 +5451,22 @@ dependencies = [
  "objc2-foundation 0.2.2",
 ]
 
+[[package]]
+name = "objc2-core-media"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05ec576860167a15dd9fce7fbee7512beb4e31f532159d3482d1f9c6caedf31d"
+dependencies = [
+ "bitflags 2.13.1",
+ "block2 0.6.2",
+ "dispatch2",
+ "objc2 0.6.4",
+ "objc2-core-audio",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-core-video",
+]
+
 [[package]]
 name = "objc2-core-text"
 version = "0.3.2"
@@ -5232,10 +5486,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6"
 dependencies = [
  "bitflags 2.13.1",
+ "block2 0.6.2",
  "objc2 0.6.4",
  "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-io-surface",
+ "objc2-metal 0.3.2",
 ]
 
 [[package]]
@@ -5270,6 +5526,17 @@ dependencies = [
  "objc2-core-foundation",
 ]
 
+[[package]]
+name = "objc2-image-io"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32b0446e98cf4a784cc7a0177715ff317eeaa8463841c616cfc78aa4f953c4ea"
+dependencies = [
+ "objc2 0.6.4",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
 [[package]]
 name = "objc2-io-kit"
 version = "0.3.2"
@@ -5288,8 +5555,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
 dependencies = [
  "bitflags 2.13.1",
+ "libc",
  "objc2 0.6.4",
  "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
 ]
 
 [[package]]
@@ -5304,6 +5573,18 @@ dependencies = [
  "objc2-foundation 0.2.2",
 ]
 
+[[package]]
+name = "objc2-media-toolbox"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd9fdde720df3da7046bb9097811000c1e7ab5cd579fa89d96b27d56781fb30"
+dependencies = [
+ "objc2 0.6.4",
+ "objc2-core-audio-types",
+ "objc2-core-foundation",
+ "objc2-core-media",
+]
+
 [[package]]
 name = "objc2-metal"
 version = "0.2.2"
@@ -5324,8 +5605,11 @@ checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794"
 dependencies = [
  "bitflags 2.13.1",
  "block2 0.6.2",
+ "dispatch2",
  "objc2 0.6.4",
+ "objc2-core-foundation",
  "objc2-foundation 0.3.2",
+ "objc2-io-surface",
 ]
 
 [[package]]
@@ -5419,6 +5703,20 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "obvhs"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf590a9310ba69b2340562d39f0c9bddd3677130bfd24a5df22941552e791bac"
+dependencies = [
+ "bytemuck",
+ "glam",
+ "half",
+ "log",
+ "rdst",
+ "static_assertions",
+]
+
 [[package]]
 name = "offset-allocator"
 version = "0.2.0"
@@ -5450,6 +5748,12 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
 [[package]]
 name = "orbclient"
 version = "0.3.55"
@@ -5554,6 +5858,69 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "parry3d"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15fa77de549af010eddaf4bcb365b39aee96f93f65489b9a49b2de616fc664e8"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bitflags 2.13.1",
+ "downcast-rs 2.0.2",
+ "either",
+ "ena",
+ "foldhash 0.2.0",
+ "glamx",
+ "hashbrown 0.17.1",
+ "log",
+ "num-derive",
+ "num-traits",
+ "ordered-float",
+ "rayon",
+ "rstar",
+ "simba",
+ "slab",
+ "smallvec",
+ "spade",
+ "static_assertions",
+ "thiserror 2.0.20",
+]
+
+[[package]]
+name = "parry3d-f64"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd4914d128fa7236407b1d12fcdc689f7dc7010faae7ab4272c509c8b937c1cb"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bitflags 2.13.1",
+ "downcast-rs 2.0.2",
+ "either",
+ "ena",
+ "foldhash 0.2.0",
+ "glamx",
+ "hashbrown 0.17.1",
+ "log",
+ "num-derive",
+ "num-traits",
+ "ordered-float",
+ "rayon",
+ "rstar",
+ "simba",
+ "slab",
+ "smallvec",
+ "spade",
+ "thiserror 2.0.20",
+]
+
+[[package]]
+name = "partition"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "947f833aaa585cf12b8ec7c0476c98784c49f33b861376ffc84ed92adebf2aba"
+
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -5659,6 +6026,34 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
 [[package]]
 name = "png"
 version = "0.18.1"
@@ -5761,6 +6156,28 @@ dependencies = [
  "toml_edit",
 ]
 
+[[package]]
+name = "proc-macro-error-attr3"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0084e6206a967a2dad822180626b2f6b07a3b379325e8f1ec0438e33a469ba7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error3"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cf066225f2373bc711684792b69bdeac0356019b007e721090c24d92d5d5a50"
+dependencies = [
+ "proc-macro-error-attr3",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
@@ -5780,6 +6197,7 @@ dependencies = [
  "processing_cuda",
  "processing_glfw",
  "processing_input",
+ "processing_physics",
  "processing_render",
  "processing_video",
  "processing_webcam",
@@ -5818,6 +6236,7 @@ dependencies = [
  "cbindgen",
  "half",
  "processing",
+ "processing_physics",
  "processing_video",
 ]
 
@@ -5841,6 +6260,17 @@ dependencies = [
  "processing_core",
 ]
 
+[[package]]
+name = "processing_physics"
+version = "0.0.1"
+dependencies = [
+ "avian3d",
+ "bevy",
+ "processing_core",
+ "processing_render",
+ "thiserror 2.0.20",
+]
+
 [[package]]
 name = "processing_pyo3"
 version = "0.0.8"
@@ -5873,6 +6303,8 @@ dependencies = [
  "notosans",
  "objc2 0.6.4",
  "objc2-app-kit 0.3.2",
+ "objc2-io-surface",
+ "objc2-metal 0.3.2",
  "parley 0.7.0",
  "processing_core",
  "raw-window-handle",
@@ -5890,7 +6322,15 @@ name = "processing_video"
 version = "0.0.1"
 dependencies = [
  "bevy",
+ "block2 0.6.2",
  "nannou_video",
+ "objc2 0.6.4",
+ "objc2-av-foundation",
+ "objc2-core-foundation",
+ "objc2-core-media",
+ "objc2-core-video",
+ "objc2-foundation 0.3.2",
+ "objc2-io-surface",
  "processing_core",
  "processing_render",
  "tempfile",
@@ -6246,6 +6686,20 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "rdst"
+version = "0.20.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e7970b4e577b76a96d5e56b5f6662b66d1a4e1f5bb026ee118fc31b373c2752"
+dependencies = [
+ "arbitrary-chunks",
+ "block-pseudorand",
+ "criterion",
+ "partition",
+ "tikv-jemallocator",
+ "voracious_radix_sort",
+]
+
 [[package]]
 name = "read-fonts"
 version = "0.35.0"
@@ -6351,6 +6805,12 @@ dependencies = [
  "bytemuck",
 ]
 
+[[package]]
+name = "robust"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e27ee8bb91ca0adcf0ecb116293afa12d393f9c2b9b9cd54d33e8078fe19839"
+
 [[package]]
 name = "rodio"
 version = "0.22.2"
@@ -6388,6 +6848,17 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "rstar"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5912b862fa5ffb462607bfd1e35036c458c537921f508c8235a83d5f3987edfe"
+dependencies = [
+ "heapless 0.8.0",
+ "num-traits",
+ "smallvec",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -6432,7 +6903,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6450,6 +6921,15 @@ dependencies = [
  "twox-hash",
 ]
 
+[[package]]
+name = "safe_arch"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42c6efa15875e6ecb39ca61fb0b0c1a40b84fac5a5ffe71eef7d1000c8eb3f5f"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -6599,6 +7079,18 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
+[[package]]
+name = "simba"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1a7200d82ff1c7b4235efd12f11e2537a402c91cf83a5cb97ce80eef787fde7"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "wide",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.10"
@@ -6711,6 +7203,18 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "spade"
+version = "2.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9699399fd9349b00b184f5635b074f9ec93afffef30c853f8c875b32c0f8c7fa"
+dependencies = [
+ "hashbrown 0.16.1",
+ "num-traits",
+ "robust",
+ "smallvec",
+]
+
 [[package]]
 name = "spin"
 version = "0.9.9"
@@ -6789,7 +7293,7 @@ version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e"
 dependencies = [
- "skrifa 0.37.0",
+ "skrifa 0.43.2",
  "yazi",
  "zeno",
 ]
@@ -6878,7 +7382,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6887,7 +7391,7 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8c27177b12a6399ffc08b98f76f7c9a1f4fe9fc967c784c5a071fa8d93cf7e1"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6962,6 +7466,26 @@ dependencies = [
  "zune-jpeg",
 ]
 
+[[package]]
+name = "tikv-jemalloc-sys"
+version = "0.5.4+5.3.0-patched"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9402443cb8fd499b6f327e40565234ff34dbda27460c5b47db0db77443dd85d1"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "tikv-jemallocator"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "965fe0c26be5c56c94e38ba547249074803efd52adfb66de62107d95aab3eaca"
+dependencies = [
+ "libc",
+ "tikv-jemalloc-sys",
+]
+
 [[package]]
 name = "tiny-skia"
 version = "0.11.4"
@@ -6998,6 +7522,16 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.12.0"
@@ -7334,6 +7868,15 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "voracious_radix_sort"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446e7ffcb6c27a71d05af7e51ef2ee5b71c48424b122a832f2439651e1914899"
+dependencies = [
+ "rayon",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -8003,6 +8546,16 @@ dependencies = [
  "rustix 0.38.44",
 ]
 
+[[package]]
+name = "wide"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de2aaf408e58689c2096682331b1f42bb2d9f2ed6b11560407d023cd0a6c634e"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -8025,7 +8578,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 70a72e76..efcaed04 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,7 @@ wayland = ["processing_render/wayland"]
 x11 = ["processing_render/x11"]
 webcam = ["dep:processing_webcam"]
 video = ["dep:processing_video"]
+physics = ["dep:processing_physics"]
 cuda = ["dep:processing_cuda", "processing_cuda/cuda"]
 
 [workspace]
@@ -59,7 +60,10 @@ bevy = { path = "/Users/char/src/github.com/bevyengine/bevy-tib-rebase", default
 bevy_naga_reflect = { path = "/Users/char/src/github.com/tychedelia/bevy_naga_reflect-020" }
 bevy_cuda = { git = "https://github.com/tychedelia/bevy_cuda" }
 naga = { version = "29", features = ["wgsl-in"] }
-wesl = { version = "0.3", default-features = false }
+# naga-ext: accept naga's storage-texture format extensions (r16float etc.)
+# beyond the base WGSL list — voxel T-field kernels write
+# texture_storage_3d<r16float, write>.
+wesl = { version = "0.3", default-features = false, features = ["naga-ext"] }
 pyo3 = { git = "https://github.com/PyO3/pyo3", branch = "main" }
 pyo3-introspection = { git = "https://github.com/PyO3/pyo3", branch = "main" }
 processing = { path = "." }
@@ -72,6 +76,7 @@ processing_render = { path = "crates/processing_render" }
 # processing_audio = { path = "crates/processing_audio" }
 processing_input = { path = "crates/processing_input" }
 processing_glfw = { path = "crates/processing_glfw" }
+processing_physics = { path = "crates/processing_physics" }
 processing_video = { path = "crates/processing_video" }
 processing_webcam = { path = "crates/processing_webcam" }
 rand = "0.10"
@@ -85,6 +90,7 @@ processing_render = { workspace = true }
 # processing_midi = { workspace = true }
 # processing_audio = { workspace = true }
 processing_input = { workspace = true }
+processing_physics = { workspace = true, optional = true }
 processing_video = { workspace = true, optional = true }
 processing_webcam = { workspace = true, optional = true }
 processing_cuda = { workspace = true, optional = true }
diff --git a/crates/processing_ffi/Cargo.toml b/crates/processing_ffi/Cargo.toml
index 8efc0f9d..fa04f09b 100644
--- a/crates/processing_ffi/Cargo.toml
+++ b/crates/processing_ffi/Cargo.toml
@@ -11,15 +11,17 @@ name = "processing"
 crate-type = ["cdylib", "staticlib"]
 
 [features]
-default = ["video"]
+default = ["video", "physics"]
 wayland = ["processing/wayland"]
 x11 = ["processing/x11"]
 webcam = ["processing/webcam"]
 cuda = ["processing/cuda"]
 video = ["processing/video", "dep:processing_video"]
+physics = ["processing/physics", "dep:processing_physics"]
 
 [dependencies]
 processing = { workspace = true }
+processing_physics = { workspace = true, optional = true }
 processing_video = { workspace = true, optional = true }
 bevy = { workspace = true }
 half = "2.7"
diff --git a/crates/processing_ffi/build.rs b/crates/processing_ffi/build.rs
index e94d8186..14aa12eb 100644
--- a/crates/processing_ffi/build.rs
+++ b/crates/processing_ffi/build.rs
@@ -18,7 +18,11 @@ fn main() {
         .expect("Unable to generate bindings")
         .write_to_file(&output_file);
 
-    println!("cargo:rerun-if-changed=src/lib.rs");
+    // The whole source tree, not just lib.rs: exports live in modules
+    // (video.rs, canvas.rs, ...) too, and naming only lib.rs meant a new or
+    // changed export in any of them left a stale header behind -- which shows
+    // up much later as a jextract binding that does not match the library.
+    println!("cargo:rerun-if-changed=src");
     println!("cargo:rerun-if-changed=cbindgen.toml");
     println!(
         "cargo:warning=Generated header at: {}",
diff --git a/crates/processing_ffi/src/canvas.rs b/crates/processing_ffi/src/canvas.rs
new file mode 100644
index 00000000..e0a37d9d
--- /dev/null
+++ b/crates/processing_ffi/src/canvas.rs
@@ -0,0 +1,179 @@
+//! Offscreen canvases, state (accumulator) canvases, and canvas compositing.
+//!
+//! A **state canvas** is the feedback/simulation counterpart to a picture
+//! canvas: float format, no bloom, no tonemapping, and LINEAR color writes.
+//! Post-processing writes back through the view target, so on a canvas whose
+//! pixels are data (a reaction-diffusion field, an accumulator) it silently
+//! re-transforms the state every frame; and sRGB color resolution means
+//! `fill(0.5)` would store 0.21. Both are fatal for patch-style work and both
+//! are off by construction here.
+
+use bevy::prelude::Entity;
+use bevy::render::render_resource::TextureFormat;
+use processing::prelude::{
+    filter_composite, filter_feedback, filter_set, graphics_apply_filter, graphics_create_ex,
+    graphics_flush, shader_value::ShaderValue, surface_create_offscreen,
+};
+
+use crate::error;
+
+/// Composite mode: REPLACE — Processing's `copy()` (filters/composite.wgsl).
+pub const COMPOSITE_MODE_REPLACE: u32 = 9;
+/// Composite mode: MASK — Processing's `mask()`.
+pub const COMPOSITE_MODE_MASK: u32 = 10;
+
+fn texture_format(hdr: bool) -> TextureFormat {
+    if hdr {
+        TextureFormat::Rgba16Float
+    } else {
+        TextureFormat::Rgba8UnormSrgb
+    }
+}
+
+/// Create an offscreen render surface (an image-backed target, no window).
+/// Pair with `processing_graphics_create_ex` to get a drawable canvas.
+/// Returns the surface entity id, or 0 on error.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - Called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_surface_create_offscreen(
+    width: u32,
+    height: u32,
+    scale_factor: f32,
+    hdr: bool,
+) -> u64 {
+    error::clear_error();
+    error::check(|| surface_create_offscreen(width, height, scale_factor, texture_format(hdr)))
+        .map(|e| e.to_bits())
+        .unwrap_or(0)
+}
+
+/// Create a graphics context with explicit format and state semantics.
+///
+/// `hdr`: float (Rgba16Float) vs Rgba8UnormSrgb target.
+/// `state`: when true the canvas is a STATE canvas — post-process-free
+/// (bloom/tonemapping never applied, and `bloom()` on it is ignored with a
+/// warning) and linear-color, so drawn values round-trip exactly.
+/// Returns the graphics entity id, or 0 on error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_graphics_create_ex(
+    surface_id: u64,
+    width: u32,
+    height: u32,
+    hdr: bool,
+    state: bool,
+) -> u64 {
+    error::clear_error();
+    let surface_entity = Entity::from_bits(surface_id);
+    error::check(|| {
+        graphics_create_ex(
+            surface_entity,
+            width,
+            height,
+            texture_format(hdr),
+            state,
+        )
+    })
+    .map(|e| e.to_bits())
+    .unwrap_or(0)
+}
+
+/// Composite a texture-bearing source onto a graphics target through the
+/// built-in composite filter — the way to get an offscreen buffer onto the
+/// main canvas.
+///
+/// `src_id` is the texture entity: an image, or an offscreen graphics'
+/// SURFACE entity. `src_graphics_id` is that graphics (or 0), flushed first so
+/// the latest content is what gets sampled. `src_rect`/`dst_rect` are uv-space
+/// `[x0, y0, x1, y1]`, or null for the full extent.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - `src_rect`/`dst_rect` are null or valid for 4 f32 reads.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_graphics_composite(
+    dst_graphics_id: u64,
+    src_id: u64,
+    src_graphics_id: u64,
+    mode: u32,
+    src_rect: *const f32,
+    dst_rect: *const f32,
+    opacity: f32,
+) {
+    error::clear_error();
+    let read_rect = |p: *const f32| -> [f32; 4] {
+        if p.is_null() {
+            [0.0, 0.0, 1.0, 1.0]
+        } else {
+            let s = unsafe { std::slice::from_raw_parts(p, 4) };
+            [s[0], s[1], s[2], s[3]]
+        }
+    };
+    let src_rect = read_rect(src_rect);
+    let dst_rect = read_rect(dst_rect);
+    error::check(|| {
+        if src_graphics_id != 0 {
+            graphics_flush(Entity::from_bits(src_graphics_id))?;
+        }
+        let filter = filter_composite()?;
+        filter_set(
+            filter,
+            "src",
+            ShaderValue::Texture(Entity::from_bits(src_id)),
+        )?;
+        filter_set(filter, "mode", ShaderValue::UInt(mode))?;
+        filter_set(filter, "opacity", ShaderValue::Float(opacity))?;
+        filter_set(filter, "src_rect", ShaderValue::Float4(src_rect))?;
+        filter_set(filter, "dst_rect", ShaderValue::Float4(dst_rect))?;
+        graphics_apply_filter(Entity::from_bits(dst_graphics_id), filter)
+    });
+}
+
+/// Built-in feedback pass: re-sample this graphics' previous frame through a
+/// zoom/rotate/offset transform scaled by `decay`, writing it back. On a
+/// canvas you never clear, call at the start of the frame and draw new content
+/// on top to get feedback trails.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_graphics_feedback(
+    graphics_id: u64,
+    decay: f32,
+    zoom: f32,
+    angle: f32,
+    offset_x: f32,
+    offset_y: f32,
+) {
+    error::clear_error();
+    error::check(|| {
+        let filter = filter_feedback()?;
+        filter_set(filter, "decay", ShaderValue::Float(decay))?;
+        filter_set(filter, "zoom", ShaderValue::Float(zoom))?;
+        filter_set(filter, "angle", ShaderValue::Float(angle))?;
+        filter_set(
+            filter,
+            "offset",
+            ShaderValue::Float2([offset_x, offset_y]),
+        )?;
+        graphics_apply_filter(Entity::from_bits(graphics_id), filter)
+    });
+}
+
+/// The built-in feedback filter entity (for direct `filter_set` tuning).
+/// Returns 0 on error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_filter_feedback() -> u64 {
+    error::clear_error();
+    error::check(filter_feedback)
+        .map(|e| e.to_bits())
+        .unwrap_or(0)
+}
+
+/// The built-in composite filter entity. Returns 0 on error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_filter_composite() -> u64 {
+    error::clear_error();
+    error::check(filter_composite)
+        .map(|e| e.to_bits())
+        .unwrap_or(0)
+}
diff --git a/crates/processing_ffi/src/lib.rs b/crates/processing_ffi/src/lib.rs
index 0596a15c..2e591949 100644
--- a/crates/processing_ffi/src/lib.rs
+++ b/crates/processing_ffi/src/lib.rs
@@ -7,10 +7,16 @@ use processing::prelude::{error::ProcessingError, shader_value::ShaderValue, *};
 
 use crate::color::Color;
 
+mod canvas;
 mod color;
 mod error;
+mod texture3d;
+#[cfg(feature = "physics")]
+mod physics;
 #[cfg(feature = "video")]
 mod video;
+#[cfg(all(feature = "video", target_os = "macos"))]
+mod video_macos;
 
 pub(crate) unsafe fn cstr_to_str<'a>(
     ptr: *const std::ffi::c_char,
@@ -218,6 +224,26 @@ pub extern "C" fn processing_surface_resize(window_id: u64, width: u32, height:
     error::check(|| surface_resize(window_entity, width, height));
 }
 
+/// Set the swapchain present mode for a window surface: `vsync` false selects
+/// `AutoNoVsync`, uncapping the draw loop from the display's refresh rate.
+///
+/// Windows are created vsynced, so this only ever has to be called to turn
+/// vsync off — the case an offline render wants, where the loop should run as
+/// fast as render + capture allow and nothing is watching the window. Tearing
+/// cannot reach a recording: `processing_record_capture` reads back the canvas
+/// texture, never the swapchain.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_surface_set_vsync(window_id: u64, vsync: bool) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| surface_set_vsync(window_entity, vsync));
+}
+
 /// Set the background color for the given graphics context.
 ///
 /// SAFETY:
@@ -307,6 +333,36 @@ pub extern "C" fn processing_end_draw(graphics_id: u64) {
     error::check(|| graphics_end_draw(graphics_entity));
 }
 
+/// Whether a canvas has draw commands waiting for a flush. Callers that flush
+/// defensively before sampling a canvas can skip the flush (a whole
+/// `app.update()`) when this is false.
+///
+/// SAFETY:
+/// - graphics_id is a valid ID returned from graphics_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_graphics_has_pending(graphics_id: u64) -> bool {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    error::check(|| graphics_has_pending(graphics_entity)).unwrap_or(true)
+}
+
+/// End the current draw WITHOUT forcing a GPU update: the canvas is armed to
+/// present on the next update instead. For window canvases only — a single
+/// update presents every armed window, so N windows cost one update per frame
+/// rather than N.
+///
+/// SAFETY:
+/// - Init and graphics_create have been called.
+/// - graphics_id is a valid ID returned from graphics_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_arm_present(graphics_id: u64) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    error::check(|| graphics_arm_present(graphics_entity));
+}
+
 /// Shuts down internal resources with given exit code, but does *not* terminate the process.
 ///
 /// SAFETY:
@@ -902,6 +958,40 @@ pub extern "C" fn processing_curve(
     });
 }
 
+/// Draw a box.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_box(graphics_id: u64, width: f32, height: f32, depth: f32) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    error::check(|| {
+        graphics_record_command(
+            graphics_entity,
+            DrawCommand::Box {
+                width,
+                height,
+                depth,
+            },
+        )
+    });
+}
+
+/// Draw a sphere.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_sphere(graphics_id: u64, radius: f32, sectors: u32, stacks: u32) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    error::check(|| {
+        graphics_record_command(
+            graphics_entity,
+            DrawCommand::Sphere {
+                radius,
+                sectors,
+                stacks,
+            },
+        )
+    });
+}
+
 /// Draw a cylinder.
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_cylinder(graphics_id: u64, radius: f32, height: f32, detail: u32) {
@@ -1141,6 +1231,12 @@ pub unsafe extern "C" fn processing_create_font(name_ptr: *const std::ffi::c_cha
     error::check(|| font_create(&name).map(|e| e.to_bits())).unwrap_or(0)
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_font_destroy(font_id: u64) {
+    error::clear_error();
+    error::check(|| font_destroy(Entity::from_bits(font_id)));
+}
+
 /// Query the number of variable font axes for a font.
 /// Returns 0 if the font is not variable or not found.
 #[unsafe(no_mangle)]
@@ -1620,6 +1716,12 @@ pub unsafe extern "C" fn processing_image_load(path: *const std::ffi::c_char) ->
         .unwrap_or(0)
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_image_destroy(image_id: u64) {
+    error::clear_error();
+    error::check(|| image_destroy(Entity::from_bits(image_id)));
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_image_resize(image_id: u64, new_width: u32, new_height: u32) {
     error::clear_error();
@@ -2838,6 +2940,76 @@ pub unsafe extern "C" fn processing_graphics_text_to_geometry(
     .unwrap_or(0)
 }
 
+/// Destroy a light created by any of the light-create functions.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_light_destroy(light_id: u64) {
+    error::clear_error();
+    error::check(|| light_destroy(Entity::from_bits(light_id)));
+}
+
+/// Aim a light: (x, y, z) is the direction the light travels (Processing's
+/// directionalLight convention).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_light_set_direction(light_id: u64, x: f32, y: f32, z: f32) {
+    error::clear_error();
+    error::check(|| light_set_direction(Entity::from_bits(light_id), Vec3::new(x, y, z)));
+}
+
+/// Enable or disable shadow casting for a directional light.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_light_set_shadows(light_id: u64, enabled: bool) {
+    error::clear_error();
+    error::check(|| light_set_shadows(Entity::from_bits(light_id), enabled));
+}
+
+/// Enable or disable contact-shadow casting for a directional light.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_light_set_contact_shadows(light_id: u64, enabled: bool) {
+    error::clear_error();
+    error::check(|| light_set_contact_shadows(Entity::from_bits(light_id), enabled));
+}
+
+/// Set a directional light's shadow-map depth and normal bias.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_light_set_shadow_bias(
+    light_id: u64,
+    depth_bias: f32,
+    normal_bias: f32,
+) {
+    error::clear_error();
+    error::check(|| {
+        light_set_shadow_bias(Entity::from_bits(light_id), depth_bias, normal_bias)
+    });
+}
+
+/// Enable or disable screen-space contact shadows on a canvas' camera.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_graphics_contact_shadows(
+    graphics_id: u64,
+    enabled: bool,
+    linear_steps: u32,
+    thickness: f32,
+    length: f32,
+) {
+    error::clear_error();
+    error::check(|| {
+        graphics_set_contact_shadows(
+            Entity::from_bits(graphics_id),
+            enabled,
+            linear_steps,
+            thickness,
+            length,
+        )
+    });
+}
+
+/// Enable or disable temporal antialiasing on a canvas' camera.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_graphics_temporal_aa(graphics_id: u64, enabled: bool) {
+    error::clear_error();
+    error::check(|| graphics_set_temporal_aa(Entity::from_bits(graphics_id), enabled));
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_light_create_directional(
     graphics_id: u64,
@@ -3005,6 +3177,12 @@ pub extern "C" fn processing_material_set_depth_write(mat_id: u64, value: bool)
     error::check(|| material_set_depth_write(Entity::from_bits(mat_id), value));
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_material_set_depth_bias(mat_id: u64, value: f32) {
+    error::clear_error();
+    error::check(|| material_set_depth_bias(Entity::from_bits(mat_id), value));
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_material_set_custom_blend_mode(
     mat_id: u64,
@@ -3504,6 +3682,15 @@ pub extern "C" fn processing_compute_dispatch(compute_id: u64, x: u32, y: u32, z
     error::check(|| compute_dispatch(Entity::from_bits(compute_id), x, y, z));
 }
 
+/// Dispatch without pumping an engine update first. See
+/// `compute_dispatch_quiet`: submission order still guarantees pass ordering,
+/// but resources created since the last update may not be bindable yet.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_compute_dispatch_quiet(compute_id: u64, x: u32, y: u32, z: u32) {
+    error::clear_error();
+    error::check(|| compute_dispatch_quiet(Entity::from_bits(compute_id), x, y, z));
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_compute_destroy(compute_id: u64) {
     error::clear_error();
@@ -3825,6 +4012,12 @@ pub unsafe extern "C" fn processing_gltf_load(
     .unwrap_or(0)
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_gltf_destroy(gltf_id: u64) {
+    error::clear_error();
+    error::check(|| gltf_destroy(Entity::from_bits(gltf_id)));
+}
+
 /// # Safety
 /// - `name` is a valid null-terminated C string.
 #[unsafe(no_mangle)]
@@ -3841,6 +4034,53 @@ pub unsafe extern "C" fn processing_gltf_geometry(
     .unwrap_or(0)
 }
 
+/// Spawn an animation pose pool from a loaded GLTF: `k` paused puppet
+/// instances of the scene, seeked along the named clip at pose/k of its
+/// duration. Their joint matrices drive skinned particle instancing (see
+/// `processing_particles_set_skin_pool`). Returns the pool id, or 0 on error.
+///
+/// # Safety
+/// - `clip_name` is a valid null-terminated C string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_gltf_animation_pool(
+    gltf_id: u64,
+    clip_name: *const std::ffi::c_char,
+    k: u32,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        let clip_name = unsafe { cstr_to_str(clip_name) }?;
+        gltf_animation_pool(Entity::from_bits(gltf_id), clip_name, k)
+    })
+    .map(|e| e.to_bits())
+    .unwrap_or(0)
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_gltf_animation_pool_destroy(pool_id: u64) {
+    error::clear_error();
+    error::check(|| gltf_animation_pool_destroy(Entity::from_bits(pool_id)));
+}
+
+/// Attach an animation pose pool and a per-particle phase attribute (float,
+/// phase in [0,1)) to a particle system. Instanced draws of the system are
+/// then skinned: each instance takes the pool pose nearest its phase.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_set_skin_pool(
+    particles_id: u64,
+    pool_id: u64,
+    phase_attr_id: u64,
+) {
+    error::clear_error();
+    error::check(|| {
+        particles_set_skin_pool(
+            Entity::from_bits(particles_id),
+            Entity::from_bits(pool_id),
+            Entity::from_bits(phase_attr_id),
+        )
+    });
+}
+
 /// # Safety
 /// - `name` is a valid null-terminated C string.
 #[unsafe(no_mangle)]
@@ -4044,6 +4284,14 @@ pub extern "C" fn processing_particles_primitives_create(
     .unwrap_or(0)
 }
 
+/// Destroy a dynamic-topology target and its internal field, buffers, reset
+/// kernel, and reset shader. The source particle system is borrowed.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_particles_primitives_destroy(target_id: u64) {
+    error::clear_error();
+    error::check(|| particles_primitives_destroy(Entity::from_bits(target_id)));
+}
+
 /// Apply `compute` over the target's source field with the target's buffers
 /// bound under the `processing::prims` reserved names.
 #[unsafe(no_mangle)]
diff --git a/crates/processing_ffi/src/physics.rs b/crates/processing_ffi/src/physics.rs
new file mode 100644
index 00000000..ea78ad2b
--- /dev/null
+++ b/crates/processing_ffi/src/physics.rs
@@ -0,0 +1,291 @@
+//! Rigid-body physics (avian3d).
+//!
+//! Bodies are pure simulation objects: create them, step happens once per
+//! frame (frame-locked, deterministic), read poses back and draw them however
+//! the sketch likes — typically in bulk into a particle system's
+//! position/rotation buffers for instanced drawing.
+
+use bevy::math::{Quat, Vec3};
+use bevy::prelude::Entity;
+use processing_physics::{
+    body_apply_angular_impulse, body_apply_impulse, body_create, body_create_from_geometry,
+    body_destroy,
+    body_get_linear_velocity, body_get_transform, body_set_angular_velocity, body_set_density,
+    body_set_friction, body_set_linear_velocity, body_set_position, body_set_restitution,
+    body_set_transform, read_transforms, set_gravity, set_paused, set_realtime, set_substeps,
+    set_timestep_hz, step,
+};
+
+use crate::error;
+
+// ── World configuration ─────────────────────────────────────────────────────
+
+/// Set the gravity vector (world units per second squared).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_set_gravity(x: f32, y: f32, z: f32) {
+    error::clear_error();
+    error::check(|| set_gravity(Vec3::new(x, y, z)));
+}
+
+/// Frame-locked stepping: the simulation advances by exactly `1/hz` seconds
+/// every rendered frame (the default, at 60 Hz). Deterministic.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_set_timestep(hz: f64) {
+    error::clear_error();
+    error::check(|| set_timestep_hz(hz));
+}
+
+/// Follow the wall clock instead of frame-locked stepping (non-deterministic).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_set_realtime() {
+    error::clear_error();
+    error::check(set_realtime);
+}
+
+/// Mark the start of a Processing frame: the next engine update advances the
+/// simulation by one fixed step. Called once per frame by the host renderer
+/// (primary canvas beginDraw); extra engine updates pumped by flushes or
+/// offscreen graphics within the frame do not step again.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_step() {
+    error::clear_error();
+    error::check(step);
+}
+
+/// Pause or resume the simulation.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_set_paused(paused: bool) {
+    error::clear_error();
+    error::check(|| set_paused(paused));
+}
+
+/// Solver substeps per physics step (default 6). More = stiffer stacks.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_set_substeps(count: u32) {
+    error::clear_error();
+    error::check(|| set_substeps(count));
+}
+
+// ── Bodies ──────────────────────────────────────────────────────────────────
+
+/// Create a rigid body.
+///
+/// `kind`: 0 = static, 1 = dynamic, 2 = kinematic.
+/// `shape`: 0 = box (p0, p1, p2 = full extents), 1 = sphere (p0 = radius),
+/// 2 = capsule (p0 = radius, p1 = cylinder length).
+/// Returns the body id, or 0 on error.
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+pub extern "C" fn processing_physics_body_create(
+    kind: u32,
+    shape: u32,
+    p0: f32,
+    p1: f32,
+    p2: f32,
+    x: f32,
+    y: f32,
+    z: f32,
+    qx: f32,
+    qy: f32,
+    qz: f32,
+    qw: f32,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        body_create(
+            kind,
+            shape,
+            Vec3::new(p0, p1, p2),
+            Vec3::new(x, y, z),
+            Quat::from_xyzw(qx, qy, qz, qw).normalize(),
+        )
+    })
+    .map(|e| e.to_bits())
+    .unwrap_or(0)
+}
+
+/// Create a rigid body whose collider is built from a geometry's CPU mesh
+/// (any geometry id: primitives, custom shapes, glTF meshes).
+///
+/// `kind`: 0 = static, 1 = dynamic, 2 = kinematic.
+/// `mode`: 0 = trimesh (exact; static scenery), 1 = convex hull (fast;
+/// dynamic bodies), 2 = convex decomposition (accurate and dynamic-friendly,
+/// expensive to build).
+/// Returns the body id, or 0 on error.
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+pub extern "C" fn processing_physics_body_create_from_geometry(
+    geometry_id: u64,
+    kind: u32,
+    mode: u32,
+    x: f32,
+    y: f32,
+    z: f32,
+    qx: f32,
+    qy: f32,
+    qz: f32,
+    qw: f32,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        body_create_from_geometry(
+            Entity::from_bits(geometry_id),
+            kind,
+            mode,
+            Vec3::new(x, y, z),
+            Quat::from_xyzw(qx, qy, qz, qw).normalize(),
+        )
+    })
+    .map(|e| e.to_bits())
+    .unwrap_or(0)
+}
+
+/// Remove a body from the simulation.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_destroy(body_id: u64) {
+    error::clear_error();
+    error::check(|| body_destroy(Entity::from_bits(body_id)));
+}
+
+/// Teleport a body (also zeroes accumulated interpolation, not velocities).
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+pub extern "C" fn processing_physics_body_set_transform(
+    body_id: u64,
+    x: f32,
+    y: f32,
+    z: f32,
+    qx: f32,
+    qy: f32,
+    qz: f32,
+    qw: f32,
+) {
+    error::clear_error();
+    error::check(|| {
+        body_set_transform(
+            Entity::from_bits(body_id),
+            Vec3::new(x, y, z),
+            Quat::from_xyzw(qx, qy, qz, qw).normalize(),
+        )
+    });
+}
+
+/// Position-only teleport: keeps the current rotation and velocities.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_set_position(body_id: u64, x: f32, y: f32, z: f32) {
+    error::clear_error();
+    error::check(|| body_set_position(Entity::from_bits(body_id), Vec3::new(x, y, z)));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_set_linear_velocity(body_id: u64, x: f32, y: f32, z: f32) {
+    error::clear_error();
+    error::check(|| body_set_linear_velocity(Entity::from_bits(body_id), Vec3::new(x, y, z)));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_set_angular_velocity(
+    body_id: u64,
+    x: f32,
+    y: f32,
+    z: f32,
+) {
+    error::clear_error();
+    error::check(|| body_set_angular_velocity(Entity::from_bits(body_id), Vec3::new(x, y, z)));
+}
+
+/// Apply a one-shot linear impulse (mass-scaled velocity change) this frame.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_apply_impulse(body_id: u64, x: f32, y: f32, z: f32) {
+    error::clear_error();
+    error::check(|| body_apply_impulse(Entity::from_bits(body_id), Vec3::new(x, y, z)));
+}
+
+/// Apply a one-shot angular impulse this frame.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_apply_angular_impulse(
+    body_id: u64,
+    x: f32,
+    y: f32,
+    z: f32,
+) {
+    error::clear_error();
+    error::check(|| body_apply_angular_impulse(Entity::from_bits(body_id), Vec3::new(x, y, z)));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_set_friction(body_id: u64, friction: f32) {
+    error::clear_error();
+    error::check(|| body_set_friction(Entity::from_bits(body_id), friction));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_set_restitution(body_id: u64, restitution: f32) {
+    error::clear_error();
+    error::check(|| body_set_restitution(Entity::from_bits(body_id), restitution));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_physics_body_set_density(body_id: u64, density: f32) {
+    error::clear_error();
+    error::check(|| body_set_density(Entity::from_bits(body_id), density));
+}
+
+// ── Readback ────────────────────────────────────────────────────────────────
+
+/// Write a body's pose into `out` as 7 floats: position xyz, quaternion xyzw.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - `out` is valid for 7 f32 writes.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_physics_body_get_transform(body_id: u64, out: *mut f32) {
+    error::clear_error();
+    if let Some(pose) = error::check(|| body_get_transform(Entity::from_bits(body_id))) {
+        let out = unsafe { std::slice::from_raw_parts_mut(out, 7) };
+        out.copy_from_slice(&pose);
+    }
+}
+
+/// Write a body's linear velocity into `out` as 3 floats.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - `out` is valid for 3 f32 writes.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_physics_body_get_linear_velocity(body_id: u64, out: *mut f32) {
+    error::clear_error();
+    if let Some(v) = error::check(|| body_get_linear_velocity(Entity::from_bits(body_id))) {
+        let out = unsafe { std::slice::from_raw_parts_mut(out, 3) };
+        out.copy_from_slice(&v);
+    }
+}
+
+/// Bulk pose readback: for each of `count` body ids, writes 7 floats
+/// (position xyz, quaternion xyzw) into `out`. Destroyed bodies write
+/// identity poses. Returns the number of live bodies read.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - `ids` is valid for `count` u64 reads; `out` for `count * 7` f32 writes.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_physics_read_transforms(
+    ids: *const u64,
+    count: usize,
+    out: *mut f32,
+) -> usize {
+    error::clear_error();
+    let ids = unsafe { std::slice::from_raw_parts(ids, count) };
+    let out = unsafe { std::slice::from_raw_parts_mut(out, count * 7) };
+    match error::check(|| {
+        let mut poses = vec![0.0f32; count * 7];
+        let read = read_transforms(ids, &mut poses)?;
+        Ok((read, poses))
+    }) {
+        Some((read, poses)) => {
+            out.copy_from_slice(&poses);
+            read
+        }
+        None => 0,
+    }
+}
diff --git a/crates/processing_ffi/src/texture3d.rs b/crates/processing_ffi/src/texture3d.rs
new file mode 100644
index 00000000..47adc3fb
--- /dev/null
+++ b/crates/processing_ffi/src/texture3d.rs
@@ -0,0 +1,133 @@
+//! 3D texture FFI: a volume texture writable from compute kernels
+//! (`texture_storage_3d<FMT, write>`) and sampled with trilinear filtering in
+//! custom materials/filters (`texture_3d<f32>`). Bound by name like any other
+//! texture via `processing_shader_set_texture` / material texture params.
+
+use bevy::prelude::Entity;
+use bevy::render::render_resource::{Extent3d, TextureFormat};
+use processing::prelude::{
+    image, image_destroy, texture3d_create, texture3d_readback, texture3d_write,
+};
+
+use crate::error;
+
+/// Map an FFI format code to a texture format.
+///
+/// 0 = r16float (2 B/texel; storage write + trilinear on Metal via
+///     adapter-specific format features — the voxel T-field default),
+/// 1 = r32float (4 B; storage write everywhere, NOT filterable on Apple GPUs),
+/// 2 = rg16float (4 B),
+/// 3 = rgba16float (8 B; base-WebGPU-safe storage + filterable fallback),
+/// 4 = rgba8unorm (4 B),
+/// 5 = r32uint (4 B; storage write, integer loads only).
+fn texture3d_format(code: u8) -> Result<TextureFormat, error::ProcessingError> {
+    Ok(match code {
+        0 => TextureFormat::R16Float,
+        1 => TextureFormat::R32Float,
+        2 => TextureFormat::Rg16Float,
+        3 => TextureFormat::Rgba16Float,
+        4 => TextureFormat::Rgba8Unorm,
+        5 => TextureFormat::R32Uint,
+        _ => {
+            return Err(error::ProcessingError::InvalidArgument(format!(
+                "unknown texture3d format code: {code}"
+            )));
+        }
+    })
+}
+
+/// Create a zero-initialized 3D texture. Returns the texture id (usable
+/// wherever an image id is accepted: shader/material texture params).
+///
+/// # Safety
+/// - Init has been called; called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_texture3d_create(
+    width: u32,
+    height: u32,
+    depth: u32,
+    format: u8,
+) -> u64 {
+    error::clear_error();
+    error::check(|| {
+        let format = texture3d_format(format)?;
+        texture3d_create(
+            Extent3d {
+                width,
+                height,
+                depth_or_array_layers: depth,
+            },
+            format,
+        )
+    })
+    .map(|entity| entity.to_bits())
+    .unwrap_or(0)
+}
+
+/// Bytes per texel for a format code (for sizing upload/readback buffers).
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_texture3d_texel_size(format: u8) -> u32 {
+    error::clear_error();
+    error::check(|| {
+        let format = texture3d_format(format)?;
+        image::pixel_size(format).map(|s| s as u32)
+    })
+    .unwrap_or(0)
+}
+
+/// Upload a full volume of tightly-packed texel bytes (x fastest, then y,
+/// then z; `data_len` must equal width*height*depth*texel_size).
+///
+/// # Safety
+/// - `data` is valid for `data_len` bytes.
+/// - Init has been called; called from the same thread as init.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_texture3d_write(
+    texture_id: u64,
+    data: *const u8,
+    data_len: usize,
+) {
+    error::clear_error();
+    let data = unsafe { std::slice::from_raw_parts(data, data_len) };
+    error::check(|| texture3d_write(Entity::from_bits(texture_id), data.to_vec()));
+}
+
+/// Read the full volume back as tightly-packed texel bytes. `out_len` must
+/// equal width*height*depth*texel_size.
+///
+/// # Safety
+/// - `out` is valid for `out_len` writable bytes.
+/// - Init has been called; called from the same thread as init.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_texture3d_readback(
+    texture_id: u64,
+    out: *mut u8,
+    out_len: usize,
+) {
+    error::clear_error();
+    error::check(|| {
+        let bytes = texture3d_readback(Entity::from_bits(texture_id))?;
+        if bytes.len() != out_len {
+            let msg = format!(
+                "texture3d readback: buffer size mismatch: expected {}, got {}",
+                bytes.len(),
+                out_len
+            );
+            return Err(error::ProcessingError::InvalidArgument(msg));
+        }
+        unsafe {
+            std::slice::from_raw_parts_mut(out, out_len).copy_from_slice(&bytes);
+        }
+        Ok(())
+    });
+}
+
+/// Destroy a 3D texture (same entity space as images).
+///
+/// # Safety
+/// - Init has been called; called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_texture3d_destroy(texture_id: u64) {
+    error::clear_error();
+    error::check(|| image_destroy(Entity::from_bits(texture_id)));
+}
diff --git a/crates/processing_ffi/src/video.rs b/crates/processing_ffi/src/video.rs
index c3385e69..ca123ff1 100644
--- a/crates/processing_ffi/src/video.rs
+++ b/crates/processing_ffi/src/video.rs
@@ -145,8 +145,14 @@ enum RecState {
         preset: Option<String>,
         codec: RecorderCodec,
         bitrate: Option<u64>,
+        bframes: Option<u32>,
     },
     Active(VideoRecorder),
+    /// GPU-resident path (macOS + VideoToolbox codecs): frames are blitted
+    /// into IOSurface-backed pixel buffers and encoded by the media engine;
+    /// no readback, no CPU pixel work. See `video_macos`.
+    #[cfg(target_os = "macos")]
+    Gpu(crate::video_macos::GpuRecorder),
 }
 
 static RECORDER: Mutex<Option<RecState>> = Mutex::new(None);
@@ -205,6 +211,7 @@ fn feed_frame(state: &mut RecState, raw: graphics::ReadbackData) -> Result<(), P
         preset,
         codec,
         bitrate,
+        bframes,
     } = state
     {
         let mut config =
@@ -213,6 +220,7 @@ fn feed_frame(state: &mut RecState, raw: graphics::ReadbackData) -> Result<(), P
         config.preset = preset.clone();
         config.codec = *codec;
         config.bitrate = *bitrate;
+        config.bframes = *bframes;
         let recorder = VideoRecorder::new(&*path, config).map_err(record_err)?;
         *state = RecState::Active(recorder);
     }
@@ -249,7 +257,10 @@ fn drain_ring(state: &mut RecState) -> Result<(), ProcessingError> {
 /// rate-controlled by `bitrate_bps` (bits per second; pass 0 or negative for
 /// an automatic choice of ~0.1 bits/pixel/frame). Frames are queued with
 /// `processing_record_capture` and the file is finalized by
-/// `processing_record_end`.
+/// `processing_record_end`. `bframes` caps consecutive B frames; pass a
+/// negative value for the encoder default (3 for x264), or 0 to disable them,
+/// which removes the periodic quality pulse B frames cause on content the
+/// codec predicts badly.
 ///
 /// SAFETY:
 /// - Init has been called.
@@ -263,6 +274,7 @@ pub unsafe extern "C" fn processing_record_begin(
     preset: *const c_char,
     codec: u8,
     bitrate_bps: i64,
+    bframes: i32,
 ) {
     error::clear_error();
     error::check(|| {
@@ -308,6 +320,15 @@ pub unsafe extern "C" fn processing_record_begin(
             }
         };
         let bitrate = (bitrate_bps > 0).then_some(bitrate_bps as u64);
+        let bframes = match bframes {
+            i32::MIN..0 => None,
+            0..=16 => Some(bframes as u32),
+            _ => {
+                return Err(ProcessingError::InvalidArgument(format!(
+                    "bframes must be between 0 (none) and 16, got {bframes}"
+                )));
+            }
+        };
         let mut slot = RECORDER.lock().unwrap();
         if slot.is_some() {
             return Err(ProcessingError::InvalidArgument(
@@ -321,6 +342,7 @@ pub unsafe extern "C" fn processing_record_begin(
             preset,
             codec,
             bitrate,
+            bframes,
         });
         Ok(())
     });
@@ -342,6 +364,44 @@ pub extern "C" fn processing_record_capture(graphics_id: u64) {
         };
         ACTIVE_GRAPHICS.store(graphics_id, Ordering::Relaxed);
         let entity = Entity::from_bits(graphics_id);
+        // macOS + a VideoToolbox codec: promote to the GPU-resident path on
+        // the first capture. `PROCESSING_RECORD_CPU=1` forces the readback +
+        // ffmpeg path (A/B comparison, escape hatch).
+        #[cfg(target_os = "macos")]
+        if let RecState::Pending {
+            path,
+            fps,
+            codec,
+            bitrate,
+            bframes,
+            ..
+        } = state
+            && std::env::var_os("PROCESSING_RECORD_CPU").is_none()
+        {
+            let avf_codec = match codec {
+                RecorderCodec::H264VideoToolbox => Some(processing_video::macos::AvfCodec::H264),
+                RecorderCodec::HevcVideoToolbox => Some(processing_video::macos::AvfCodec::Hevc),
+                RecorderCodec::X264 => None,
+            };
+            if let Some(avf_codec) = avf_codec {
+                *state = RecState::Gpu(crate::video_macos::GpuRecorder::new(
+                    std::mem::take(path),
+                    *fps,
+                    avf_codec,
+                    *bitrate,
+                    *bframes,
+                ));
+            }
+        }
+        #[cfg(target_os = "macos")]
+        if let RecState::Gpu(gpu) = state {
+            let result = gpu.capture(entity);
+            if result.is_err() {
+                *slot = None;
+                ACTIVE_GRAPHICS.store(0, Ordering::Relaxed);
+            }
+            return result;
+        }
         let result = (|| {
             let timing = std::env::var_os("PROCESSING_RECORD_TIMING").is_some();
             let t0 = std::time::Instant::now();
@@ -400,7 +460,7 @@ pub extern "C" fn processing_record_end() -> u64 {
             )),
             Some(mut state) => {
                 let drained = drain_ring(&mut state);
-                ACTIVE_GRAPHICS.store(0, Ordering::Relaxed);
+                let _entity_bits = ACTIVE_GRAPHICS.swap(0, Ordering::Relaxed);
                 drained?;
                 match state {
                     RecState::Pending { .. } => Err(ProcessingError::InvalidArgument(
@@ -409,6 +469,8 @@ pub extern "C" fn processing_record_end() -> u64 {
                             .to_string(),
                     )),
                     RecState::Active(recorder) => recorder.finish().map_err(record_err),
+                    #[cfg(target_os = "macos")]
+                    RecState::Gpu(gpu) => gpu.finish(_entity_bits),
                 }
             }
         }
@@ -422,8 +484,15 @@ pub(crate) fn finish_on_exit() {
         && let Some(mut state) = slot.take()
     {
         let _ = drain_ring(&mut state);
-        if let RecState::Active(recorder) = state {
-            let _ = recorder.finish();
+        match state {
+            RecState::Active(recorder) => {
+                let _ = recorder.finish();
+            }
+            #[cfg(target_os = "macos")]
+            RecState::Gpu(gpu) => {
+                let _ = gpu.finish(ACTIVE_GRAPHICS.load(Ordering::Relaxed));
+            }
+            _ => {}
         }
     }
     ACTIVE_GRAPHICS.store(0, Ordering::Relaxed);
diff --git a/crates/processing_ffi/src/video_macos.rs b/crates/processing_ffi/src/video_macos.rs
new file mode 100644
index 00000000..b2d22aee
--- /dev/null
+++ b/crates/processing_ffi/src/video_macos.rs
@@ -0,0 +1,134 @@
+//! GPU-resident recording glue (macOS only).
+//!
+//! Pairs `processing_render`'s IOSurface capture (wgpu blit, GPU completion
+//! callback) with `processing_video`'s AVAssetWriter recorder (hardware
+//! encode + mux). Selected automatically by `processing_record_capture` when
+//! a VideoToolbox codec is requested; set `PROCESSING_RECORD_CPU=1` to force
+//! the readback + ffmpeg path instead.
+
+use bevy::prelude::Entity;
+use processing::prelude::{
+    error::ProcessingError, graphics_capture_into_iosurface, graphics_capture_reset,
+    graphics_device_poll, graphics_surface_size,
+};
+use processing_video::macos::{AvfCodec, AvfRecorder, AvfRecorderConfig};
+
+fn record_err(e: impl std::fmt::Display) -> ProcessingError {
+    ProcessingError::InvalidArgument(format!("video record: {e}"))
+}
+
+/// One in-progress GPU recording. The AVF recorder is created on the first
+/// captured frame so its dimensions match the graphics being recorded.
+pub struct GpuRecorder {
+    path: String,
+    fps: f64,
+    codec: AvfCodec,
+    bitrate: Option<u64>,
+    bframes: Option<u32>,
+    recorder: Option<AvfRecorder>,
+}
+
+impl GpuRecorder {
+    pub fn new(
+        path: String,
+        fps: f64,
+        codec: AvfCodec,
+        bitrate: Option<u64>,
+        bframes: Option<u32>,
+    ) -> Self {
+        Self {
+            path,
+            fps,
+            codec,
+            bitrate,
+            bframes,
+            recorder: None,
+        }
+    }
+
+    /// Capture the current canvas as one frame: check a pixel buffer out of
+    /// the recorder's pool, blit into its IOSurface on the GPU, and hand the
+    /// buffer to the encoder when the GPU signals completion. Blocks only
+    /// when `MAX_IN_FLIGHT` frames are still in the pipeline.
+    pub fn capture(&mut self, entity: Entity) -> Result<(), ProcessingError> {
+        let timing = std::env::var_os("PROCESSING_RECORD_TIMING").is_some();
+        let t0 = std::time::Instant::now();
+        let (width, height) = graphics_surface_size(entity)?;
+        let recorder = match &mut self.recorder {
+            Some(r) => {
+                if r.width() != width || r.height() != height {
+                    return Err(record_err(format!(
+                        "canvas resized mid-recording ({}x{} -> {width}x{height})",
+                        r.width(),
+                        r.height(),
+                    )));
+                }
+                r
+            }
+            None => {
+                let config = AvfRecorderConfig {
+                    width,
+                    height,
+                    fps: self.fps,
+                    codec: self.codec,
+                    bitrate: self.bitrate,
+                    bframes: self.bframes,
+                };
+                self.recorder
+                    .insert(AvfRecorder::new(&self.path, config).map_err(record_err)?)
+            }
+        };
+
+        let frame = recorder
+            .acquire_frame(&mut || {
+                let _ = graphics_device_poll();
+            })
+            .map_err(record_err)?;
+        let t1 = std::time::Instant::now();
+        let ptr = frame.iosurface_ptr();
+        let id = frame.iosurface_id();
+        let completer = recorder.completer();
+        graphics_capture_into_iosurface(
+            entity,
+            ptr,
+            id,
+            Box::new(move || completer.complete(frame)),
+        )?;
+        if timing {
+            eprintln!(
+                "capture(gpu): acquire={:?} blit-submit={:?}",
+                t1 - t0,
+                t1.elapsed(),
+            );
+        }
+        Ok(())
+    }
+
+    /// Finalize the file and return the number of frames encoded. `entity` is
+    /// the recorded graphics (0 bits if no frame was ever captured), used to
+    /// drop the render side's texture cache.
+    pub fn finish(self, entity_bits: u64) -> Result<u64, ProcessingError> {
+        if entity_bits != 0 {
+            // Best-effort: the graphics may already be gone at exit.
+            let _ = graphics_capture_reset(Entity::from_bits(entity_bits));
+        }
+        match self.recorder {
+            Some(recorder) => {
+                let frames = recorder
+                    .finish(&mut || {
+                        let _ = graphics_device_poll();
+                    })
+                    .map_err(record_err)?;
+                if frames == 0 {
+                    return Err(record_err("no frames were captured"));
+                }
+                Ok(frames)
+            }
+            None => Err(ProcessingError::InvalidArgument(
+                "no frames were captured between processing_record_begin and \
+                 processing_record_end"
+                    .to_string(),
+            )),
+        }
+    }
+}
diff --git a/crates/processing_glfw/src/lib.rs b/crates/processing_glfw/src/lib.rs
index 9bf6a2f2..18856805 100644
--- a/crates/processing_glfw/src/lib.rs
+++ b/crates/processing_glfw/src/lib.rs
@@ -13,7 +13,7 @@ use processing_core::error::Result;
 use processing_input::{
     input_cursor_grab_mode, input_cursor_visible, input_flush, input_set_char,
     input_set_cursor_enter, input_set_cursor_leave, input_set_focus, input_set_key,
-    input_set_mouse_button, input_set_mouse_move, input_set_scroll, input_window_resize,
+    input_set_mouse_button, input_set_mouse_move, input_set_scroll,
 };
 use processing_render::surface::{MonitorWorkarea, WindowControls};
 
@@ -410,9 +410,10 @@ impl ManagedWindow {
             return false;
         }
 
-        // Apply the coalesced resize once, the WindowResized message and Window change are processed this poll.
+        // Apply the coalesced resize once, so the WindowResized message and the
+        // Window change are both processed this poll. `surface_resize` writes
+        // the message itself -- see the note in `processing_render::surface`.
         if let Some((width, height)) = pending_resize {
-            input_window_resize(surface, width as f32, height as f32).unwrap();
             processing_render::surface_resize(surface, width as u32, height as u32).unwrap();
         }
 
diff --git a/crates/processing_input/src/lib.rs b/crates/processing_input/src/lib.rs
index 4ee0bfd4..3d40e1ad 100644
--- a/crates/processing_input/src/lib.rs
+++ b/crates/processing_input/src/lib.rs
@@ -8,7 +8,7 @@ use bevy::input::mouse::{
 };
 use bevy::input::touch::TouchPhase;
 use bevy::prelude::*;
-use bevy::window::{CursorMoved, WindowResized};
+use bevy::window::CursorMoved;
 
 use processing_core::app_mut;
 use processing_core::error;
@@ -366,14 +366,3 @@ pub fn input_mouse_scrolled() -> error::Result<bool> {
         Ok(d.x != 0.0 || d.y != 0.0)
     })
 }
-
-pub fn input_window_resize(surface: Entity, width: f32, height: f32) -> error::Result<()> {
-    app_mut(|app| {
-        app.world_mut().write_message(WindowResized {
-            window: surface,
-            width,
-            height,
-        });
-        Ok(())
-    })
-}
diff --git a/crates/processing_physics/Cargo.toml b/crates/processing_physics/Cargo.toml
new file mode 100644
index 00000000..67e1620f
--- /dev/null
+++ b/crates/processing_physics/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "processing_physics"
+version = "0.0.1"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[dependencies]
+avian3d = { path = "/Users/char/src/github.com/avianphysics/avian/crates/avian3d", default-features = false, features = [
+  "3d",
+  "parry-f32",
+  "parallel",
+  "collider-from-mesh",
+] }
+bevy = { workspace = true }
+processing_core = { workspace = true }
+processing_render = { workspace = true }
+thiserror = "2"
diff --git a/crates/processing_physics/src/lib.rs b/crates/processing_physics/src/lib.rs
new file mode 100644
index 00000000..05be2017
--- /dev/null
+++ b/crates/processing_physics/src/lib.rs
@@ -0,0 +1,480 @@
+//! Physics integration for processing, wrapping the avian3d physics engine.
+//!
+//! Bodies are pure simulation entities: they carry no render components. A
+//! sketch draws them itself by reading transforms back (typically in bulk into
+//! a particle system's position/rotation buffers for instanced drawing).
+//!
+//! Stepping is frame-locked by default: `Time<Physics>` is paused and advanced
+//! by exactly `1/hz` every app update, so a sketch rendered frame-by-frame is
+//! deterministic regardless of wall-clock jitter (same policy as the paused
+//! animation-pool puppets). `set_realtime` opts back into wall-clock stepping.
+
+use std::time::Duration;
+
+use avian3d::prelude::*;
+use bevy::prelude::*;
+use processing_core::app_mut;
+use processing_core::error::Result;
+
+pub use avian3d;
+
+use crate::error::PhysicsError;
+
+pub mod error {
+    use processing_core::error::ProcessingError;
+    use thiserror::Error;
+
+    #[derive(Error, Debug)]
+    pub enum PhysicsError {
+        #[error("unknown rigid body kind {0} (expected 0=static, 1=dynamic, 2=kinematic)")]
+        UnknownBodyKind(u32),
+        #[error("unknown collider shape {0} (expected 0=box, 1=sphere, 2=capsule)")]
+        UnknownShape(u32),
+        #[error(
+            "unknown mesh collider mode {0} (expected 0=trimesh, 1=convex hull, 2=convex decomposition)"
+        )]
+        UnknownMeshMode(u32),
+        #[error("collider construction from mesh failed (empty or non-triangle geometry?)")]
+        MeshColliderFailed,
+        #[error("entity is not a physics body")]
+        NotABody,
+    }
+
+    impl From<PhysicsError> for ProcessingError {
+        fn from(err: PhysicsError) -> Self {
+            ProcessingError::InvalidArgument(err.to_string())
+        }
+    }
+}
+
+/// How the physics clock advances each app update.
+#[derive(Resource, Debug, Clone, Copy)]
+pub struct PhysicsFrameClock {
+    /// Fixed timestep frequency; each rendered frame advances the simulation
+    /// by exactly `1/hz` seconds.
+    pub hz: f64,
+    /// When false, `Time<Physics>` is unpaused and follows the wall clock.
+    pub frame_locked: bool,
+    /// When true, the frame clock stops advancing (bodies freeze).
+    pub paused: bool,
+    /// One step is owed. Set by [`step`] at the start of a Processing frame
+    /// and consumed by the first app update that follows, so extra updates
+    /// pumped by flushes/offscreen graphics within the same frame don't
+    /// advance the simulation again.
+    pub pending: bool,
+}
+
+impl Default for PhysicsFrameClock {
+    fn default() -> Self {
+        Self {
+            hz: 60.0,
+            frame_locked: true,
+            paused: false,
+            pending: false,
+        }
+    }
+}
+
+/// Marker for entities created through the processing physics API.
+#[derive(Component)]
+pub struct PhysicsBody;
+
+pub struct ProcessingPhysicsPlugin;
+
+impl Plugin for ProcessingPhysicsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(PhysicsPlugins::new(PostUpdate));
+        app.init_resource::<PhysicsFrameClock>();
+        app.add_systems(Startup, pause_physics_clock);
+        app.add_systems(
+            PostUpdate,
+            advance_frame_clock.before(PhysicsSystems::First),
+        );
+    }
+}
+
+fn pause_physics_clock(mut time: ResMut<Time<Physics>>) {
+    time.pause();
+}
+
+/// Frame-locked stepping: while `Time<Physics>` is paused, avian's schedule
+/// runner uses whatever delta a manual `advance_by` set, so advancing by
+/// exactly `1/hz` here steps the simulation deterministically per frame.
+/// Gated on `pending` — the host marks each Processing frame with [`step`],
+/// and every flush-pumped app update in between is a no-op.
+fn advance_frame_clock(mut clock: ResMut<PhysicsFrameClock>, mut time: ResMut<Time<Physics>>) {
+    if clock.frame_locked {
+        if !time.is_paused() {
+            time.pause();
+        }
+        if clock.pending && !clock.paused {
+            time.advance_by(Duration::from_secs_f64(1.0 / clock.hz));
+        }
+        clock.pending = false;
+    } else if time.is_paused() && !clock.paused {
+        time.unpause();
+    } else if clock.paused && !time.is_paused() {
+        time.pause();
+    }
+}
+
+/// Mark the start of a Processing frame: the next app update advances the
+/// simulation by one fixed step (frame-locked mode only; a wall-clock world
+/// steps on every update regardless).
+pub fn step() -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .resource_mut::<PhysicsFrameClock>()
+            .pending = true;
+        Ok(())
+    })
+}
+
+// ── World configuration ─────────────────────────────────────────────────────
+
+pub fn set_gravity(gravity: Vec3) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut().insert_resource(Gravity(gravity));
+        Ok(())
+    })
+}
+
+pub fn set_timestep_hz(hz: f64) -> Result<()> {
+    app_mut(|app| {
+        let mut clock = app.world_mut().resource_mut::<PhysicsFrameClock>();
+        clock.hz = hz.max(1.0);
+        clock.frame_locked = true;
+        Ok(())
+    })
+}
+
+pub fn set_realtime() -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .resource_mut::<PhysicsFrameClock>()
+            .frame_locked = false;
+        Ok(())
+    })
+}
+
+pub fn set_paused(paused: bool) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut().resource_mut::<PhysicsFrameClock>().paused = paused;
+        Ok(())
+    })
+}
+
+pub fn set_substeps(count: u32) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .insert_resource(SubstepCount(count.max(1)));
+        Ok(())
+    })
+}
+
+// ── Bodies ──────────────────────────────────────────────────────────────────
+
+fn body_kind(kind: u32) -> std::result::Result<RigidBody, PhysicsError> {
+    match kind {
+        0 => Ok(RigidBody::Static),
+        1 => Ok(RigidBody::Dynamic),
+        2 => Ok(RigidBody::Kinematic),
+        other => Err(PhysicsError::UnknownBodyKind(other)),
+    }
+}
+
+/// Shape params: box = full extents (x, y, z); sphere = (radius, _, _);
+/// capsule = (radius, length, _) where length is the cylindrical section.
+fn collider_shape(shape: u32, p: Vec3) -> std::result::Result<Collider, PhysicsError> {
+    match shape {
+        0 => Ok(Collider::cuboid(p.x, p.y, p.z)),
+        1 => Ok(Collider::sphere(p.x)),
+        2 => Ok(Collider::capsule(p.x, p.y)),
+        other => Err(PhysicsError::UnknownShape(other)),
+    }
+}
+
+pub fn body_create(
+    kind: u32,
+    shape: u32,
+    params: Vec3,
+    position: Vec3,
+    rotation: Quat,
+) -> Result<Entity> {
+    app_mut(|app| {
+        let body = body_kind(kind)?;
+        let collider = collider_shape(shape, params)?;
+        Ok(app
+            .world_mut()
+            .spawn((
+                PhysicsBody,
+                body,
+                collider,
+                Transform::from_translation(position).with_rotation(rotation),
+            ))
+            .id())
+    })
+}
+
+/// Create a rigid body whose collider is built from an existing geometry's
+/// CPU mesh (the same entities the geometry/glTF APIs hand out).
+///
+/// `mode`: 0 = trimesh (exact, best for static scenery), 1 = convex hull
+/// (fast, best for dynamic bodies), 2 = convex decomposition (accurate AND
+/// dynamic-friendly, expensive to build).
+pub fn body_create_from_geometry(
+    geometry: Entity,
+    kind: u32,
+    mode: u32,
+    position: Vec3,
+    rotation: Quat,
+) -> Result<Entity> {
+    app_mut(|app| {
+        let body = body_kind(kind)?;
+        let world = app.world_mut();
+        let handle = world
+            .get::<processing_render::geometry::Geometry>(geometry)
+            .ok_or(processing_core::error::ProcessingError::GeometryNotFound)?
+            .handle
+            .clone();
+        let meshes = world.resource::<Assets<Mesh>>();
+        let mesh = meshes.get(&handle).ok_or(processing_core::error::ProcessingError::GeometryNotFound)?;
+        let collider = match mode {
+            0 => Collider::trimesh_from_mesh(mesh),
+            1 => Collider::convex_hull_from_mesh(mesh),
+            2 => Collider::convex_decomposition_from_mesh(mesh),
+            other => return Err(PhysicsError::UnknownMeshMode(other).into()),
+        }
+        // Engine meshes (glTF in particular) are often non-indexed triangle
+        // soups, which avian's *_from_mesh helpers reject; sequential indices
+        // are exact for a soup, so rebuild from raw positions.
+        .or_else(|| collider_from_triangle_soup(mesh, mode))
+        .ok_or_else(|| {
+            processing_core::error::ProcessingError::InvalidArgument(format!(
+                "collider construction from mesh failed (position attr: {:?}, indices: {:?}, topology: {:?})",
+                mesh.attribute(Mesh::ATTRIBUTE_POSITION).map(|a| {
+                    format!(
+                        "{} verts, float32x3: {}",
+                        a.len(),
+                        matches!(a, bevy::mesh::VertexAttributeValues::Float32x3(_))
+                    )
+                }),
+                mesh.indices().map(|i| i.len()),
+                mesh.primitive_topology(),
+            ))
+        })?;
+        Ok(world
+            .spawn((
+                PhysicsBody,
+                body,
+                collider,
+                Transform::from_translation(position).with_rotation(rotation),
+            ))
+            .id())
+    })
+}
+
+/// Collider from a non-indexed TriangleList mesh: consecutive vertex triples
+/// are the triangles, so sequential indices reconstruct the topology exactly.
+fn collider_from_triangle_soup(mesh: &Mesh, mode: u32) -> Option<Collider> {
+    use bevy::mesh::{PrimitiveTopology, VertexAttributeValues};
+    if mesh.primitive_topology() != PrimitiveTopology::TriangleList || mesh.indices().is_some() {
+        return None;
+    }
+    let VertexAttributeValues::Float32x3(positions) = mesh.attribute(Mesh::ATTRIBUTE_POSITION)?
+    else {
+        return None;
+    };
+    let vertices: Vec<Vec3> = positions.iter().map(|p| Vec3::from_array(*p)).collect();
+    if vertices.len() < 3 {
+        return None;
+    }
+    let indices: Vec<[u32; 3]> = (0..vertices.len() as u32 / 3)
+        .map(|t| [t * 3, t * 3 + 1, t * 3 + 2])
+        .collect();
+    match mode {
+        0 => Some(Collider::trimesh(vertices, indices)),
+        1 => Collider::convex_hull(vertices),
+        2 => Some(Collider::convex_decomposition(vertices, indices)),
+        _ => None,
+    }
+}
+
+pub fn body_destroy(entity: Entity) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut().entity_mut(entity).despawn();
+        Ok(())
+    })
+}
+
+/// Teleport. Writes both `Transform` and avian's `Position`/`Rotation` so the
+/// change lands regardless of where in the frame it happens.
+pub fn body_set_transform(entity: Entity, position: Vec3, rotation: Quat) -> Result<()> {
+    app_mut(|app| {
+        let mut e = app.world_mut().entity_mut(entity);
+        let mut transform = e.get_mut::<Transform>().ok_or(PhysicsError::NotABody)?;
+        transform.translation = position;
+        transform.rotation = rotation;
+        if let Some(mut p) = e.get_mut::<Position>() {
+            p.0 = position;
+        }
+        if let Some(mut r) = e.get_mut::<Rotation>() {
+            r.0 = rotation;
+        }
+        Ok(())
+    })
+}
+
+/// Position-only teleport: keeps the current rotation and velocities.
+pub fn body_set_position(entity: Entity, position: Vec3) -> Result<()> {
+    app_mut(|app| {
+        let mut e = app.world_mut().entity_mut(entity);
+        let mut transform = e.get_mut::<Transform>().ok_or(PhysicsError::NotABody)?;
+        transform.translation = position;
+        if let Some(mut p) = e.get_mut::<Position>() {
+            p.0 = position;
+        }
+        Ok(())
+    })
+}
+
+pub fn body_set_linear_velocity(entity: Entity, velocity: Vec3) -> Result<()> {
+    app_mut(|app| {
+        let mut e = app.world_mut().entity_mut(entity);
+        let mut v = e
+            .get_mut::<LinearVelocity>()
+            .ok_or(PhysicsError::NotABody)?;
+        v.0 = velocity;
+        Ok(())
+    })
+}
+
+pub fn body_set_angular_velocity(entity: Entity, velocity: Vec3) -> Result<()> {
+    app_mut(|app| {
+        let mut e = app.world_mut().entity_mut(entity);
+        let mut v = e
+            .get_mut::<AngularVelocity>()
+            .ok_or(PhysicsError::NotABody)?;
+        v.0 = velocity;
+        Ok(())
+    })
+}
+
+pub fn body_apply_impulse(entity: Entity, impulse: Vec3) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(apply_impulse_system, (entity, impulse))
+            .unwrap()
+    })
+}
+
+fn apply_impulse_system(
+    In((entity, impulse)): In<(Entity, Vec3)>,
+    mut bodies: Query<Forces>,
+) -> Result<()> {
+    let mut forces = bodies.get_mut(entity).map_err(|_| PhysicsError::NotABody)?;
+    forces.apply_linear_impulse(impulse);
+    Ok(())
+}
+
+pub fn body_apply_angular_impulse(entity: Entity, impulse: Vec3) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(apply_angular_impulse_system, (entity, impulse))
+            .unwrap()
+    })
+}
+
+fn apply_angular_impulse_system(
+    In((entity, impulse)): In<(Entity, Vec3)>,
+    mut bodies: Query<Forces>,
+) -> Result<()> {
+    let mut forces = bodies.get_mut(entity).map_err(|_| PhysicsError::NotABody)?;
+    forces.apply_angular_impulse(impulse);
+    Ok(())
+}
+
+pub fn body_set_friction(entity: Entity, friction: f32) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(Friction::new(friction));
+        Ok(())
+    })
+}
+
+pub fn body_set_restitution(entity: Entity, restitution: f32) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(Restitution::new(restitution));
+        Ok(())
+    })
+}
+
+pub fn body_set_density(entity: Entity, density: f32) -> Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(ColliderDensity(density));
+        Ok(())
+    })
+}
+
+// ── Readback ────────────────────────────────────────────────────────────────
+
+/// Position (3) + rotation quaternion xyzw (4) for one body.
+pub fn body_get_transform(entity: Entity) -> Result<[f32; 7]> {
+    app_mut(|app| {
+        let e = app.world().entity(entity);
+        let (pos, rot) = read_pose(&e).ok_or(PhysicsError::NotABody)?;
+        Ok([pos.x, pos.y, pos.z, rot.x, rot.y, rot.z, rot.w])
+    })
+}
+
+pub fn body_get_linear_velocity(entity: Entity) -> Result<[f32; 3]> {
+    app_mut(|app| {
+        let v = app
+            .world()
+            .entity(entity)
+            .get::<LinearVelocity>()
+            .ok_or(PhysicsError::NotABody)?
+            .0;
+        Ok([v.x, v.y, v.z])
+    })
+}
+
+fn read_pose(e: &EntityRef) -> Option<(Vec3, Quat)> {
+    // Prefer avian's own components (updated during the step); fall back to
+    // Transform for bodies that haven't simulated yet.
+    match (e.get::<Position>(), e.get::<Rotation>()) {
+        (Some(p), Some(r)) => Some((p.0, r.0)),
+        _ => e.get::<Transform>().map(|t| (t.translation, t.rotation)),
+    }
+}
+
+/// Bulk pose readback: writes 7 floats (pos xyz, quat xyzw) per body into
+/// `out`, which must hold `ids.len() * 7` floats. Bodies that no longer exist
+/// write identity poses. Returns the number of bodies read.
+pub fn read_transforms(ids: &[u64], out: &mut [f32]) -> Result<usize> {
+    assert!(out.len() >= ids.len() * 7);
+    app_mut(|app| {
+        let world = app.world();
+        let mut read = 0;
+        for (i, &id) in ids.iter().enumerate() {
+            let o = &mut out[i * 7..i * 7 + 7];
+            let pose = world
+                .get_entity(Entity::from_bits(id))
+                .ok()
+                .and_then(|e| read_pose(&e));
+            match pose {
+                Some((p, r)) => {
+                    o.copy_from_slice(&[p.x, p.y, p.z, r.x, r.y, r.z, r.w]);
+                    read += 1;
+                }
+                None => o.copy_from_slice(&[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]),
+            }
+        }
+        Ok(read)
+    })
+}
diff --git a/crates/processing_pyo3/src/material.rs b/crates/processing_pyo3/src/material.rs
index 8e033674..e72031da 100644
--- a/crates/processing_pyo3/src/material.rs
+++ b/crates/processing_pyo3/src/material.rs
@@ -100,6 +100,7 @@ fn apply_kwargs(entity: Entity, kwargs: &Bound<'_, PyDict>) -> PyResult<()> {
             "unlit" => material_set_unlit(entity, py_truthy(&value)?).map_err(rt)?,
             "double_sided" => material_set_double_sided(entity, py_truthy(&value)?).map_err(rt)?,
             "depth_write" => material_set_depth_write(entity, py_truthy(&value)?).map_err(rt)?,
+            "depth_bias" => material_set_depth_bias(entity, value.extract::<f32>()?).map_err(rt)?,
             "alpha_mode" => {
                 material_set_alpha_mode(entity, value.extract::<u8>()?, 0.5).map_err(rt)?
             }
diff --git a/crates/processing_render/Cargo.toml b/crates/processing_render/Cargo.toml
index d3af13b0..07e2bf86 100644
--- a/crates/processing_render/Cargo.toml
+++ b/crates/processing_render/Cargo.toml
@@ -38,6 +38,8 @@ bevy = { workspace = true, features = ["file_watcher"] }
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = { version = "0.6", default-features = false }
 objc2-app-kit = { version = "0.3", features = ["NSWindow", "NSView"] }
+objc2-metal = { version = "0.3", features = ["objc2-io-surface"] }
+objc2-io-surface = "0.3"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows = { version = "0.58", features = ["Win32_Foundation", "Win32_System_LibraryLoader"] }
diff --git a/crates/processing_render/src/animation.rs b/crates/processing_render/src/animation.rs
new file mode 100644
index 00000000..d89652b1
--- /dev/null
+++ b/crates/processing_render/src/animation.rs
@@ -0,0 +1,163 @@
+//! Animation pose pools: K paused puppet instances of a rigged glTF scene,
+//! each seeked to k/K of one animation clip, giving K static skeleton poses
+//! whose joint matrices bevy uploads every frame. Instanced particles sample
+//! the pool by a per-particle phase attribute (see `particles/pack.rs`), so
+//! thousands of instances animate at individual phases with no per-instance
+//! animation state — poses are a pure function of the phase attribute, which
+//! keeps frame-clock determinism.
+
+use bevy::animation::{AnimationClip, AnimationPlayer, graph::AnimationGraphHandle};
+use bevy::camera::visibility::{SetViewVisibility, ViewVisibility, VisibilitySystems};
+use bevy::gltf::Gltf;
+use bevy::mesh::skinning::SkinnedMesh;
+use bevy::prelude::*;
+use bevy::world_serialization::WorldInstanceSpawner;
+
+use processing_core::error::{ProcessingError, Result};
+
+pub struct AnimationPoolPlugin;
+
+impl Plugin for AnimationPoolPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(
+            PostUpdate,
+            force_puppet_visibility.in_set(VisibilitySystems::CheckVisibility),
+        );
+    }
+}
+
+/// A pose pool: `slots[k]` is the skinned-mesh entity of the puppet posed at
+/// phase k/K. The render-side pack pipeline reads each slot's live skin
+/// index out of `SkinUniforms` every frame (offsets are not stable).
+#[derive(Component)]
+pub struct SkinPosePool {
+    pub slots: Vec<Entity>,
+    instances: Vec<bevy::world_serialization::InstanceId>,
+}
+
+/// Marker on puppet skinned-mesh entities. Puppets are `Visibility::Hidden`
+/// (never queued for rendering by any view), but skin extraction only
+/// allocates joint matrices for view-visible entities — this marker forces
+/// their `ViewVisibility` through bevy's sanctioned custom-visibility hook so
+/// `SkinUniforms` stays populated.
+#[derive(Component)]
+pub struct SkinPoolPuppet;
+
+fn force_puppet_visibility(mut puppets: Query<&mut ViewVisibility, With<SkinPoolPuppet>>) {
+    for mut view_visibility in &mut puppets {
+        view_visibility.set_visible();
+    }
+}
+
+/// Spawn K paused puppets of `gltf_entity`'s scene, posed along `clip_name`.
+pub fn pool_create(
+    In((gltf_entity, clip_name, k)): In<(Entity, String, u32)>,
+    world: &mut World,
+) -> Result<Entity> {
+    if k == 0 {
+        return Err(ProcessingError::InvalidArgument(
+            "animation pool size must be at least 1".to_string(),
+        ));
+    }
+    let handle = world
+        .get::<crate::gltf::GltfHandle>(gltf_entity)
+        .ok_or(ProcessingError::InvalidEntity)?
+        .gltf_handle()
+        .clone();
+
+    let (scene_handle, clip_handle) = {
+        let gltf_assets = world.resource::<Assets<Gltf>>();
+        let gltf = gltf_assets
+            .get(&handle)
+            .ok_or_else(|| ProcessingError::GltfLoadError("GLTF asset not found".into()))?;
+        let scene = gltf
+            .default_scene
+            .clone()
+            .or_else(|| gltf.scenes.first().cloned())
+            .ok_or_else(|| ProcessingError::GltfLoadError("GLTF has no scenes".into()))?;
+        let clip = gltf.named_animations.get(clip_name.as_str()).cloned().ok_or_else(|| {
+            ProcessingError::GltfLoadError(format!(
+                "Animation '{clip_name}' not found in GLTF (available: {:?})",
+                gltf.named_animations.keys().collect::<Vec<_>>()
+            ))
+        })?;
+        (scene, clip)
+    };
+
+    let duration = world
+        .resource::<Assets<AnimationClip>>()
+        .get(&clip_handle)
+        .ok_or_else(|| ProcessingError::GltfLoadError("Animation clip asset not found".into()))?
+        .duration();
+
+    let (graph, clip_node) = bevy::animation::graph::AnimationGraph::from_clip(clip_handle);
+    let graph_handle = world.resource_mut::<Assets<bevy::animation::graph::AnimationGraph>>().add(graph);
+
+    let mut slots = Vec::with_capacity(k as usize);
+    let mut instances = Vec::with_capacity(k as usize);
+    for pose in 0..k {
+        let seek_time = duration * (pose as f32 / k as f32);
+
+        let instance_id = world.resource_scope(|world, mut spawner: Mut<WorldInstanceSpawner>| {
+            spawner
+                .spawn_sync(world, &scene_handle)
+                .map_err(|e| ProcessingError::GltfLoadError(format!("Puppet spawn failed: {e}")))
+        })?;
+        instances.push(instance_id);
+        let entities: Vec<Entity> = {
+            let spawner = world.resource::<WorldInstanceSpawner>();
+            spawner.iter_instance_entities(instance_id).collect()
+        };
+
+        let mut slot_entity = None;
+        for entity in entities {
+            // Same hygiene as gltf::load: scene cameras must not fight the
+            // sketch's camera.
+            if world.get::<Camera>(entity).is_some() {
+                world.entity_mut(entity).remove::<Camera>();
+            }
+            // Hidden everywhere: puppets exist only to pose joint matrices.
+            if let Some(mut visibility) = world.get_mut::<Visibility>(entity) {
+                *visibility = Visibility::Hidden;
+            }
+            if world.get::<SkinnedMesh>(entity).is_some() {
+                world.entity_mut(entity).insert(SkinPoolPuppet);
+                if slot_entity.is_none() {
+                    slot_entity = Some(entity);
+                }
+            }
+            if world.get::<AnimationPlayer>(entity).is_some() {
+                world
+                    .entity_mut(entity)
+                    .insert(AnimationGraphHandle(graph_handle.clone()));
+                let mut player = world.get_mut::<AnimationPlayer>(entity).unwrap();
+                player.play(clip_node).seek_to(seek_time).pause();
+            }
+        }
+
+        slots.push(slot_entity.ok_or_else(|| {
+            ProcessingError::GltfLoadError(
+                "GLTF scene has no skinned mesh; an animation pool needs a rigged mesh"
+                    .to_string(),
+            )
+        })?);
+    }
+
+    Ok(world.spawn(SkinPosePool { slots, instances }).id())
+}
+
+/// Destroy a pose pool and all K puppet scene instances it spawned.
+pub fn pool_destroy(In(pool_entity): In<Entity>, world: &mut World) -> Result<()> {
+    let instances = world
+        .get::<SkinPosePool>(pool_entity)
+        .ok_or(ProcessingError::InvalidEntity)?
+        .instances
+        .clone();
+    world.resource_scope(|world, mut spawner: Mut<WorldInstanceSpawner>| {
+        for instance_id in &instances {
+            spawner.despawn_instance_sync(world, instance_id);
+        }
+    });
+    world.despawn(pool_entity);
+    Ok(())
+}
diff --git a/crates/processing_render/src/capture_macos.rs b/crates/processing_render/src/capture_macos.rs
new file mode 100644
index 00000000..71cabb97
--- /dev/null
+++ b/crates/processing_render/src/capture_macos.rs
@@ -0,0 +1,197 @@
+//! GPU-resident frame capture into IOSurfaces (macOS only).
+//!
+//! The wgpu side of the hardware recording path: an IOSurface (backing a
+//! CVPixelBuffer owned by the AVFoundation recorder in `processing_video`) is
+//! wrapped as a Metal texture, that texture is wrapped as a wgpu texture via
+//! wgpu-hal, and the canvas is blitted into it on the GPU. A completion
+//! callback registered on the queue reports when the surface actually holds
+//! the frame. No pixel ever crosses to the CPU.
+//!
+//! This module knows nothing about CoreVideo or AVFoundation — it sees only a
+//! raw `IOSurfaceRef` pointer and its stable id. Everything is behind
+//! `cfg(target_os = "macos")` at the module declaration.
+
+use std::collections::HashMap;
+
+use bevy::prelude::*;
+use bevy::render::render_resource::Texture;
+use bevy::render::renderer::{RenderDevice, RenderQueue};
+use objc2::runtime::ProtocolObject;
+use objc2_io_surface::IOSurfaceRef;
+use objc2_metal::{
+    MTLDevice, MTLPixelFormat, MTLStorageMode, MTLTextureDescriptor, MTLTextureType,
+    MTLTextureUsage,
+};
+use processing_core::error::{ProcessingError, Result};
+
+use crate::graphics::Graphics;
+
+/// The pixel layout of every capture surface: BGRA8, with sRGB encode done by
+/// the render hardware on write. Matches the recorder's
+/// `kCVPixelFormatType_32BGRA` pool.
+const CAPTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
+
+/// GPU work the render side hands back once the blit into the surface has
+/// completed on the queue.
+pub type CaptureDone = Box<dyn FnOnce() + Send + 'static>;
+
+/// Per-graphics cache of IOSurface texture wraps. The recorder's pool
+/// recycles a handful of surfaces for the whole recording, so each one is
+/// wrapped exactly once; the map is keyed by the surface's stable id.
+#[derive(Component, Default)]
+pub struct CaptureCache {
+    textures: HashMap<u32, wgpu::Texture>,
+    blitter: Option<wgpu::util::TextureBlitter>,
+    width: u32,
+    height: u32,
+}
+
+/// Wrap an IOSurface as a renderable wgpu texture on bevy's device.
+///
+/// SAFETY contract with the caller: `surface_ptr` is a live `IOSurfaceRef`
+/// whose dimensions are exactly `width`×`height` and whose pixel format is
+/// BGRA8. The Metal texture retains the surface, so the wrap stays valid in
+/// the cache even across the caller releasing its own reference.
+fn wrap_iosurface(
+    device: &wgpu::Device,
+    surface_ptr: usize,
+    width: u32,
+    height: u32,
+) -> Result<wgpu::Texture> {
+    let surface: &IOSurfaceRef = unsafe { &*(surface_ptr as *const IOSurfaceRef) };
+
+    let hal_device = unsafe { device.as_hal::<wgpu::hal::api::Metal>() }.ok_or_else(|| {
+        ProcessingError::InvalidArgument(
+            "GPU capture requires the Metal backend".to_string(),
+        )
+    })?;
+
+    let desc = unsafe {
+        MTLTextureDescriptor::texture2DDescriptorWithPixelFormat_width_height_mipmapped(
+            MTLPixelFormat::BGRA8Unorm_sRGB,
+            width as usize,
+            height as usize,
+            false,
+        )
+    };
+    desc.setUsage(MTLTextureUsage::RenderTarget);
+    desc.setStorageMode(MTLStorageMode::Shared);
+
+    let raw_device: &ProtocolObject<dyn MTLDevice> = hal_device.raw_device();
+    let mtl_texture = raw_device
+        .newTextureWithDescriptor_iosurface_plane(&desc, surface, 0)
+        .ok_or_else(|| {
+            ProcessingError::InvalidArgument("Metal refused to wrap the IOSurface".to_string())
+        })?;
+
+    let hal_texture = unsafe {
+        wgpu::hal::metal::Device::texture_from_raw(
+            mtl_texture,
+            CAPTURE_FORMAT,
+            MTLTextureType::Type2D,
+            1,
+            1,
+            wgpu::hal::CopyExtent {
+                width,
+                height,
+                depth: 1,
+            },
+            None,
+        )
+    };
+    let texture = unsafe {
+        device.create_texture_from_hal::<wgpu::hal::api::Metal>(
+            hal_texture,
+            &wgpu::TextureDescriptor {
+                label: Some("gpu capture iosurface"),
+                size: wgpu::Extent3d {
+                    width,
+                    height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: CAPTURE_FORMAT,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
+            },
+            wgpu::wgt::TextureUses::UNINITIALIZED,
+        )
+    };
+    Ok(texture)
+}
+
+/// Blit the canvas into the given IOSurface and register `on_done` to fire
+/// once the copy has completed on the GPU. The blit converts whatever the
+/// canvas format is (HDR included) into sRGB-encoded BGRA8 — the same plain
+/// blit policy as the readback ring, so captures match the screen.
+pub fn capture_into_surface(
+    In((entity, texture, surface_ptr, surface_id, on_done)): In<(
+        Entity,
+        Texture,
+        usize,
+        u32,
+        CaptureDone,
+    )>,
+    world: &mut World,
+) -> Result<()> {
+    let render_device = world.resource::<RenderDevice>().clone();
+    let render_queue = world.resource::<RenderQueue>().clone();
+    let size = world
+        .get::<Graphics>(entity)
+        .ok_or(ProcessingError::GraphicsNotFound)?
+        .size;
+
+    if world.get::<CaptureCache>(entity).is_none() {
+        world.entity_mut(entity).insert(CaptureCache::default());
+    }
+    {
+        let mut cache = world.get_mut::<CaptureCache>(entity).unwrap();
+        if cache.width != size.width || cache.height != size.height {
+            cache.textures.clear();
+            cache.width = size.width;
+            cache.height = size.height;
+        }
+        if !cache.textures.contains_key(&surface_id) {
+            let wrapped =
+                wrap_iosurface(render_device.wgpu_device(), surface_ptr, size.width, size.height)?;
+            cache.textures.insert(surface_id, wrapped);
+        }
+        if cache.blitter.is_none() {
+            cache.blitter = Some(wgpu::util::TextureBlitter::new(
+                render_device.wgpu_device(),
+                CAPTURE_FORMAT,
+            ));
+        }
+    }
+
+    let cache = world.get::<CaptureCache>(entity).unwrap();
+    let dst = cache.textures.get(&surface_id).unwrap();
+    let blitter = cache.blitter.as_ref().unwrap();
+
+    let src_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+    let dst_view = dst.create_view(&wgpu::TextureViewDescriptor::default());
+    let mut encoder = render_device
+        .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+            label: Some("gpu capture blit"),
+        });
+    blitter.copy(
+        render_device.wgpu_device(),
+        &mut encoder,
+        &src_view,
+        &dst_view,
+    );
+    render_queue.submit(std::iter::once(encoder.finish()));
+    render_queue.on_submitted_work_done(on_done);
+    Ok(())
+}
+
+/// Drop the capture cache (wrapped textures and blitter) for a graphics.
+/// Called when a recording ends; the pool the surfaces came from is gone.
+pub fn capture_reset(In(entity): In<Entity>, world: &mut World) -> Result<()> {
+    if let Ok(mut e) = world.get_entity_mut(entity) {
+        e.remove::<CaptureCache>();
+    }
+    Ok(())
+}
diff --git a/crates/processing_render/src/compute.rs b/crates/processing_render/src/compute.rs
index d9e98e10..1f8b7d94 100644
--- a/crates/processing_render/src/compute.rs
+++ b/crates/processing_render/src/compute.rs
@@ -363,6 +363,24 @@ pub fn dispatch(
             }
         }
 
+        // A short bind group is a FATAL wgpu validation error, not a warning.
+        // `create_bindings` skips any parameter it can't resolve yet (an
+        // unset buffer/texture, or a GpuImage/GpuShaderBuffer asset not
+        // prepared in this frame) — fail with the parameter names instead.
+        if bindings.len() != desc.entries.len() {
+            let bound: Vec<u32> = bindings.iter().map(|(b, _)| *b).collect();
+            let missing: Vec<String> = reflection
+                .parameters()
+                .filter(|p| p.group() == *group && !bound.contains(&p.binding()))
+                .filter_map(|p| p.name().map(|n| n.to_string()))
+                .collect();
+            return Err(ProcessingError::InvalidArgument(format!(
+                "compute dispatch: unresolved @group({group}) bindings {missing:?} — \
+                 set them with set-uniforms! (a texture created this frame needs one \
+                 engine update before it can bind; draw a frame first)"
+            )));
+        }
+
         let bind_group_entries: Vec<_> = bindings
             .iter()
             .map(
diff --git a/crates/processing_render/src/gltf.rs b/crates/processing_render/src/gltf.rs
index 7b9397be..147dea9b 100644
--- a/crates/processing_render/src/gltf.rs
+++ b/crates/processing_render/src/gltf.rs
@@ -9,6 +9,7 @@ use bevy::{
     camera::visibility::RenderLayers,
     ecs::system::RunSystemOnce,
     gltf::{Gltf, GltfMaterial, GltfMeshName},
+    mesh::Indices,
     pbr::ExtendedMaterial,
     prelude::*,
     world_serialization::WorldInstanceSpawner,
@@ -18,6 +19,7 @@ use crate::geometry::{BuiltinAttributes, Geometry, layout::VertexLayout};
 use crate::graphics;
 use crate::material::ProcessingMaterial;
 use crate::render::material::{ProcessingExtendedMaterial, UntypedMaterial};
+use crate::render::primitive::ensure_vertex_colors;
 use processing_core::config::{Config, ConfigKey};
 use processing_core::error::{ProcessingError, Result};
 
@@ -71,6 +73,12 @@ pub struct GltfHandle {
     graphics_entity: Entity,
 }
 
+impl GltfHandle {
+    pub(crate) fn gltf_handle(&self) -> &Handle<Gltf> {
+        &self.handle
+    }
+}
+
 pub fn load(
     In((graphics_entity, path)): In<(Entity, String)>,
     world: &mut World,
@@ -128,6 +136,22 @@ pub fn load(
     Ok(entity)
 }
 
+/// Destroy a loaded glTF handle and the scene instance spawned for queries.
+/// Shapes/materials explicitly extracted from it are independent Processing
+/// resources and retain their own handles until their respective destroy API
+/// is called.
+pub fn destroy(In(gltf_entity): In<Entity>, world: &mut World) -> Result<()> {
+    let instance_id = world
+        .get::<GltfHandle>(gltf_entity)
+        .ok_or(ProcessingError::InvalidEntity)?
+        .instance_id;
+    world.resource_scope(|world, mut spawner: Mut<WorldInstanceSpawner>| {
+        spawner.despawn_instance_sync(world, &instance_id);
+    });
+    world.despawn(gltf_entity);
+    Ok(())
+}
+
 pub fn geometry(
     In((gltf_entity, name)): In<(Entity, String)>,
     world: &mut World,
@@ -165,6 +189,8 @@ pub fn geometry(
         (handle, transform)
     };
 
+    prepare_for_draw(world, &mesh_handle);
+
     let builtins = world.resource::<BuiltinAttributes>();
     let attrs = vec![
         builtins.position,
@@ -182,6 +208,39 @@ pub fn geometry(
     Ok(entity)
 }
 
+/// Bring a gltf mesh up to the shape the immediate-mode draw paths expect.
+///
+/// Meshes the engine builds itself all carry an index buffer and a vertex
+/// color attribute, and the `VertexLayout` this module declares for a gltf
+/// geometry names `color` too. A gltf primitive is whatever the file and the
+/// loader between them produced, so both have to be guaranteed here instead of
+/// assumed. Neither changes how the mesh looks.
+fn prepare_for_draw(world: &mut World, handle: &Handle<Mesh>) {
+    let mut meshes = world.resource_mut::<Assets<Mesh>>();
+    let Some(mut mesh) = meshes.get_mut(handle) else {
+        return;
+    };
+    ensure_indexed(&mut mesh);
+    ensure_vertex_colors(&mut mesh);
+}
+
+/// Give a mesh the trivial index buffer if it arrived without one, so that
+/// `stroke()` can draw it.
+///
+/// The wireframe pass pulls its vertices through the index buffer and quietly
+/// skips any mesh that has none, so a non-indexed mesh cannot be outlined --
+/// and gltf primitives commonly arrive without indices. `0..n` names
+/// exactly the vertices the draw already walks in exactly the order it walks
+/// them, so this changes nothing about how the mesh renders; it only gives
+/// the wireframe pass the handle it needs.
+fn ensure_indexed(mesh: &mut Mesh) {
+    if mesh.indices().is_some() {
+        return;
+    }
+    let count = mesh.count_vertices() as u32;
+    mesh.insert_indices(Indices::U32((0..count).collect()));
+}
+
 /// Translate a bevy [`GltfMaterial`] into the [`StandardMaterial`] base of a
 /// [`ProcessingExtendedMaterial`]. `GltfMaterial` mirrors `StandardMaterial`'s
 /// fields, so we copy across the ones that drive shading and let the rest fall
diff --git a/crates/processing_render/src/graphics.rs b/crates/processing_render/src/graphics.rs
index bce83fa7..83b7de6c 100644
--- a/crates/processing_render/src/graphics.rs
+++ b/crates/processing_render/src/graphics.rs
@@ -4,14 +4,16 @@
 //! In Bevy terms, a graphics object is represented as an entity with a camera component
 //! configured to render to a specific surface (either a window or an offscreen image).
 use bevy::{
+    anti_alias::taa::TemporalAntiAliasing,
     camera::{
         CameraMainTextureUsages, CameraOutputMode, CameraProjection, ClearColorConfig, Hdr,
         ImageRenderTarget, MsaaWriteback, Projection, RenderTarget, visibility::RenderLayers,
     },
+    core_pipeline::prepass::{DepthPrepass, MotionVectorPrepass},
     core_pipeline::tonemapping::Tonemapping,
     ecs::query::QueryEntityError,
+    pbr::contact_shadows::ContactShadows,
     math::{Mat4, Vec3A},
-    post_process::bloom::Bloom,
     prelude::*,
     render::{
         RenderApp,
@@ -30,7 +32,7 @@ use crate::{
     Flush,
     image::{Image, create_readback_buffer, pixel_size, pixels_to_bytes},
     render::{
-        BATCH_INDEX_STEP, RenderState,
+        BATCH_INDEX_STEP, NEAR_HEADROOM, RenderState,
         command::{CommandBuffer, DrawCommand},
         filter,
     },
@@ -49,6 +51,16 @@ impl Plugin for GraphicsPlugin {
     }
 }
 
+/// Marks a canvas that holds SIMULATION STATE rather than a picture:
+/// feedback patches, accumulators, reaction-diffusion fields. Such a canvas
+/// is guaranteed post-process-free — bloom and tonemapping are never applied,
+/// because both write back THROUGH the view target and would re-transform the
+/// stored state every frame (tonemapping converges it to the tonemapper's
+/// fixed point, which looks like a mysterious blur/wash bug). Draws into it
+/// also write LINEAR color, so values round-trip exactly.
+#[derive(Component)]
+pub struct StateCanvas;
+
 #[derive(Component)]
 pub struct Graphics {
     readback_buffer: bevy::render::render_resource::Buffer,
@@ -101,13 +113,29 @@ impl ProcessingProjection {
 
 impl CameraProjection for ProcessingProjection {
     fn get_clip_from_view(&self) -> Mat4 {
+        // Depth is REVERSED (near -> 1, far -> 0), which an ortho expresses by
+        // swapping near and far in the standard formula. Everything else in
+        // the pipeline assumes it: the depth test is GreaterEqual, the depth
+        // buffer clears to 0 = far, bevy's own OrthographicProjection swaps
+        // for this reason, FrustumProjection below derives the same convention
+        // by hand, and world_from_screen unprojects with `1.0 - depth`.
+        //
+        // Unswapped, this projection alone ran forward-z, and every depth
+        // comparison in 2d came out backwards: a later draw LOST to an earlier
+        // one, and the background/clear quad -- built at ndc_z ~= 0, the far
+        // plane under reverse-z (create_ndc_background_quad) -- landed on the
+        // NEAR plane, where it sorted last in Transparent3d and repainted over
+        // every blended draw in the frame. That is what made blended draws
+        // vanish inside offscreen canvases.
+        //
+        // NEAR_HEADROOM opens the near side for the per-batch z staircase.
         Mat4::orthographic_rh(
             0.0,
             self.width,
             self.height, // bottom = height
             0.0,         // top = 0
-            self.near,
             self.far,
+            self.near - NEAR_HEADROOM,
         )
     }
 
@@ -219,7 +247,13 @@ impl CameraProjection for FrustumProjection {
 }
 
 pub fn create(
-    In((width, height, surface_entity, texture_format)): In<(u32, u32, Entity, TextureFormat)>,
+    In((width, height, surface_entity, texture_format, state)): In<(
+        u32,
+        u32,
+        Entity,
+        TextureFormat,
+        bool,
+    )>,
     mut commands: Commands,
     mut layer_manager: ResMut<RenderLayersManager>,
     p_images: Query<&Image, With<Surface>>,
@@ -287,7 +321,18 @@ pub fn create(
         render_layer,
         CommandBuffer::new(),
         RenderState::default(),
-        crate::color::ColorMode::default(),
+        // A state canvas takes LINEAR color: the host normalizes fill/stroke
+        // to 0..1 and the engine would otherwise read those as sRGB, so
+        // fill(0.5) would land at linear 0.21 — fatal when the "color" is a
+        // reagent concentration rather than a picture.
+        if state {
+            crate::color::ColorMode {
+                space: crate::color::ColorSpace::Linear,
+                max: [1.0; 4],
+            }
+        } else {
+            crate::color::ColorMode::default()
+        },
         SurfaceSize(width, height),
         Graphics {
             readback_buffer,
@@ -296,8 +341,28 @@ pub fn create(
         },
     ));
 
-    if is_hdr {
-        entity_commands.insert((Hdr, Bloom::NATURAL, Tonemapping::TonyMcMapface));
+    // Physical-lux contract: EV100 9.7 (Blender's default, and bevy's own
+    // implicit default) unless overridden for calibration probes.
+    entity_commands.insert(bevy::camera::Exposure {
+        ev100: std::env::var("PROCESSING_EV100")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(9.7),
+    });
+
+    if state {
+        // Float precision, zero post-processing: the canvas IS the data.
+        entity_commands.insert((StateCanvas, Hdr));
+    } else if is_hdr {
+        // Bloom is OPT-IN: a canvas gets HDR + the tonemapper, but no bloom
+        // until `bloom()` asks for it. Shipping `Bloom::NATURAL` here meant
+        // every canvas had UN-THRESHOLDED bloom (intensity 0.15, prefilter
+        // threshold 0.0) without asking — which contradicts the documented
+        // API (`no_bloom` "disables bloom previously enabled with bloom")
+        // and, in a dense scene, hazes the whole frame including areas with
+        // nothing drawn in them. It also skips the bloom node entirely when
+        // unused, which is free performance at show resolutions.
+        entity_commands.insert((Hdr, Tonemapping::TonyMcMapface));
     }
 
     // TEMP(bevy-020 debug): force direct drawing to bisect the indirect-args
@@ -311,6 +376,85 @@ pub fn create(
     Ok(entity)
 }
 
+/// Turn screen-space contact shadows on or off for this canvas' camera.
+///
+/// Contact shadows are the short dark line where two surfaces meet -- box on
+/// box, box on ground. Shadow maps do the big forms; at cascade resolution
+/// they cannot resolve a contact, which is what makes a dense pile of objects
+/// read as one mass instead of many things.
+///
+/// `length` is in WORLD units, not pixels: it is how far the ray marches from
+/// the contact, so it scales with the scene, not with the window. `thickness`
+/// is likewise world units -- the depth buffer only carries 2.5D information,
+/// so the effect has to assume some thickness for what it finds there.
+/// `linear_steps` is the per-pixel raymarch step count, and the one to spend
+/// down if the effect costs too much at delivery resolution.
+///
+/// A canvas is a camera here, so this applies to whichever canvas is passed:
+/// the primary, a `create_offscreen` buffer, or a `create_window` canvas.
+///
+/// `ContactShadows` requires a depth prepass, which bevy attaches for us. We
+/// take it away again on disable -- nothing else in the engine asks for a
+/// prepass, so leaving one running would be paying for a full depth pass per
+/// frame to feed an effect that is off.
+pub fn set_contact_shadows(
+    In((entity, enabled, linear_steps, thickness, length)): In<(Entity, bool, u32, f32, f32)>,
+    mut commands: Commands,
+    graphics: Query<(), With<Graphics>>,
+) -> Result<()> {
+    graphics
+        .get(entity)
+        .map_err(|_| ProcessingError::GraphicsNotFound)?;
+
+    if enabled {
+        commands.entity(entity).insert(ContactShadows {
+            linear_steps,
+            thickness,
+            length,
+        });
+    } else {
+        commands
+            .entity(entity)
+            .remove::<ContactShadows>()
+            .remove::<DepthPrepass>();
+    }
+    Ok(())
+}
+
+/// Turn temporal antialiasing on or off for this canvas' camera.
+///
+/// Kept separate from `set_contact_shadows` deliberately, even though bevy's
+/// own contact-shadows example pairs them: TAA rewrites how the WHOLE canvas
+/// is antialiased, adds a motion-vector prepass, and jitters the projection
+/// every frame. Turning that on as a side effect of asking for a lighting
+/// detail would be a large, invisible change to a sketch's whole image.
+///
+/// TAA requires MSAA off -- the two are different answers to the same
+/// question and bevy cannot run both -- so this switches MSAA off with it and
+/// restores the default sample count on the way out.
+pub fn set_temporal_aa(
+    In((entity, enabled)): In<(Entity, bool)>,
+    mut commands: Commands,
+    graphics: Query<(), With<Graphics>>,
+) -> Result<()> {
+    graphics
+        .get(entity)
+        .map_err(|_| ProcessingError::GraphicsNotFound)?;
+
+    if enabled {
+        commands
+            .entity(entity)
+            .insert((TemporalAntiAliasing::default(), Msaa::Off));
+    } else {
+        commands
+            .entity(entity)
+            .remove::<TemporalAntiAliasing>()
+            .remove::<MotionVectorPrepass>()
+            .insert(Msaa::default());
+    }
+    Ok(())
+}
+
 #[allow(dead_code)]
 pub fn resize(
     In((entity, width, height)): In<(Entity, u32, u32)>,
@@ -579,9 +723,17 @@ pub fn set_bloom(
     In((entity, intensity, threshold)): In<(Entity, f32, f32)>,
     mut commands: Commands,
     mut tonemapping_query: Query<&mut Tonemapping>,
+    state_canvases: Query<(), With<StateCanvas>>,
 ) -> Result<()> {
     use bevy::post_process::bloom::{Bloom, BloomCompositeMode, BloomPrefilter};
 
+    // Post-processing on a state canvas would corrupt the stored state; the
+    // guarantee is the whole point of asking for one.
+    if state_canvases.get(entity).is_ok() {
+        warn!("bloom() ignored: this graphics is a state canvas (post-process-free by contract)");
+        return Ok(());
+    }
+
     let mut bloom = Bloom::NATURAL;
     bloom.intensity = intensity;
     if threshold > 0.0 {
@@ -635,6 +787,7 @@ pub fn destroy(
 }
 
 pub fn begin_draw(In(entity): In<Entity>, mut state_query: Query<&mut RenderState>) -> Result<()> {
+    if std::env::var("PROCESSING_TRACE_VT").is_ok() { eprintln!("ENGINE begin_draw ==== FRAME ===="); }
     let mut state = state_query
         .get_mut(entity)
         .map_err(|_| ProcessingError::GraphicsNotFound)?;
@@ -682,10 +835,80 @@ pub fn screen_point(
     ))
 }
 
+/// A canvas that has finished a frame and is waiting for the next
+/// `app.update()` to put it on screen, instead of forcing an update of its
+/// own. See [`arm_present`].
+#[derive(Component)]
+pub struct PendingPresent;
+
+/// Arm `entity` to present on the next update rather than presenting now.
+///
+/// `present` costs a whole `app.update()` — around 3ms of fixed CPU work
+/// regardless of what was drawn — so a sketch driving N windows through the
+/// usual `endDraw`-per-canvas path pays N of them per frame and falls off a
+/// cliff by a couple of dozen windows. The renderer never needed that: a
+/// camera is active exactly when its graphics carries `Flush`
+/// (`render::activate_cameras`), so any number of canvases can render and
+/// present within a SINGLE update. Arming marks the canvas ready and leaves
+/// the update to whoever runs one next — in practice the primary window's
+/// `endDraw`, which Processing always calls at the end of every frame.
+///
+/// Only safe for canvases nothing samples back: a window surface is never an
+/// image source, so no draw call can observe the delay. Offscreen buffers
+/// keep presenting synchronously.
+pub fn arm_present(app: &mut App, entity: Entity) -> Result<()> {
+    let mut graphics = graphics_mut!(app, entity);
+    graphics
+        .get_mut::<Camera>()
+        .ok_or(ProcessingError::GraphicsNotFound)?
+        .output_mode = CameraOutputMode::Write {
+        blend_state: None,
+        clear_color: ClearColorConfig::None,
+    };
+    graphics.insert((Flush, PendingPresent));
+    Ok(())
+}
+
+/// Stand every armed canvas back down after an update presented it.
+fn disarm_pending(app: &mut App) {
+    let world = app.world_mut();
+    let armed: Vec<Entity> = world
+        .query_filtered::<Entity, With<PendingPresent>>()
+        .iter(world)
+        .collect();
+    for entity in armed {
+        let Ok(mut graphics) = world.get_entity_mut(entity) else {
+            continue;
+        };
+        if let Some(mut camera) = graphics.get_mut::<Camera>() {
+            camera.output_mode = CameraOutputMode::Skip;
+        }
+        graphics.remove::<(Flush, PendingPresent)>();
+    }
+}
+
+/// Whether `entity` has draw commands recorded since its last flush.
+///
+/// A canvas with an empty command buffer has already rendered everything it
+/// was asked to, so flushing it again is a whole wasted `app.update()`. The
+/// blit path (`image(pg, ...)`) flushes its source defensively, which at a
+/// hundred-odd offscreen canvases per frame is the single largest cost in the
+/// frame; this lets it skip the ones that are already clean.
+pub fn has_pending(In(entity): In<Entity>, buffers: Query<&CommandBuffer>) -> Result<bool> {
+    Ok(!buffers
+        .get(entity)
+        .map_err(|_| ProcessingError::GraphicsNotFound)?
+        .commands
+        .is_empty())
+}
+
 pub fn flush(app: &mut App, entity: Entity) -> Result<()> {
+    if std::env::var("PROCESSING_TRACE_VT").is_ok() { eprintln!("ENGINE flush+update"); }
     graphics_mut!(app, entity).insert(Flush);
     app.update();
     graphics_mut!(app, entity).remove::<Flush>();
+    // Whatever was armed for presentation rode along on that update.
+    disarm_pending(app);
     Ok(())
 }
 
@@ -755,25 +978,66 @@ pub struct ReadbackData {
 }
 
 pub fn readback_raw(
-    In((entity, texture)): In<(Entity, Texture)>,
-    graphics_query: Query<&Graphics>,
-    render_device: Res<RenderDevice>,
-    render_queue: Res<RenderQueue>,
+    In((entity, texture, lut_view)): In<(Entity, Texture, Option<wgpu::TextureView>)>,
+    world: &mut World,
 ) -> Result<ReadbackData> {
-    let graphics = graphics_query
-        .get(entity)
-        .map_err(|_| ProcessingError::GraphicsNotFound)?;
+    let render_device = world.resource::<RenderDevice>().clone();
+    let render_queue = world.resource::<RenderQueue>().clone();
+    let (source_format, size, readback_buffer) = {
+        let graphics = world
+            .get::<Graphics>(entity)
+            .ok_or(ProcessingError::GraphicsNotFound)?;
+        (
+            graphics.texture_format,
+            graphics.size,
+            graphics.readback_buffer.clone(),
+        )
+    };
 
-    let mut encoder = render_device.create_command_encoder(&CommandEncoderDescriptor::default());
+    // Same conversion policy as the async ring: 8-bit surfaces read back
+    // as-is; HDR surfaces convert on the GPU to 8-bit sRGB, honoring the
+    // camera's tonemapping — so q/save/loadPixels see what the screen shows.
+    let needs_convert = !matches!(
+        source_format,
+        TextureFormat::Rgba8UnormSrgb
+            | TextureFormat::Rgba8Unorm
+            | TextureFormat::Bgra8UnormSrgb
+            | TextureFormat::Bgra8Unorm
+    );
+    let format = if needs_convert {
+        TextureFormat::Rgba8UnormSrgb
+    } else {
+        source_format
+    };
+    let px_size = pixel_size(format)?;
+    let bytes_per_row = size.width as usize * px_size;
+    let padded_bytes_per_row = RenderDevice::align_copy_bytes_per_row(bytes_per_row);
+
+    if world.get::<ReadbackRing>(entity).is_none() {
+        world.entity_mut(entity).insert(ReadbackRing::default());
+    }
+    let copy_src = prepare_convert_source(
+        world,
+        entity,
+        &render_device,
+        &texture,
+        needs_convert,
+        size,
+        &lut_view,
+    );
 
-    let px_size = pixel_size(graphics.texture_format)?;
-    let padded_bytes_per_row =
-        RenderDevice::align_copy_bytes_per_row(graphics.size.width as usize * px_size);
+    let mut encoder = render_device.create_command_encoder(&CommandEncoderDescriptor::default());
+    if needs_convert {
+        let src_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let ring = world.get::<ReadbackRing>(entity).unwrap();
+        let convert = ring.convert.as_ref().unwrap();
+        record_convert(&render_device, &mut encoder, convert, &src_view);
+    }
 
     encoder.copy_texture_to_buffer(
-        texture.as_image_copy(),
+        copy_src.as_image_copy(),
         TexelCopyBufferInfo {
-            buffer: &graphics.readback_buffer,
+            buffer: &readback_buffer,
             layout: TexelCopyBufferLayout {
                 offset: 0,
                 bytes_per_row: Some(
@@ -784,12 +1048,15 @@ pub fn readback_raw(
                 rows_per_image: None,
             },
         },
-        graphics.size,
+        size,
     );
 
     render_queue.submit(std::iter::once(encoder.finish()));
 
-    let buffer_slice = graphics.readback_buffer.slice(..);
+    // The readback buffer is sized for the (larger or equal) source format;
+    // map only the region this copy wrote.
+    let mapped_len = padded_bytes_per_row as u64 * size.height as u64;
+    let buffer_slice = readback_buffer.slice(..mapped_len);
 
     let (s, r) = crossbeam_channel::bounded(1);
 
@@ -809,13 +1076,12 @@ pub fn readback_raw(
         .expect("Failed to get mapped range for readback")
         .to_vec();
 
-    graphics.readback_buffer.unmap();
+    readback_buffer.unmap();
 
     // strip row padding
-    let bytes_per_row = graphics.size.width as usize * px_size;
     let unpadded = if padded_bytes_per_row != bytes_per_row {
         data.chunks_exact(padded_bytes_per_row)
-            .take(graphics.size.height as usize)
+            .take(size.height as usize)
             .flat_map(|row| &row[..bytes_per_row])
             .copied()
             .collect()
@@ -825,9 +1091,9 @@ pub fn readback_raw(
 
     Ok(ReadbackData {
         bytes: unpadded,
-        format: graphics.texture_format,
-        width: graphics.size.width,
-        height: graphics.size.height,
+        format,
+        width: size.width,
+        height: size.height,
     })
 }
 
@@ -846,9 +1112,19 @@ pub fn readback_raw(
 /// producer can run ahead.
 pub const READBACK_RING_DEPTH: usize = 3;
 
+/// A queued readback's mapping is still in flight.
+const READBACK_PENDING: u8 = 0;
+/// It mapped, and the bytes can be read.
+const READBACK_READY: u8 = 1;
+/// It will never map. wgpu calls the `map_async` callback with an error when
+/// the device goes away underneath a copy that is still in flight, which is
+/// the ordinary way a recording sketch exits: the window closes, the device is
+/// torn down, and whatever was queued that frame aborts.
+const READBACK_FAILED: u8 = 2;
+
 struct PendingReadback {
     buffer: bevy::render::render_resource::Buffer,
-    ready: std::sync::Arc<std::sync::atomic::AtomicBool>,
+    state: std::sync::Arc<std::sync::atomic::AtomicU8>,
     /// The copy's own submission, so a blocking fetch waits for exactly this
     /// copy — waiting for "the most recent submission" would drain the whole
     /// queue (including newer copies and the in-flight render) and serialize
@@ -862,19 +1138,308 @@ struct PendingReadback {
 }
 
 /// GPU-side format conversion in front of the readback: HDR (or any
-/// non-8-bit) surfaces are blitted into an 8-bit sRGB texture BEFORE the
+/// non-8-bit) surfaces are converted into an 8-bit sRGB texture BEFORE the
 /// copy, so the readback moves half the bytes and the CPU never touches a
 /// float pixel. (A 3840×4320 Rgba16Float frame is 132MB and a per-pixel CPU
 /// conversion of it costs ~350ms — it, not the copy, was the recording
 /// bottleneck.)
+///
+/// The conversion honors the camera's tonemapping so captures match the
+/// screen: `Tonemapping::None` (the show's calibrated mode) is a plain blit
+/// — byte-identical to the previous behavior — while `TonyMcMapface` runs
+/// bevy's own LUT in a tiny fullscreen pass. Without this, captures of lit
+/// scenes read the raw HDR canvas and clamp everything bright to white.
+enum ConvertMode {
+    Blit(wgpu::util::TextureBlitter),
+    Tonemap {
+        pipeline: wgpu::RenderPipeline,
+        bind_group_layout: wgpu::BindGroupLayout,
+        lut_view: wgpu::TextureView,
+        lut_sampler: wgpu::Sampler,
+    },
+}
+
 struct ConvertPass {
     texture: wgpu::Texture,
     view: wgpu::TextureView,
-    blitter: wgpu::util::TextureBlitter,
+    mode: ConvertMode,
     width: u32,
     height: u32,
 }
 
+/// Matches bevy's `sample_tony_mc_mapface_lut` (tonemapping_shared.wgsl);
+/// exposure is already pre-applied during shading, so tonemapping is the
+/// only remaining display transform. Output target is Rgba8UnormSrgb, so
+/// the hardware performs the sRGB encode.
+const TONEMAP_CONVERT_SHADER: &str = r#"
+@group(0) @binding(0) var hdr_tex: texture_2d<f32>;
+@group(0) @binding(1) var lut_tex: texture_3d<f32>;
+@group(0) @binding(2) var lut_smp: sampler;
+
+@vertex
+fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+    let uv = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+    return vec4<f32>(uv * 2.0 - 1.0, 0.0, 1.0);
+}
+
+const LUT_DIMS: f32 = 48.0;
+
+fn tony_mc_mapface(stimulus: vec3<f32>) -> vec3<f32> {
+    let uv = saturate(
+        (stimulus / (stimulus + 1.0)) * ((LUT_DIMS - 1.0) / LUT_DIMS) + 0.5 / LUT_DIMS,
+    );
+    return textureSampleLevel(lut_tex, lut_smp, uv, 0.0).rgb;
+}
+
+@fragment
+fn fs(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    let c = textureLoad(hdr_tex, vec2<i32>(pos.xy), 0);
+    return vec4<f32>(tony_mc_mapface(max(c.rgb, vec3<f32>(0.0))), 1.0);
+}
+"#;
+
+fn build_tonemap_convert(
+    device: &wgpu::Device,
+    lut_view: wgpu::TextureView,
+) -> ConvertMode {
+    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: Some("readback tonemap convert"),
+        source: wgpu::ShaderSource::Wgsl(TONEMAP_CONVERT_SHADER.into()),
+    });
+    let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        label: Some("readback tonemap convert"),
+        entries: &[
+            wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+                count: None,
+            },
+            wgpu::BindGroupLayoutEntry {
+                binding: 1,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    view_dimension: wgpu::TextureViewDimension::D3,
+                    multisampled: false,
+                },
+                count: None,
+            },
+            wgpu::BindGroupLayoutEntry {
+                binding: 2,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                count: None,
+            },
+        ],
+    });
+    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: Some("readback tonemap convert"),
+        bind_group_layouts: &[Some(&bind_group_layout)],
+        immediate_size: 0,
+    });
+    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("readback tonemap convert"),
+        layout: Some(&layout),
+        vertex: wgpu::VertexState {
+            module: &shader,
+            entry_point: Some("vs"),
+            compilation_options: Default::default(),
+            buffers: &[],
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: &shader,
+            entry_point: Some("fs"),
+            compilation_options: Default::default(),
+            targets: &[Some(wgpu::ColorTargetState {
+                format: wgpu::TextureFormat::Rgba8UnormSrgb,
+                blend: None,
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        primitive: wgpu::PrimitiveState::default(),
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState::default(),
+        multiview_mask: None,
+        cache: None,
+    });
+    let lut_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+        label: Some("readback tonemap lut"),
+        mag_filter: wgpu::FilterMode::Linear,
+        min_filter: wgpu::FilterMode::Linear,
+        mipmap_filter: wgpu::MipmapFilterMode::Linear,
+        address_mode_u: wgpu::AddressMode::ClampToEdge,
+        address_mode_v: wgpu::AddressMode::ClampToEdge,
+        address_mode_w: wgpu::AddressMode::ClampToEdge,
+        ..Default::default()
+    });
+    ConvertMode::Tonemap {
+        pipeline,
+        bind_group_layout,
+        lut_view,
+        lut_sampler,
+    }
+}
+
+/// Ensure the graphics' convert pass matches the current size and camera
+/// tonemapping, and return the texture the readback copy should read from.
+/// The capture must show what the camera setting shows: TonyMcMapface runs
+/// the LUT pass; None (and, conservatively, any variant we don't replicate)
+/// is a plain blit — the raw-linear behavior every calibrated-unlit sketch
+/// depends on.
+fn prepare_convert_source(
+    world: &mut World,
+    entity: Entity,
+    render_device: &RenderDevice,
+    texture: &Texture,
+    needs_convert: bool,
+    size: Extent3d,
+    lut_view: &Option<wgpu::TextureView>,
+) -> wgpu::Texture {
+    if !needs_convert {
+        // bevy's Texture derefs to the raw wgpu texture.
+        return wgpu::Texture::clone(texture);
+    }
+    // The canvas texture is the camera's render TARGET: bevy's tonemapping
+    // node has already been applied by the time anything lands in it, for
+    // every Tonemapping mode. Running the LUT here again double-tonemaps —
+    // tony(tony(x)) plateaus at tony(1.0) ≈ sRGB 169, which masked the whole
+    // lit-exposure miscalibration (captures showed flat grey while the
+    // window was hot white). Readback is therefore ALWAYS a plain blit.
+    let want_tonemap = false;
+    let _ = lut_view;
+
+    let stale = match world.get::<ReadbackRing>(entity).unwrap().convert {
+        Some(ref c) => {
+            c.width != size.width
+                || c.height != size.height
+                || matches!(c.mode, ConvertMode::Tonemap { .. }) != want_tonemap
+        }
+        None => true,
+    };
+    if stale {
+        let device = render_device.wgpu_device();
+        let tex = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("async readback convert target"),
+            size: wgpu::Extent3d {
+                width: size.width,
+                height: size.height,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: TextureFormat::Rgba8UnormSrgb,
+            usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
+        let mode = if want_tonemap {
+            build_tonemap_convert(device, lut_view.clone().unwrap())
+        } else {
+            ConvertMode::Blit(wgpu::util::TextureBlitter::new(
+                device,
+                TextureFormat::Rgba8UnormSrgb,
+            ))
+        };
+        world.get_mut::<ReadbackRing>(entity).unwrap().convert = Some(ConvertPass {
+            texture: tex,
+            view,
+            mode,
+            width: size.width,
+            height: size.height,
+        });
+    }
+    world
+        .get::<ReadbackRing>(entity)
+        .unwrap()
+        .convert
+        .as_ref()
+        .unwrap()
+        .texture
+        .clone()
+}
+
+/// Record the convert (blit or tonemap) into `encoder`, writing the source
+/// into the convert pass's sRGB8 target.
+fn record_convert(
+    render_device: &RenderDevice,
+    encoder: &mut wgpu::CommandEncoder,
+    convert: &ConvertPass,
+    src_view: &wgpu::TextureView,
+) {
+    match &convert.mode {
+        ConvertMode::Blit(blitter) => {
+            blitter.copy(render_device.wgpu_device(), encoder, src_view, &convert.view);
+        }
+        ConvertMode::Tonemap {
+            pipeline,
+            bind_group_layout,
+            lut_view,
+            lut_sampler,
+        } => {
+            let bind_group = render_device
+                .wgpu_device()
+                .create_bind_group(&wgpu::BindGroupDescriptor {
+                    label: Some("readback tonemap convert"),
+                    layout: bind_group_layout,
+                    entries: &[
+                        wgpu::BindGroupEntry {
+                            binding: 0,
+                            resource: wgpu::BindingResource::TextureView(src_view),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 1,
+                            resource: wgpu::BindingResource::TextureView(lut_view),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 2,
+                            resource: wgpu::BindingResource::Sampler(lut_sampler),
+                        },
+                    ],
+                });
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("readback tonemap convert"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &convert.view,
+                    resolve_target: None,
+                    depth_slice: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+                multiview_mask: None,
+            });
+            pass.set_pipeline(pipeline);
+            pass.set_bind_group(0, &bind_group, &[]);
+            pass.draw(0..3, 0..1);
+        }
+    }
+}
+
+/// Resolve the GPU texture view of bevy's TonyMcMapface LUT, if loaded.
+pub fn tonemap_lut_view(app: &mut App) -> Option<wgpu::TextureView> {
+    use bevy::core_pipeline::tonemapping::TonemappingLuts;
+    let lut_id = app
+        .world()
+        .get_resource::<TonemappingLuts>()?
+        .tony_mc_mapface
+        .id();
+    let render_world = app.sub_app(RenderApp).world();
+    let gpu_images =
+        render_world.get_resource::<bevy::render::render_asset::RenderAssets<bevy::render::texture::GpuImage>>()?;
+    let img = gpu_images.get(lut_id)?;
+    Some((*img.texture_view).clone())
+}
+
 /// Per-graphics async readback state; created lazily on first enqueue.
 #[derive(Component, Default)]
 pub struct ReadbackRing {
@@ -884,7 +1449,7 @@ pub struct ReadbackRing {
 }
 
 pub fn readback_ring_enqueue(
-    In((entity, texture)): In<(Entity, Texture)>,
+    In((entity, texture, lut_view)): In<(Entity, Texture, Option<wgpu::TextureView>)>,
     world: &mut World,
 ) -> Result<()> {
     let render_device = world.resource::<RenderDevice>().clone();
@@ -942,53 +1507,23 @@ pub fn readback_ring_enqueue(
         }
     };
 
-    if needs_convert {
-        let stale = match world.get::<ReadbackRing>(entity).unwrap().convert {
-            Some(ref c) => c.width != size.width || c.height != size.height,
-            None => true,
-        };
-        if stale {
-            let device = render_device.wgpu_device();
-            let tex = device.create_texture(&wgpu::TextureDescriptor {
-                label: Some("async readback convert target"),
-                size: wgpu::Extent3d {
-                    width: size.width,
-                    height: size.height,
-                    depth_or_array_layers: 1,
-                },
-                mip_level_count: 1,
-                sample_count: 1,
-                dimension: wgpu::TextureDimension::D2,
-                format: TextureFormat::Rgba8UnormSrgb,
-                usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::COPY_SRC,
-                view_formats: &[],
-            });
-            let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
-            let blitter =
-                wgpu::util::TextureBlitter::new(device, TextureFormat::Rgba8UnormSrgb);
-            world.get_mut::<ReadbackRing>(entity).unwrap().convert = Some(ConvertPass {
-                texture: tex,
-                view,
-                blitter,
-                width: size.width,
-                height: size.height,
-            });
-        }
-    }
+    let copy_src = prepare_convert_source(
+        world,
+        entity,
+        &render_device,
+        &texture,
+        needs_convert,
+        size,
+        &lut_view,
+    );
 
     let mut encoder = render_device.create_command_encoder(&CommandEncoderDescriptor::default());
-    let copy_src = if needs_convert {
+    if needs_convert {
         let src_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
         let ring = world.get::<ReadbackRing>(entity).unwrap();
         let convert = ring.convert.as_ref().unwrap();
-        convert
-            .blitter
-            .copy(render_device.wgpu_device(), &mut encoder, &src_view, &convert.view);
-        convert.texture.clone()
-    } else {
-        // bevy's Texture derefs to the raw wgpu texture.
-        wgpu::Texture::clone(&texture)
-    };
+        record_convert(&render_device, &mut encoder, convert, &src_view);
+    }
     encoder.copy_texture_to_buffer(
         copy_src.as_image_copy(),
         TexelCopyBufferInfo {
@@ -1007,11 +1542,22 @@ pub fn readback_ring_enqueue(
     );
     let submission = render_queue.submit(std::iter::once(encoder.finish()));
 
-    let ready = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
-    let ready_cb = std::sync::Arc::clone(&ready);
+    let state = std::sync::Arc::new(std::sync::atomic::AtomicU8::new(READBACK_PENDING));
+    let state_cb = std::sync::Arc::clone(&state);
     buffer.slice(..).map_async(MapMode::Read, move |r| {
-        r.expect("Failed to map async readback buffer");
-        ready_cb.store(true, std::sync::atomic::Ordering::Release);
+        // This runs on wgpu's callback thread, so a panic here takes the
+        // process down from somewhere with no useful context. A mapping that
+        // aborts is expected during teardown -- the device can be gone before
+        // the last frame's copy lands -- so record the failure and let the
+        // fetch side drop the readback.
+        let next = match r {
+            Ok(()) => READBACK_READY,
+            Err(err) => {
+                debug!("readback buffer mapping aborted, dropping the frame: {err}");
+                READBACK_FAILED
+            }
+        };
+        state_cb.store(next, std::sync::atomic::Ordering::Release);
     });
 
     world
@@ -1020,7 +1566,7 @@ pub fn readback_ring_enqueue(
         .pending
         .push_back(PendingReadback {
             buffer,
-            ready,
+            state,
             submission,
             padded_bytes_per_row,
             bytes_per_row,
@@ -1031,6 +1577,18 @@ pub fn readback_ring_enqueue(
     Ok(())
 }
 
+/// Retire the oldest queued readback without reading it.
+///
+/// For a readback whose mapping or poll failed -- which is what happens when
+/// the device is torn down with a copy still in flight. The buffer is dropped
+/// rather than recycled onto the free list, since wgpu still regards it as
+/// mapped and handing it back out would fail again on its next use.
+fn drop_failed_readback(world: &mut World, entity: Entity) {
+    if let Some(mut ring) = world.get_mut::<ReadbackRing>(entity) {
+        ring.pending.pop_front();
+    }
+}
+
 /// Number of enqueued readbacks not yet fetched.
 pub fn readback_ring_pending(In(entity): In<Entity>, world: &mut World) -> Result<usize> {
     Ok(world
@@ -1060,37 +1618,51 @@ pub fn readback_ring_fetch(
     // and then only until THIS copy's submission completes — never the whole
     // queue.
     loop {
-        let (ready, submission) = {
+        let (state, submission) = {
             let ring = world.get::<ReadbackRing>(entity).unwrap();
             let front = ring.pending.front().unwrap();
             (
-                front.ready.load(std::sync::atomic::Ordering::Acquire),
+                front.state.load(std::sync::atomic::Ordering::Acquire),
                 front.submission.clone(),
             )
         };
-        if ready {
+        if state == READBACK_READY {
             break;
         }
-        if blocking {
-            render_device
-                .poll(PollType::Wait {
-                    submission_index: Some(submission),
-                    timeout: None,
-                })
-                .expect("Failed to poll device for async readback");
+        // A mapping that aborted is never coming back, so retire the entry
+        // rather than waiting on it forever. Its buffer is deliberately NOT
+        // returned to the free list: it is still considered mapped by wgpu and
+        // reusing it would be a second failure.
+        if state == READBACK_FAILED {
+            drop_failed_readback(world, entity);
+            return Ok(None);
+        }
+        // Polling can itself fail once the device is gone, which is the same
+        // teardown story -- drop the frame instead of taking the process with
+        // it.
+        let polled = if blocking {
+            render_device.poll(PollType::Wait {
+                submission_index: Some(submission),
+                timeout: None,
+            })
         } else {
-            render_device
-                .poll(PollType::Poll)
-                .expect("Failed to poll device for async readback");
-            let ready_now = {
+            render_device.poll(PollType::Poll)
+        };
+        if let Err(err) = polled {
+            debug!("polling for a readback failed, dropping the frame: {err}");
+            drop_failed_readback(world, entity);
+            return Ok(None);
+        }
+        if !blocking {
+            let state_now = {
                 let ring = world.get::<ReadbackRing>(entity).unwrap();
                 ring.pending
                     .front()
                     .unwrap()
-                    .ready
+                    .state
                     .load(std::sync::atomic::Ordering::Acquire)
             };
-            if !ready_now {
+            if state_now == READBACK_PENDING {
                 return Ok(None);
             }
         }
@@ -1102,12 +1674,12 @@ pub fn readback_ring_fetch(
         .pending
         .pop_front()
         .unwrap();
-    let data = pr
-        .buffer
-        .slice(..)
-        .get_mapped_range()
-        .expect("Failed to get mapped range for async readback")
-        .to_vec();
+    let Ok(mapped) = pr.buffer.slice(..).get_mapped_range() else {
+        debug!("readback buffer went away before it could be read, dropping the frame");
+        return Ok(None);
+    };
+    let data = mapped.to_vec();
+    drop(mapped);
     pr.buffer.unmap();
 
     let unpadded = if pr.padded_bytes_per_row != pr.bytes_per_row {
diff --git a/crates/processing_render/src/image.rs b/crates/processing_render/src/image.rs
index 9ff018de..3bd40771 100644
--- a/crates/processing_render/src/image.rs
+++ b/crates/processing_render/src/image.rs
@@ -153,6 +153,174 @@ pub fn create(
         .id()
 }
 
+/// Create a 3D texture usable as a storage texture in compute kernels
+/// (`texture_storage_3d<FMT, write>`) and as a sampled `texture_3d<f32>` in
+/// materials/filters. Zero-initialized; trilinear clamp-to-edge sampler.
+///
+/// Unlike 2D images this is never a render attachment, and the CPU-side asset
+/// copy is dropped after upload (a 256^3 field is 32MB — keeping a main-world
+/// mirror would double it). Readback goes through `readback_3d_raw`.
+pub fn create_3d(
+    In((size, texture_format)): In<(Extent3d, TextureFormat)>,
+    mut commands: Commands,
+    mut images: ResMut<Assets<bevy::image::Image>>,
+    render_device: Res<RenderDevice>,
+) -> Result<Entity> {
+    let px_size = pixel_size(texture_format)?;
+    let data = vec![
+        0u8;
+        size.width as usize
+            * size.height as usize
+            * size.depth_or_array_layers as usize
+            * px_size
+    ];
+    let mut image = bevy::image::Image::new(
+        size,
+        TextureDimension::D3,
+        data,
+        texture_format,
+        RenderAssetUsages::RENDER_WORLD,
+    );
+    image.texture_descriptor.usage = TextureUsages::TEXTURE_BINDING
+        | TextureUsages::STORAGE_BINDING
+        | TextureUsages::COPY_DST
+        | TextureUsages::COPY_SRC;
+    image.sampler = ImageSampler::Descriptor(ImageSamplerDescriptor {
+        mag_filter: ImageFilterMode::Linear,
+        min_filter: ImageFilterMode::Linear,
+        mipmap_filter: ImageFilterMode::Linear,
+        address_mode_u: ImageAddressMode::ClampToEdge,
+        address_mode_v: ImageAddressMode::ClampToEdge,
+        address_mode_w: ImageAddressMode::ClampToEdge,
+        ..Default::default()
+    });
+
+    let handle = images.add(image);
+    let readback_buffer = create_readback_buffer_3d(
+        &render_device,
+        size.width,
+        size.height,
+        size.depth_or_array_layers,
+        texture_format,
+        "Texture3D Readback Buffer",
+    )?;
+
+    Ok(commands
+        .spawn(Image {
+            handle,
+            readback_buffer,
+            texture_format,
+            size,
+        })
+        .id())
+}
+
+/// Upload a full volume of tightly-packed texel bytes into a 3D texture.
+pub fn write_3d_raw(
+    In((entity, texture, data)): In<(Entity, Texture, Vec<u8>)>,
+    p_images: Query<&Image>,
+    render_queue: Res<RenderQueue>,
+) -> Result<()> {
+    let p_image = p_images
+        .get(entity)
+        .map_err(|_| ProcessingError::ImageNotFound)?;
+    let px_size = pixel_size(p_image.texture_format)? as u32;
+    let expected = (p_image.size.width
+        * p_image.size.height
+        * p_image.size.depth_or_array_layers
+        * px_size) as usize;
+    if data.len() != expected {
+        return Err(ProcessingError::InvalidArgument(format!(
+            "texture3d write: expected {} bytes for {}x{}x{} {:?}, got {}",
+            expected,
+            p_image.size.width,
+            p_image.size.height,
+            p_image.size.depth_or_array_layers,
+            p_image.texture_format,
+            data.len()
+        )));
+    }
+
+    render_queue.write_texture(
+        TexelCopyTextureInfo {
+            texture: &texture,
+            mip_level: 0,
+            origin: Origin3d::ZERO,
+            aspect: Default::default(),
+        },
+        &data,
+        TexelCopyBufferLayout {
+            offset: 0,
+            bytes_per_row: Some(p_image.size.width * px_size),
+            rows_per_image: Some(p_image.size.height),
+        },
+        p_image.size,
+    );
+
+    Ok(())
+}
+
+/// Read a full 3D texture back as tightly-packed texel bytes (row padding from
+/// the copy alignment is stripped).
+pub fn readback_3d_raw(
+    In((entity, texture)): In<(Entity, Texture)>,
+    p_images: Query<&Image>,
+    render_device: Res<RenderDevice>,
+    render_queue: ResMut<RenderQueue>,
+) -> Result<Vec<u8>> {
+    let p_image = p_images
+        .get(entity)
+        .map_err(|_| ProcessingError::ImageNotFound)?;
+
+    let px_size = pixel_size(p_image.texture_format)?;
+    let padded_bytes_per_row =
+        RenderDevice::align_copy_bytes_per_row(p_image.size.width as usize * px_size);
+
+    let mut encoder = render_device.create_command_encoder(&CommandEncoderDescriptor::default());
+    encoder.copy_texture_to_buffer(
+        texture.as_image_copy(),
+        TexelCopyBufferInfo {
+            buffer: &p_image.readback_buffer,
+            layout: TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(
+                    std::num::NonZero::<u32>::new(padded_bytes_per_row as u32)
+                        .unwrap()
+                        .into(),
+                ),
+                rows_per_image: Some(p_image.size.height),
+            },
+        },
+        p_image.size,
+    );
+    render_queue.submit(std::iter::once(encoder.finish()));
+
+    let buffer_slice = p_image.readback_buffer.slice(..);
+    let (s, r) = crossbeam_channel::bounded(1);
+    buffer_slice.map_async(MapMode::Read, move |res| match res {
+        Ok(res) => s.send(res).expect("Failed to send map update"),
+        Err(err) => panic!("Failed to map buffer {err}"),
+    });
+    render_device
+        .poll(PollType::wait_indefinitely())
+        .expect("Failed to poll device for map async");
+    r.recv().expect("Failed to receive the map_async message");
+
+    let padded = buffer_slice
+        .get_mapped_range()
+        .expect("Failed to get mapped range for readback")
+        .to_vec();
+    p_image.readback_buffer.unmap();
+
+    let bytes_per_row = p_image.size.width as usize * px_size;
+    let rows = (p_image.size.height * p_image.size.depth_or_array_layers) as usize;
+    let mut out = Vec::with_capacity(bytes_per_row * rows);
+    for row in padded.chunks_exact(padded_bytes_per_row).take(rows) {
+        out.extend_from_slice(&row[..bytes_per_row]);
+    }
+    Ok(out)
+}
+
 pub fn load_start(world: &mut World, path: PathBuf) -> Handle<bevy::image::Image> {
     world.get_asset_server().load(path)
 }
@@ -432,6 +600,8 @@ pub fn destroy(
 /// Get the size in bytes of a single pixel for the given texture format.
 pub fn pixel_size(format: TextureFormat) -> Result<usize> {
     match format {
+        TextureFormat::R16Float => Ok(2),
+        TextureFormat::R32Float | TextureFormat::R32Uint | TextureFormat::Rg16Float => Ok(4),
         TextureFormat::Rgba8Unorm | TextureFormat::Rgba8UnormSrgb => Ok(4),
         TextureFormat::Rgba16Float => Ok(8),
         TextureFormat::Rgba32Float => Ok(16),
@@ -439,6 +609,27 @@ pub fn pixel_size(format: TextureFormat) -> Result<usize> {
     }
 }
 
+/// Create a readback buffer sized for a (possibly 3D) texture.
+pub fn create_readback_buffer_3d(
+    render_device: &RenderDevice,
+    width: u32,
+    height: u32,
+    depth: u32,
+    format: TextureFormat,
+    label: &str,
+) -> Result<Buffer> {
+    let px_size = pixel_size(format)?;
+    let padded_bytes_per_row = RenderDevice::align_copy_bytes_per_row(width as usize * px_size);
+    let buffer_size = padded_bytes_per_row as u64 * height as u64 * depth as u64;
+
+    Ok(render_device.create_buffer(&BufferDescriptor {
+        label: Some(label),
+        size: buffer_size,
+        usage: BufferUsages::COPY_DST | BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    }))
+}
+
 /// Convert LinearRgba pixels to raw bytes in the specified texture format.
 pub fn pixels_to_bytes(pixels: &[LinearRgba], format: TextureFormat) -> Result<Vec<u8>> {
     match format {
diff --git a/crates/processing_render/src/lib.rs b/crates/processing_render/src/lib.rs
index 7eb9649b..34e563de 100644
--- a/crates/processing_render/src/lib.rs
+++ b/crates/processing_render/src/lib.rs
@@ -1,6 +1,10 @@
 #![allow(clippy::module_inception)]
 
+pub mod animation;
 pub mod camera;
+/// GPU-resident frame capture into IOSurfaces; macOS only.
+#[cfg(target_os = "macos")]
+pub mod capture_macos;
 pub mod color;
 pub mod compute;
 pub mod geometry;
@@ -36,7 +40,7 @@ pub use particles::{
     FALLOFF_INVERSE, FALLOFF_LINEAR, FALLOFF_QUADRATIC, FALLOFF_SMOOTHSTEP, particles_apply,
     particles_attribute_add, particles_buffer, particles_capacity, particles_connectivity_indirect,
     particles_primitives_apply, particles_primitives_attempted, particles_primitives_create,
-    particles_primitives_field,
+    particles_primitives_destroy, particles_primitives_field,
     particles_create, particles_create_from_geometry, particles_destroy, particles_emit,
     particles_emit_gpu, particles_ensure_attribute, particles_flock, particles_flock_auto,
     particles_gather, particles_kernel_age, particles_kernel_attr_combine,
@@ -73,7 +77,7 @@ pub struct ProcessingRenderPlugin;
 
 impl Plugin for ProcessingRenderPlugin {
     fn build(&self, app: &mut App) {
-        use render::material::{add_custom_materials, add_processing_materials};
+        use render::material::sync_typed_materials;
         use render::{activate_cameras, clear_transient_meshes, flush_draw_commands};
 
         let config = app.world().resource::<Config>().clone();
@@ -104,16 +108,12 @@ impl Plugin for ProcessingRenderPlugin {
             bevy::camera_controller::pan_camera::PanCameraPlugin,
             text::font::TextPlugin,
         ));
+        app.add_plugins(animation::AnimationPoolPlugin);
 
         app.add_systems(First, (clear_transient_meshes, activate_cameras))
             .add_systems(
                 Update,
-                (
-                    flush_draw_commands,
-                    add_processing_materials,
-                    add_custom_materials,
-                    particles::material::add_particles_materials,
-                )
+                (flush_draw_commands, sync_typed_materials)
                     .chain()
                     .before(AssetEventSystems),
             );
@@ -376,6 +376,14 @@ pub fn surface_resize(graphics_entity: Entity, width: u32, height: u32) -> error
     })
 }
 
+pub fn surface_set_vsync(entity: Entity, vsync: bool) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(surface::set_vsync, (entity, vsync))
+            .unwrap()
+    })
+}
+
 pub fn surface_set_pixel_density(entity: Entity, density: f32) -> error::Result<()> {
     app_mut(|app| {
         app.world_mut()
@@ -522,13 +530,26 @@ pub fn graphics_create(
     width: u32,
     height: u32,
     texture_format: TextureFormat,
+) -> error::Result<Entity> {
+    graphics_create_ex(surface_entity, width, height, texture_format, false)
+}
+
+/// Create a graphics context, optionally as a STATE canvas: a
+/// post-process-free, linear-color float target for feedback/simulation
+/// patches (see [`graphics::StateCanvas`]).
+pub fn graphics_create_ex(
+    surface_entity: Entity,
+    width: u32,
+    height: u32,
+    texture_format: TextureFormat,
+    state: bool,
 ) -> error::Result<Entity> {
     app_mut(|app| -> error::Result<Entity> {
         let entity = app
             .world_mut()
             .run_system_cached_with(
                 graphics::create,
-                (width, height, surface_entity, texture_format),
+                (width, height, surface_entity, texture_format, state),
             )
             .unwrap()?;
 
@@ -561,6 +582,21 @@ pub fn graphics_end_draw(graphics_entity: Entity) -> error::Result<()> {
     app_mut(|app| graphics::end_draw(app, graphics_entity))
 }
 
+/// Whether a canvas has draw commands waiting for a flush.
+pub fn graphics_has_pending(graphics_entity: Entity) -> error::Result<bool> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(graphics::has_pending, graphics_entity)
+            .unwrap()
+    })
+}
+
+/// End a draw without forcing an update: the canvas is armed to present on
+/// the next one. See [`graphics::arm_present`].
+pub fn graphics_arm_present(graphics_entity: Entity) -> error::Result<()> {
+    app_mut(|app| graphics::arm_present(app, graphics_entity))
+}
+
 /// Apply a filter to a graphics canvas.
 pub fn graphics_apply_filter(graphics_entity: Entity, filter_entity: Entity) -> error::Result<()> {
     app_mut(|app| graphics::apply_filter(app, graphics_entity, filter_entity))
@@ -660,8 +696,12 @@ pub fn graphics_readback_raw(graphics_entity: Entity) -> error::Result<graphics:
         graphics::flush(app, graphics_entity)?;
         let vt = graphics::view_target(app, graphics_entity)?;
         let texture = vt.main_texture().clone();
+        let lut_view = graphics::tonemap_lut_view(app);
         app.world_mut()
-            .run_system_cached_with(graphics::readback_raw, (graphics_entity, texture))
+            .run_system_cached_with(
+                graphics::readback_raw,
+                (graphics_entity, texture, lut_view),
+            )
             .unwrap()
     })
 }
@@ -677,8 +717,12 @@ pub fn graphics_readback_enqueue(graphics_entity: Entity) -> error::Result<()> {
         graphics::flush(app, graphics_entity)?;
         let vt = graphics::view_target(app, graphics_entity)?;
         let texture = vt.main_texture().clone();
+        let lut_view = graphics::tonemap_lut_view(app);
         app.world_mut()
-            .run_system_cached_with(graphics::readback_ring_enqueue, (graphics_entity, texture))
+            .run_system_cached_with(
+                graphics::readback_ring_enqueue,
+                (graphics_entity, texture, lut_view),
+            )
             .unwrap()
     })
 }
@@ -705,6 +749,74 @@ pub fn graphics_readback_pending(graphics_entity: Entity) -> error::Result<usize
     })
 }
 
+/// Non-blocking device poll: pumps wgpu so `map_async` and
+/// `on_submitted_work_done` callbacks can fire while a caller waits on GPU
+/// completions outside the render loop.
+pub fn graphics_device_poll() -> error::Result<()> {
+    app_mut(|app| {
+        let device = app
+            .world()
+            .resource::<bevy::render::renderer::RenderDevice>()
+            .clone();
+        let _ = device.poll(bevy::render::render_resource::PollType::Poll);
+        Ok(())
+    })
+}
+
+/// Current pixel size of the graphics surface.
+pub fn graphics_surface_size(graphics_entity: Entity) -> error::Result<(u32, u32)> {
+    app_mut(|app| {
+        let graphics = app
+            .world()
+            .get::<graphics::Graphics>(graphics_entity)
+            .ok_or(error::ProcessingError::GraphicsNotFound)?;
+        Ok((graphics.size.width, graphics.size.height))
+    })
+}
+
+/// Flush pending draws, blit the canvas into the given IOSurface on the GPU,
+/// and fire `on_done` (from wgpu's callback thread) once the blit completes.
+/// The GPU-resident recording path; see `capture_macos`.
+#[cfg(target_os = "macos")]
+pub fn graphics_capture_into_iosurface(
+    graphics_entity: Entity,
+    iosurface: *mut std::ffi::c_void,
+    iosurface_id: u32,
+    on_done: capture_macos::CaptureDone,
+) -> error::Result<()> {
+    let iosurface = iosurface as usize;
+    app_mut(|app| {
+        // Capture runs right after endDraw, which already flushed and
+        // rendered — an unconditional flush here would pump a whole extra
+        // app.update() (~3ms of fixed cost) per recorded frame for nothing.
+        let pending = app
+            .world_mut()
+            .run_system_cached_with(graphics::has_pending, graphics_entity)
+            .unwrap()?;
+        if pending {
+            graphics::flush(app, graphics_entity)?;
+        }
+        let vt = graphics::view_target(app, graphics_entity)?;
+        let texture = vt.main_texture().clone();
+        app.world_mut()
+            .run_system_cached_with(
+                capture_macos::capture_into_surface,
+                (graphics_entity, texture, iosurface, iosurface_id, on_done),
+            )
+            .unwrap()
+    })
+}
+
+/// Drop the GPU capture cache for a graphics (end of a recording).
+#[cfg(target_os = "macos")]
+pub fn graphics_capture_reset(graphics_entity: Entity) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(capture_macos::capture_reset, graphics_entity)
+            .unwrap()
+    })
+}
+
 /// Read back pixel data from the graphics surface as LinearRgba.
 pub fn graphics_readback(graphics_entity: Entity) -> error::Result<Vec<LinearRgba>> {
     let raw = graphics_readback_raw(graphics_entity)?;
@@ -1003,6 +1115,45 @@ pub fn graphics_frustum(
     })
 }
 
+/// Spawn an animation pose pool: K paused puppet instances of the glTF's
+/// scene, seeked along `clip_name` at k/K, whose joint matrices feed skinned
+/// particle instancing. Returns the pool entity.
+pub fn gltf_animation_pool(gltf_entity: Entity, clip_name: &str, k: u32) -> error::Result<Entity> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(
+                animation::pool_create,
+                (gltf_entity, clip_name.to_string(), k),
+            )
+            .unwrap()
+    })
+}
+
+pub fn gltf_animation_pool_destroy(pool_entity: Entity) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(animation::pool_destroy, pool_entity)
+            .unwrap()
+    })
+}
+
+/// Attach a pose pool + per-particle phase attribute to a particle system;
+/// its pack dispatch switches to the skin-enabled variant.
+pub fn particles_set_skin_pool(
+    particles_entity: Entity,
+    pool_entity: Entity,
+    phase_attribute: Entity,
+) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(
+                particles::set_skin_pool,
+                (particles_entity, pool_entity, phase_attribute),
+            )
+            .unwrap()
+    })
+}
+
 pub fn graphics_world_from_screen(
     graphics_entity: Entity,
     sx: f32,
@@ -1180,6 +1331,56 @@ pub fn image_create(
     })
 }
 
+/// Create a 3D texture (compute-writable storage texture + trilinear-sampled
+/// `texture_3d<f32>`), zero-initialized.
+pub fn texture3d_create(size: Extent3d, texture_format: TextureFormat) -> error::Result<Entity> {
+    app_mut(|app| {
+        let entity = app
+            .world_mut()
+            .run_system_cached_with(image::create_3d, (size, texture_format))
+            .unwrap()?;
+        // Prepare the GpuImage now so the texture can be bound (compute
+        // dispatch, material prepare) or written this same frame.
+        app.update();
+        Ok(entity)
+    })
+}
+
+/// The wgpu texture for an image entity, pumping one update if the GPU asset
+/// has not been prepared yet.
+fn image_texture(
+    app: &mut App,
+    entity: Entity,
+) -> error::Result<bevy::render::render_resource::Texture> {
+    match gpu_image(app, entity) {
+        Ok(img) => Ok(img.texture.clone()),
+        Err(_) => {
+            app.update();
+            Ok(gpu_image(app, entity)?.texture.clone())
+        }
+    }
+}
+
+/// Upload a full volume of tightly-packed texel bytes into a 3D texture.
+pub fn texture3d_write(entity: Entity, data: Vec<u8>) -> error::Result<()> {
+    app_mut(|app| {
+        let texture = image_texture(app, entity)?;
+        app.world_mut()
+            .run_system_cached_with(image::write_3d_raw, (entity, texture, data))
+            .unwrap()
+    })
+}
+
+/// Read a full 3D texture back as tightly-packed texel bytes.
+pub fn texture3d_readback(entity: Entity) -> error::Result<Vec<u8>> {
+    app_mut(|app| {
+        let texture = image_texture(app, entity)?;
+        app.world_mut()
+            .run_system_cached_with(image::readback_3d_raw, (entity, texture))
+            .unwrap()
+    })
+}
+
 /// Load an image from disk.
 #[cfg(not(target_arch = "wasm32"))]
 pub fn image_load(path: &str) -> error::Result<Entity> {
@@ -1360,6 +1561,98 @@ pub fn image_destroy(entity: Entity) -> error::Result<()> {
     })
 }
 
+/// Destroy a light.
+pub fn light_destroy(light_entity: Entity) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(light::destroy, light_entity)
+            .unwrap()
+    })
+}
+
+/// Aim a light along a travel direction (Processing directionalLight
+/// convention).
+pub fn light_set_direction(light_entity: Entity, dir: Vec3) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(light::set_direction, (light_entity, dir))
+            .unwrap()
+    })
+}
+
+/// Toggle shadow casting on a directional light.
+pub fn light_set_shadows(light_entity: Entity, enabled: bool) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(light::set_shadows, (light_entity, enabled))
+            .unwrap()
+    })
+}
+
+/// Toggle contact-shadow casting on a directional light.
+pub fn light_set_contact_shadows(light_entity: Entity, enabled: bool) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(light::set_contact_shadows, (light_entity, enabled))
+            .unwrap()
+    })
+}
+
+/// Set a directional light's shadow-map depth and normal bias.
+pub fn light_set_shadow_bias(
+    light_entity: Entity,
+    depth_bias: f32,
+    normal_bias: f32,
+) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(
+                light::set_shadow_bias,
+                (light_entity, depth_bias, normal_bias),
+            )
+            .unwrap()
+    })
+}
+
+/// Turn screen-space contact shadows on or off for a canvas' camera.
+///
+/// Checks that bevy's `ContactShadowsPlugin` is actually in the app rather
+/// than assuming it rides in with `PbrPlugin`: it does today, but a plugin
+/// that is not registered would leave this silently inserting a component
+/// nothing reads, which is exactly the kind of quiet no-op that costs an
+/// afternoon.
+pub fn graphics_set_contact_shadows(
+    graphics_entity: Entity,
+    enabled: bool,
+    linear_steps: u32,
+    thickness: f32,
+    length: f32,
+) -> error::Result<()> {
+    app_mut(|app| {
+        if enabled && !app.is_plugin_added::<bevy::pbr::contact_shadows::ContactShadowsPlugin>() {
+            bevy::log::warn_once!(
+                "contact shadows were requested but ContactShadowsPlugin is not registered in \
+                 this app, so nothing will change on screen."
+            );
+        }
+        app.world_mut()
+            .run_system_cached_with(
+                graphics::set_contact_shadows,
+                (graphics_entity, enabled, linear_steps, thickness, length),
+            )
+            .unwrap()
+    })
+}
+
+/// Turn temporal antialiasing on or off for a canvas' camera.
+pub fn graphics_set_temporal_aa(graphics_entity: Entity, enabled: bool) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(graphics::set_temporal_aa, (graphics_entity, enabled))
+            .unwrap()
+    })
+}
+
 pub fn light_create_directional(
     graphics_entity: Entity,
     color: Color,
@@ -2074,6 +2367,14 @@ pub fn material_set_depth_write(entity: Entity, value: bool) -> error::Result<()
     })
 }
 
+pub fn material_set_depth_bias(entity: Entity, value: f32) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(material::set_depth_bias, (entity, value))
+            .unwrap()
+    })
+}
+
 pub fn material_set_custom_blend(
     entity: Entity,
     blend: bevy::render::render_resource::BlendState,
@@ -2258,6 +2559,14 @@ pub fn gltf_load(graphics_entity: Entity, path: &str) -> error::Result<Entity> {
     })
 }
 
+pub fn gltf_destroy(gltf_entity: Entity) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(gltf::destroy, gltf_entity)
+            .unwrap()
+    })
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub fn gltf_geometry(gltf_entity: Entity, name: &str) -> error::Result<Entity> {
     app_mut(|app| {
@@ -2531,6 +2840,7 @@ pub fn compute_set(
 
 pub fn compute_dispatch(entity: Entity, x: u32, y: u32, z: u32) -> error::Result<()> {
     app_mut(|app| {
+        if std::env::var("PROCESSING_TRACE_VT").is_ok() { eprintln!("ENGINE dispatch(update first)"); }
         app.update();
         dispatch_inner(app, entity, x, y, z)
     })
@@ -2544,18 +2854,35 @@ pub fn compute_dispatch(entity: Entity, x: u32, y: u32, z: u32) -> error::Result
 /// `update()` provides that a dispatch may genuinely need is pipeline
 /// compilation on first use — so on `PipelineNotReady` we pump once and
 /// retry.
-pub(crate) fn compute_dispatch_quiet(
+///
+/// Public since it is also the user-facing fast path for dispatch chains:
+/// callers opt out of the "resources created earlier this frame are always
+/// visible" guarantee that [`compute_dispatch`] buys with its update — a
+/// buffer or texture created since the last update may bind as unresolved.
+/// Set everything up, then chain quiet dispatches.
+pub fn compute_dispatch_quiet(
     entity: Entity,
     x: u32,
     y: u32,
     z: u32,
 ) -> error::Result<()> {
-    app_mut(|app| match dispatch_inner(app, entity, x, y, z) {
-        Err(error::ProcessingError::PipelineNotReady(_)) => {
-            app.update();
-            dispatch_inner(app, entity, x, y, z)
+    app_mut(|app| {
+        let result = match dispatch_inner(app, entity, x, y, z) {
+            Err(error::ProcessingError::PipelineNotReady(_)) => {
+                app.update();
+                dispatch_inner(app, entity, x, y, z)
+            }
+            r => r,
+        };
+        // `invalidate_rw_buffers` normally runs in the main schedule's `Last`,
+        // which a quiet dispatch skips — without this a CPU readback after a
+        // quiet chain returns the stale synced copy instead of the GPU data.
+        if result.is_ok() {
+            app.world_mut()
+                .run_system_cached(compute::invalidate_rw_buffers)
+                .unwrap();
         }
-        r => r,
+        result
     })
 }
 
@@ -2645,6 +2972,18 @@ pub fn font_create(name: &str) -> error::Result<Entity> {
     })
 }
 
+/// Destroy a font handle entity. Registered font data remains cached in the
+/// process-wide text context and may be reused by another handle.
+pub fn font_destroy(font_entity: Entity) -> error::Result<()> {
+    app_mut(|app| {
+        if app.world().get::<text::font::Font>(font_entity).is_none() {
+            return Err(error::ProcessingError::InvalidEntity);
+        }
+        app.world_mut().entity_mut(font_entity).despawn();
+        Ok(())
+    })
+}
+
 /// List all available font family names (system + registered).
 pub fn font_list() -> error::Result<Vec<String>> {
     use text::font::TextContext;
diff --git a/crates/processing_render/src/light.rs b/crates/processing_render/src/light.rs
index 423703c2..7c76f9c5 100644
--- a/crates/processing_render/src/light.rs
+++ b/crates/processing_render/src/light.rs
@@ -5,12 +5,99 @@ use bevy::{camera::visibility::RenderLayers, prelude::*};
 
 use crate::{error::ProcessingError, graphics::Graphics};
 
+/// Calibration: the engine's light contract is PHYSICAL LUX at the default
+/// camera exposure (EV100 9.7, Blender's default — bevy's own convention).
+///
+/// The current bevy-tib-rebase vintage renders analytical (directional/point/
+/// spot) lights ~1/exposure(9.7)^2 = 9.2e5x hotter than physical: measured on
+/// the grey-card probe (quil `dev/greycard_once.clj`, linear-pipeline fits
+/// kappa = 7.5e5..9.6e5 across half a decade of lux), while ambient light,
+/// emissive, and the camera `Exposure` knob itself all behave correctly (the
+/// exposure law verified exact over 10 EV of camera exposure). Scaling
+/// illuminance/intensity by exposure(9.7)^2 at creation restores the physical
+/// contract without touching the (correct) ambient and emissive paths.
+/// Re-verify with the probe after any bevy rebase; if upstream fixes its
+/// light scaling this constant must be re-measured or the scene goes dark.
+const LIGHT_EXPOSURE_COMPENSATION: f32 = 1.0828123e-6; // (exp2(-9.7) / 1.2)^2
+
 pub struct LightPlugin;
 
 impl Plugin for LightPlugin {
     fn build(&self, _app: &mut App) {}
 }
 
+/// Despawn a light entity (both retained-API and immediate-mode lights).
+pub fn destroy(In(entity): In<Entity>, mut commands: Commands) -> Result<(), ProcessingError> {
+    commands.entity(entity).despawn();
+    Ok(())
+}
+
+/// Aim a light: `dir` is the direction the light TRAVELS (Processing's
+/// directionalLight convention). Distinct from the generic Euler-angle
+/// transform setter, which cannot express "point this way".
+pub fn set_direction(
+    In((entity, dir)): In<(Entity, Vec3)>,
+    mut transforms: Query<&mut Transform>,
+) -> Result<(), ProcessingError> {
+    let mut transform = transforms
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::InvalidEntity)?;
+    let dir = dir.try_normalize().ok_or(ProcessingError::InvalidArgument(
+        "light direction must be non-zero".into(),
+    ))?;
+    // Lights shine along their -Z; look_to aims -Z at `dir`.
+    let up = if dir.y.abs() > 0.99 { Vec3::Z } else { Vec3::Y };
+    transform.look_to(dir, up);
+    Ok(())
+}
+
+/// Toggle shadow casting on a directional light.
+pub fn set_shadows(
+    In((entity, enabled)): In<(Entity, bool)>,
+    mut lights: Query<&mut DirectionalLight>,
+) -> Result<(), ProcessingError> {
+    let mut light = lights
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::InvalidEntity)?;
+    light.shadow_maps_enabled = enabled;
+    Ok(())
+}
+
+/// Toggle contact-shadow casting on a directional light.
+///
+/// Separate from `set_shadows`: shadow maps and contact shadows are
+/// independent gates on the same light, and the effect also has to be enabled
+/// on the camera (`graphics::set_contact_shadows`) before a light's flag does
+/// anything.
+pub fn set_contact_shadows(
+    In((entity, enabled)): In<(Entity, bool)>,
+    mut lights: Query<&mut DirectionalLight>,
+) -> Result<(), ProcessingError> {
+    let mut light = lights
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::InvalidEntity)?;
+    light.contact_shadows_enabled = enabled;
+    Ok(())
+}
+
+/// Set the shadow-map depth and normal bias for a directional light.
+///
+/// These are the two knobs for shadow acne -- the self-shadowing stipple a
+/// surface gets when its own depth in the shadow map lands ambiguously.
+/// Raising them trades acne for peter-panning (shadows detaching from their
+/// caster). A stack of coplanar faces is the scene that needs them.
+pub fn set_shadow_bias(
+    In((entity, depth_bias, normal_bias)): In<(Entity, f32, f32)>,
+    mut lights: Query<&mut DirectionalLight>,
+) -> Result<(), ProcessingError> {
+    let mut light = lights
+        .get_mut(entity)
+        .map_err(|_| ProcessingError::InvalidEntity)?;
+    light.shadow_depth_bias = depth_bias;
+    light.shadow_normal_bias = normal_bias;
+    Ok(())
+}
+
 pub fn create_directional(
     In((entity, color, illuminance)): In<(Entity, Color, f32)>,
     mut commands: Commands,
@@ -22,7 +109,7 @@ pub fn create_directional(
     Ok(commands
         .spawn((
             DirectionalLight {
-                illuminance,
+                illuminance: illuminance * LIGHT_EXPOSURE_COMPENSATION,
                 color,
                 ..default()
             },
@@ -42,7 +129,7 @@ pub fn create_point(
     Ok(commands
         .spawn((
             PointLight {
-                intensity,
+                intensity: intensity * LIGHT_EXPOSURE_COMPENSATION,
                 color,
                 range,
                 radius,
@@ -73,7 +160,7 @@ pub fn create_spot(
         .spawn((
             SpotLight {
                 color,
-                intensity,
+                intensity: intensity * LIGHT_EXPOSURE_COMPENSATION,
                 range,
                 radius,
                 inner_angle,
diff --git a/crates/processing_render/src/material/custom.rs b/crates/processing_render/src/material/custom.rs
index 286ef490..4209480d 100644
--- a/crates/processing_render/src/material/custom.rs
+++ b/crates/processing_render/src/material/custom.rs
@@ -91,6 +91,7 @@ pub struct CustomMaterial {
     pub alpha_mode: AlphaMode,
     pub double_sided: Option<bool>,
     pub depth_write: Option<bool>,
+    pub depth_bias: f32,
 }
 
 #[derive(Component)]
@@ -305,6 +306,7 @@ pub fn create_custom(
         alpha_mode: AlphaMode::Opaque,
         double_sided: None,
         depth_write: None,
+        depth_bias: 0.0,
     };
     let handle = custom_materials.add(material);
     Ok(commands.spawn(UntypedMaterial(handle.untyped())).id())
@@ -615,6 +617,54 @@ impl ErasedRenderAsset for CustomMaterial {
             gpu_buffers,
         );
 
+        // Every binding the reflected LAYOUT declares must be present in the
+        // bind group. `create_bindings` skips a storage parameter whose buffer
+        // isn't resolvable yet (unset, or its GpuShaderBuffer not prepared in
+        // this frame), which would otherwise hand wgpu a short descriptor —
+        // "Number of bindings in bind group descriptor (1) does not match the
+        // number of bindings defined in the bind group layout (3)" — and that
+        // is a validation error, i.e. it kills the app. A material with two
+        // storage buffers hit this every time. Retry instead: a
+        // not-yet-prepared buffer resolves on a later frame, and a genuinely
+        // unset one gets a named warning rather than a crash.
+        if bindings.len() != layout_entries.len() {
+            let bound: Vec<u32> = bindings.iter().map(|(b, _)| *b).collect();
+            let missing: Vec<u32> = layout_entries
+                .iter()
+                .map(|e| e.binding)
+                .filter(|b| !bound.contains(b))
+                .collect();
+            let names: Vec<String> = reflection
+                .parameters()
+                .filter(|p| missing.contains(&p.binding()))
+                .filter_map(|p| p.name().map(|n| n.to_string()))
+                .collect();
+            // Diagnose WHICH half is missing: no handle on the extracted
+            // material (assignment hasn't reached the render world) vs handle
+            // present but its GpuShaderBuffer not prepared yet (asset race).
+            let detail: Vec<String> = names
+                .iter()
+                .map(|n| match source_asset.shader.buffer_handle(n) {
+                    None => format!("{n}: NO HANDLE on extracted material"),
+                    Some(h) => match gpu_buffers.get(h) {
+                        None => format!("{n}: handle present, GPU BUFFER NOT PREPARED"),
+                        Some(_) => format!("{n}: handle+gpu present (unexpected)"),
+                    },
+                })
+                .collect();
+            warn!(
+                "custom material: {} of {} @group(3) bindings unresolved {:?} \
+                 (unbound: {:?}) — retrying next frame. If this repeats, the \
+                 shader declares a storage buffer that was never assigned; \
+                 set it with set_uniforms/set-uniforms!.",
+                missing.len(),
+                layout_entries.len(),
+                detail,
+                missing,
+            );
+            return Err(PrepareAssetError::RetryNextUpdate(source_asset));
+        }
+
         let unprepared = UnpreparedBindGroup {
             bindings: BindingResources(bindings),
         };
@@ -675,6 +725,7 @@ impl ErasedRenderAsset for CustomMaterial {
             user_specialize: Some(specialize),
             alpha_mode,
             render_phase_type,
+            depth_bias: source_asset.depth_bias,
             ..Default::default()
         };
         properties.add_draw_function(MainPassOpaqueDrawFunction, draw_opaque);
diff --git a/crates/processing_render/src/material/mod.rs b/crates/processing_render/src/material/mod.rs
index 43091660..55ff83ef 100644
--- a/crates/processing_render/src/material/mod.rs
+++ b/crates/processing_render/src/material/mod.rs
@@ -134,6 +134,31 @@ pub fn set_property(
             return Ok(());
         }
 
+        // Textures (2D images and 3D voxel textures alike) bind by name into
+        // the material's dynamic shader; `create_bindings` resolves the
+        // GpuImage at prepare time. `texture_handle` was resolved above.
+        if let ShaderValue::Texture(_) = &value {
+            let handle = texture_handle.expect("texture_handle resolved for ShaderValue::Texture");
+            let category = mat
+                .shader
+                .reflection()
+                .parameter(&name)
+                .map(|p| p.category())
+                .ok_or_else(|| ProcessingError::UnknownShaderProperty(name.clone()))?;
+            if !matches!(
+                category,
+                ParameterCategory::Texture
+                    | ParameterCategory::StorageTexture
+                    | ParameterCategory::Sampler
+            ) {
+                return Err(ProcessingError::InvalidArgument(format!(
+                    "property `{name}` expects {category:?}, got Texture"
+                )));
+            }
+            mat.shader.insert(&name, handle);
+            return Ok(());
+        }
+
         return custom::set_property(&mut mat, &name, &value);
     }
 
@@ -328,6 +353,30 @@ pub fn set_depth_write(
     )
 }
 
+pub fn set_depth_bias(
+    In((entity, value)): In<(Entity, f32)>,
+    material_handles: Query<&UntypedMaterial>,
+    mut pbr: ResMut<Assets<PbrMaterial>>,
+    mut particles: ResMut<Assets<crate::particles::material::ParticlesMaterial>>,
+    mut custom: ResMut<Assets<custom::CustomMaterial>>,
+) -> error::Result<()> {
+    edit_material(
+        entity,
+        &material_handles,
+        &mut pbr,
+        &mut particles,
+        &mut custom,
+        |m| {
+            match m {
+                MaterialMut::Pbr(mat) => mat.base.depth_bias = value,
+                MaterialMut::Particles(mat) => mat.base.depth_bias = value,
+                MaterialMut::Custom(mat) => mat.depth_bias = value,
+            }
+            Ok(())
+        },
+    )
+}
+
 pub fn set_custom_blend(
     In((entity, blend)): In<(Entity, BlendState)>,
     material_handles: Query<&UntypedMaterial>,
diff --git a/crates/processing_render/src/particles/material.rs b/crates/processing_render/src/particles/material.rs
index 0075a605..63a302e3 100644
--- a/crates/processing_render/src/particles/material.rs
+++ b/crates/processing_render/src/particles/material.rs
@@ -1,5 +1,3 @@
-use std::ops::Deref;
-
 use bevy::asset::embedded_asset;
 use bevy::material::specialize::SpecializedMeshPipelineError;
 use bevy::pbr::{
@@ -14,8 +12,6 @@ use bevy::render::{
 };
 use bevy::shader::ShaderRef;
 
-use crate::render::material::UntypedMaterial;
-
 pub struct ParticlesMaterialPlugin;
 
 impl Plugin for ParticlesMaterialPlugin {
@@ -90,14 +86,3 @@ impl MaterialExtension for ParticlesExtension {
         Ok(())
     }
 }
-
-pub fn add_particles_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
-    for (entity, handle) in meshes.iter() {
-        let handle = handle.deref().clone();
-        if let Ok(handle) = handle.try_typed::<ParticlesMaterial>() {
-            commands
-                .entity(entity)
-                .insert(MeshMaterial3d::<ParticlesMaterial>(handle));
-        }
-    }
-}
diff --git a/crates/processing_render/src/particles/mod.rs b/crates/processing_render/src/particles/mod.rs
index 7e61f41c..dabf6fd4 100644
--- a/crates/processing_render/src/particles/mod.rs
+++ b/crates/processing_render/src/particles/mod.rs
@@ -28,7 +28,7 @@ pub use emit::{
 pub use grid::{Grid, GridParams, grid_bind, grid_build, grid_create};
 pub use prims::{
     PrimitivesTarget, particles_primitives_apply, particles_primitives_attempted,
-    particles_primitives_create, particles_primitives_field,
+    particles_primitives_create, particles_primitives_destroy, particles_primitives_field,
 };
 pub use kernels::{
     BOUNDS_CLAMP, BOUNDS_REFLECT, BOUNDS_SOFT, BOUNDS_WRAP, COMBINE_ADD, COMBINE_DIV, COMBINE_MAX,
@@ -105,6 +105,17 @@ pub struct Particles {
     /// Set by the raster draw path, consumed by the primitives-apply path so
     /// a target's counts reset once per draw regardless of frame pacing.
     pub drawn_since_apply: bool,
+    /// When set, instanced draws of this system are skinned: the pack kernel
+    /// samples the pose pool by the per-particle phase attribute.
+    pub skin: Option<ParticlesSkin>,
+}
+
+/// Pose-pool attachment for skinned particle instances (see
+/// `crate::animation::SkinPosePool`).
+#[derive(Clone, Copy)]
+pub struct ParticlesSkin {
+    pub pool: Entity,
+    pub phase_attr: Entity,
 }
 
 #[derive(Clone, Copy)]
@@ -122,6 +133,24 @@ impl Particles {
     }
 }
 
+/// Attach a pose pool + phase attribute; pack dispatch switches to the
+/// skin-enabled pipeline for this system's instanced draws.
+pub fn set_skin_pool(
+    In((particles_entity, pool, phase_attr)): In<(Entity, Entity, Entity)>,
+    mut particles: Query<&mut Particles>,
+) -> Result<()> {
+    let mut p = particles
+        .get_mut(particles_entity)
+        .map_err(|_| ProcessingError::InvalidEntity)?;
+    if !p.buffers.contains_key(&phase_attr) {
+        return Err(ProcessingError::InvalidArgument(
+            "skin pool phase attribute is not an attribute of this particle system".to_string(),
+        ));
+    }
+    p.skin = Some(ParticlesSkin { pool, phase_attr });
+    Ok(())
+}
+
 #[derive(Component, Clone, Copy)]
 pub struct ParticlesDraw {
     pub particles: Entity,
@@ -163,6 +192,7 @@ pub fn create(
             connectivity: None,
             emit_head: 0,
             drawn_since_apply: false,
+            skin: None,
         })
         .id();
     Ok(entity)
@@ -245,6 +275,7 @@ pub fn create_from_geometry(
             connectivity,
             emit_head: 0,
             drawn_since_apply: false,
+            skin: None,
         })
         .id();
     Ok(entity)
diff --git a/crates/processing_render/src/particles/pack.rs b/crates/processing_render/src/particles/pack.rs
index 0d844113..16b30775 100644
--- a/crates/processing_render/src/particles/pack.rs
+++ b/crates/processing_render/src/particles/pack.rs
@@ -8,7 +8,7 @@ use bevy::pbr::{
 use bevy::platform::collections::HashMap;
 use bevy::prelude::*;
 use bevy::render::{
-    Extract, ExtractSchedule, Render, RenderApp, RenderSystems,
+    Extract, ExtractSchedule, Render, RenderApp, RenderStartup, RenderSystems,
     batching::gpu_preprocessing::BatchedInstanceBuffers,
     render_asset::RenderAssets,
     render_resource::{
@@ -22,6 +22,10 @@ use bevy::render::{
 };
 use bevy::shader::{Shader, ShaderDefVal};
 
+use bevy::pbr::SkinUniforms;
+use bevy::render::render_resource::{BufferInitDescriptor, BufferUsages};
+
+use crate::animation::SkinPosePool;
 use crate::compute;
 use crate::geometry::BuiltinAttributes;
 
@@ -50,6 +54,7 @@ impl Plugin for ParticlesPackPlugin {
             .init_resource::<ExtractedParticlesDraws>()
             .init_resource::<ParticlesPackPipelines>()
             .init_resource::<ParticlesPackBindGroups>()
+            .add_systems(RenderStartup, prewarm_pack_pipelines)
             .add_systems(ExtractSchedule, extract_particles_draws)
             .add_systems(
                 Render,
@@ -67,6 +72,7 @@ pub struct PackPipelineKey {
     pub has_rotation: bool,
     pub has_scale: bool,
     pub has_life: bool,
+    pub has_skin: bool,
 }
 
 pub struct CachedPackPipeline {
@@ -83,7 +89,7 @@ pub struct ParticlesPackPipelines {
 struct ParticlesPackParams {
     base_input_index: u32,
     count: u32,
-    _pad0: u32,
+    pool_size: u32,
     _pad1: u32,
 }
 
@@ -93,6 +99,9 @@ pub struct ExtractedParticlesData {
     pub rotation: Option<Handle<ShaderBuffer>>,
     pub scale: Option<Handle<ShaderBuffer>>,
     pub life: Option<Handle<ShaderBuffer>>,
+    /// Phase attribute buffer + the pool's slot entities (main world), whose
+    /// live skin indices prepare resolves each frame.
+    pub skin: Option<(Handle<ShaderBuffer>, Vec<MainEntity>)>,
 }
 
 #[derive(Resource, Default)]
@@ -143,6 +152,10 @@ fn pack_layout_entries(key: PackPipelineKey) -> Vec<BindGroupLayoutEntry> {
         entries.push(layout_entry(5, storage_r));
     }
     entries.push(layout_entry(6, uniform));
+    if key.has_skin {
+        entries.push(layout_entry(7, storage_r));
+        entries.push(layout_entry(8, storage_r));
+    }
     entries
 }
 
@@ -166,9 +179,42 @@ fn shader_defs_for(key: PackPipelineKey) -> Vec<ShaderDefVal> {
     if key.has_life {
         defs.push("HAS_LIFE".into());
     }
+    if key.has_skin {
+        defs.push("HAS_SKIN".into());
+    }
     defs
 }
 
+/// Queue every pack-kernel variant up front.
+///
+/// The pack kernel is what writes per-instance transforms into the batch slab,
+/// so until its pipeline exists an instanced draw renders NOTHING — measured:
+/// a particle system drawn from frame 1 is blank on frame 1 and correct on
+/// frame 2, while a second system whose first draw happens later appears
+/// immediately (the pipeline is hot by then). That one-time cost also lands
+/// MID-SHOW the first time a new variant appears — the skinned (`has_skin`)
+/// pack for the crow cut is a different pipeline from the unskinned one, so it
+/// would otherwise blank its own first frame at the cut.
+///
+/// There are only 2^4 = 16 combinations and they are small compute pipelines,
+/// so compiling them all at startup is cheap and makes instanced draws behave
+/// like Processing expects: draw it, and it draws THIS frame.
+fn prewarm_pack_pipelines(
+    shader: Res<ParticlesPackShader>,
+    pipeline_cache: Res<PipelineCache>,
+    mut pipelines: ResMut<ParticlesPackPipelines>,
+) {
+    for bits in 0..16u8 {
+        let key = PackPipelineKey {
+            has_rotation: bits & 0b0001 != 0,
+            has_scale: bits & 0b0010 != 0,
+            has_life: bits & 0b0100 != 0,
+            has_skin: bits & 0b1000 != 0,
+        };
+        get_or_create_pipeline(&mut pipelines, &pipeline_cache, &shader.0, key);
+    }
+}
+
 fn get_or_create_pipeline(
     pipelines: &mut ParticlesPackPipelines,
     pipeline_cache: &PipelineCache,
@@ -180,16 +226,16 @@ fn get_or_create_pipeline(
     }
     let bind_group_layout = BindGroupLayoutDescriptor::new(
         format!(
-            "ParticlesPackBindGroupLayout(rot={},scale={},life={})",
-            key.has_rotation, key.has_scale, key.has_life
+            "ParticlesPackBindGroupLayout(rot={},scale={},life={},skin={})",
+            key.has_rotation, key.has_scale, key.has_life, key.has_skin
         ),
         &pack_layout_entries(key),
     );
     let pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
         label: Some(
             format!(
-                "particles_pack_pipeline(rot={},scale={},life={})",
-                key.has_rotation, key.has_scale, key.has_life
+                "particles_pack_pipeline(rot={},scale={},life={},skin={})",
+                key.has_rotation, key.has_scale, key.has_life, key.has_skin
             )
             .into(),
         ),
@@ -213,6 +259,7 @@ fn extract_particles_draws(
     particles_draws: Extract<Query<(Entity, &ParticlesDraw)>>,
     particles_q: Extract<Query<&Particles>>,
     buffers: Extract<Query<&compute::Buffer>>,
+    pools: Extract<Query<&SkinPosePool>>,
     builtins: Extract<Res<BuiltinAttributes>>,
     mut extracted: ResMut<ExtractedParticlesDraws>,
 ) {
@@ -240,10 +287,24 @@ fn extract_particles_draws(
             .and_then(|e| buffers.get(e).ok())
             .map(|b| b.handle.clone());
 
+        let skin = p.skin.and_then(|ps| {
+            let phase_entity = p.buffer(ps.phase_attr)?;
+            let phase_buf = buffers.get(phase_entity).ok()?;
+            let pool = pools.get(ps.pool).ok()?;
+            Some((
+                phase_buf.handle.clone(),
+                pool.slots
+                    .iter()
+                    .map(|&e| MainEntity::from(e))
+                    .collect::<Vec<_>>(),
+            ))
+        });
+
         let key = PackPipelineKey {
             has_rotation: rotation.is_some(),
             has_scale: scale.is_some(),
             has_life: life.is_some(),
+            has_skin: skin.is_some(),
         };
         extracted.by_main.insert(
             MainEntity::from(entity),
@@ -253,6 +314,7 @@ fn extract_particles_draws(
                 rotation,
                 scale,
                 life,
+                skin,
             },
         );
     }
@@ -267,6 +329,7 @@ fn prepare_pack_bind_groups(
     batched_instance_buffers: Res<BatchedInstanceBuffers<MeshUniform, MeshInputUniform>>,
     culling_data_buffer: Res<MeshCullingDataBuffer>,
     gpu_buffers: Res<RenderAssets<GpuShaderBuffer>>,
+    skin_uniforms: Res<SkinUniforms>,
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     mut bind_groups: ResMut<ParticlesPackBindGroups>,
@@ -304,6 +367,34 @@ fn prepare_pack_bind_groups(
             continue;
         }
 
+        // Resolve the pose pool's live skin indices. Offsets can change any
+        // frame as skins come and go, so the table is rebuilt per frame; if
+        // the pool isn't fully extracted yet (first frame or two), skip the
+        // batch rather than draw with garbage joints.
+        let mut skin_bindings = None;
+        if let Some((phase_handle, slots)) = &data.skin {
+            let Some(gpu_phase) = gpu_buffers.get(phase_handle) else {
+                continue;
+            };
+            let mut table: Vec<u32> = Vec::with_capacity(slots.len());
+            for slot in slots {
+                match skin_uniforms.skin_byte_offset(*slot) {
+                    Some(offset) => table.push(offset.index()),
+                    None => break,
+                }
+            }
+            if table.len() != slots.len() || table.is_empty() {
+                continue;
+            }
+            let bytes: Vec<u8> = table.iter().flat_map(|v| v.to_le_bytes()).collect();
+            let table_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+                label: Some("particles_skin_index_table"),
+                contents: &bytes,
+                usage: BufferUsages::STORAGE,
+            });
+            skin_bindings = Some((gpu_phase, table_buffer, table.len() as u32));
+        }
+
         let pipeline_id =
             get_or_create_pipeline(&mut pipelines, &pipeline_cache, &shader.0, data.key);
         if !matches!(
@@ -317,6 +408,7 @@ fn prepare_pack_bind_groups(
         let params = ParticlesPackParams {
             base_input_index: reservation.input_buffer_base,
             count: reservation.max_capacity,
+            pool_size: skin_bindings.as_ref().map(|(_, _, k)| *k).unwrap_or(0),
             ..default()
         };
         let mut uniform = UniformBuffer::from(params);
@@ -358,6 +450,16 @@ fn prepare_pack_bind_groups(
             binding: 6,
             resource: uniform.binding().unwrap(),
         });
+        if let Some((gpu_phase, table_buffer, _)) = &skin_bindings {
+            entries.push(BindGroupEntry {
+                binding: 7,
+                resource: gpu_phase.buffer.as_entire_binding(),
+            });
+            entries.push(BindGroupEntry {
+                binding: 8,
+                resource: table_buffer.as_entire_binding(),
+            });
+        }
 
         let bind_group = render_device.create_bind_group(
             Some("particles_pack_bind_group"),
diff --git a/crates/processing_render/src/particles/pack.wgsl b/crates/processing_render/src/particles/pack.wgsl
index ef24a8eb..a6d321e3 100644
--- a/crates/processing_render/src/particles/pack.wgsl
+++ b/crates/processing_render/src/particles/pack.wgsl
@@ -24,7 +24,7 @@ struct MeshCullingData {
 struct PackParams {
     base_input_index: u32,
     count: u32,
-    _pad0: u32,
+    pool_size: u32,
     _pad1: u32,
 }
 
@@ -41,6 +41,13 @@ struct PackParams {
 @group(0) @binding(5) var<storage, read> life: array<f32>;
 #endif
 @group(0) @binding(6) var<uniform> params: PackParams;
+#ifdef HAS_SKIN
+// Per-particle animation phase in [0,1) and the pose pool's live skin
+// indices (joint-matrix offsets into the global skin array, refreshed every
+// frame by prepare — they are not stable across frames).
+@group(0) @binding(7) var<storage, read> skin_phase: array<f32>;
+@group(0) @binding(8) var<storage, read> skin_index_table: array<u32>;
+#endif
 
 fn quat_to_basis(q: vec4<f32>) -> mat3x3<f32> {
     let x = q.x; let y = q.y; let z = q.z; let w = q.w;
@@ -104,6 +111,15 @@ fn pack(@builtin(global_invocation_id) gid: vec3<u32>) {
     );
     mesh_input_buffer[slot].tag = i;
 
+#ifdef HAS_SKIN
+    let pool_size = params.pool_size;
+    let pose = min(u32(fract(skin_phase[i]) * f32(pool_size)), pool_size - 1u);
+    mesh_input_buffer[slot].current_skin_index = skin_index_table[pose];
+    // MESH_FLAGS_SKIN_INSTANCE_COMPOSE_BIT: the vertex shader composes this
+    // instance's transform with the pooled skeleton pose.
+    mesh_input_buffer[slot].flags = mesh_input_buffer[slot].flags | (1u << 26u);
+#endif
+
     mesh_culling_buffer[slot].aabb_center = vec3<f32>(0.0, 0.0, 0.0);
     mesh_culling_buffer[slot].aabb_half_extents = vec3<f32>(1.0, 1.0, 1.0);
 #ifdef HAS_LIFE
diff --git a/crates/processing_render/src/particles/point.wgsl b/crates/processing_render/src/particles/point.wgsl
index 14d418ed..5e8a8392 100644
--- a/crates/processing_render/src/particles/point.wgsl
+++ b/crates/processing_render/src/particles/point.wgsl
@@ -40,16 +40,6 @@ fn vertex(@builtin(vertex_index) vertex_index: u32) -> VertexOutput {
 
 @fragment
 fn fragment(frag: VertexOutput) -> @location(0) vec4<f32> {
-    var rgb = frag.color.rgb;
-#ifdef SHADED
-    #ifdef HAS_NORMALS
-    let normal = normalize(frag.normal);
-    #else
-    let normal = normalize(cross(dpdx(frag.world), dpdy(frag.world)));
-    #endif
-    let light = normalize(vec3<f32>(0.4, 0.85, 0.35));
-    let diffuse = abs(dot(normal, light));
-    rgb = rgb * (0.2 + 0.8 * diffuse);
-#endif
-    return vec4<f32>(rgb, frag.color.a);
+    // Per-vertex colour is authoritative — see the note in point_render.rs.
+    return frag.color;
 }
diff --git a/crates/processing_render/src/particles/point_render.rs b/crates/processing_render/src/particles/point_render.rs
index f1645255..a68cceb4 100644
--- a/crates/processing_render/src/particles/point_render.rs
+++ b/crates/processing_render/src/particles/point_render.rs
@@ -123,9 +123,21 @@ impl Specializer<RenderPipeline> for RasterSpecializer {
         if key.has_normal {
             defs.push("HAS_NORMALS");
         }
-        if matches!(topology, Topology::TriangleList | Topology::TriangleStrip) {
-            defs.push("SHADED");
-        }
+        // NO implicit shading. Triangle prims used to get a hardcoded
+        // directional light baked into point.wgsl (`SHADED`), with the normal
+        // derived from screen-space derivatives when the target had none. That
+        // meant:
+        //   * per-vertex colours were never what you got — a flat sheet facing
+        //     +Z came out at 0.48x, so a shader computing paper 244/240/232
+        //     could not match `background(244, 240, 232)`;
+        //   * no material call could turn it off, because this path bypasses
+        //     the material system entirely;
+        //   * geometry with more than one orientation shaded in bands. A
+        //     canvas folded into a wall and a floor rendered as two different
+        //     colours across the crease from identical vertex colours (0.48x
+        //     vs 0.89x for the hardcoded light at (0.4, 0.85, 0.35)).
+        // Prims carry per-vertex colour and the kernel that wrote them owns
+        // the look; shading is that kernel's business, not the renderer's.
         for def in defs {
             descriptor.vertex.shader_defs.push(def.into());
             if let Some(fragment) = descriptor.fragment.as_mut() {
diff --git a/crates/processing_render/src/particles/prims.rs b/crates/processing_render/src/particles/prims.rs
index 24182f05..5e0e9ba9 100644
--- a/crates/processing_render/src/particles/prims.rs
+++ b/crates/processing_render/src/particles/prims.rs
@@ -45,6 +45,9 @@ pub struct PrimitivesTarget {
     /// must happen on the GPU: a CPU-side asset write races the kernel
     /// dispatches, silently clobbering a frame's output either way it lands.
     pub reset_kernel: Entity,
+    /// Shader entity used only by `reset_kernel`; retained so destruction can
+    /// release the complete internally-created target graph.
+    pub reset_shader: Entity,
 }
 
 fn verts_per_prim(topology: Topology) -> error::Result<u32> {
@@ -113,11 +116,34 @@ pub fn particles_primitives_create(
                 verts_per_prim: vpp,
                 args,
                 reset_kernel,
+                reset_shader,
             })
             .id())
     })
 }
 
+/// Destroy a dynamic-topology target and every entity it created internally.
+/// The source particle field is borrowed and deliberately survives.
+pub fn particles_primitives_destroy(target_entity: Entity) -> error::Result<()> {
+    let (field, reset_kernel, reset_shader) = app_mut(|app| {
+        let target = app
+            .world()
+            .get::<PrimitivesTarget>(target_entity)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        Ok((target.field, target.reset_kernel, target.reset_shader))
+    })?;
+
+    // Destroy the internal field first: it owns the widened indirect args
+    // buffer through Connectivity. The reset compute borrows that buffer.
+    crate::particles_destroy(field)?;
+    crate::compute_destroy(reset_kernel)?;
+    crate::shader_destroy(reset_shader)?;
+    app_mut(|app| {
+        app.world_mut().entity_mut(target_entity).despawn();
+        Ok(())
+    })
+}
+
 /// Resolves a reserved `processing::prims` binding to its mangled reflected
 /// name in the kernel, then binds the buffer through the normal path.
 fn set_reserved_buffer(
diff --git a/crates/processing_render/src/render/filter.rs b/crates/processing_render/src/render/filter.rs
index 52a2a9b4..65744cc8 100644
--- a/crates/processing_render/src/render/filter.rs
+++ b/crates/processing_render/src/render/filter.rs
@@ -158,6 +158,7 @@ pub fn apply(app: &mut App, graphics: Entity, filter: Entity) -> Result<()> {
         )
     };
 
+    if std::env::var("PROCESSING_TRACE_VT").is_ok() { eprintln!("ENGINE filter apply"); }
     // flush() also extracts the shader asset to the render world.
     crate::graphics::flush(app, graphics)?;
 
diff --git a/crates/processing_render/src/render/material.rs b/crates/processing_render/src/render/material.rs
index 828f2862..5b1a4790 100644
--- a/crates/processing_render/src/render/material.rs
+++ b/crates/processing_render/src/render/material.rs
@@ -6,6 +6,7 @@ use std::ops::Deref;
 
 use crate::material::ProcessingMaterial;
 use crate::material::custom::{CustomMaterial, CustomMaterial3d};
+use crate::particles::material::ParticlesMaterial;
 
 #[derive(Component, Deref)]
 pub struct UntypedMaterial(pub UntypedHandle);
@@ -178,20 +179,37 @@ impl MaterialKey {
     }
 }
 
-pub fn add_processing_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
+/// Project `UntypedMaterial` onto the typed material component bevy renders
+/// with, and clear the slots the handle's type does *not* call for.
+///
+/// Draw entities outlive a single draw — every instanced body draw of one
+/// particle system shares `particles_data.draw_entity`, and mesh draws reuse
+/// their entity across frames — so a typed component left behind by an earlier
+/// material of a different type would keep the entity queued in that material's
+/// pipeline and overdraw the current one. Inserting without removing is what
+/// made a particle system drawn first with a constant-albedo (extended)
+/// material and then with a per-particle (particles) material render with the
+/// stale extended material.
+pub fn sync_typed_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
     for (entity, handle) in meshes.iter() {
         let handle = handle.deref().clone();
-        if let Ok(handle) = handle.try_typed::<ProcessingExtendedMaterial>() {
-            commands.entity(entity).insert(MeshMaterial3d(handle));
-        }
-    }
-}
+        let mut entity = commands.entity(entity);
 
-pub fn add_custom_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
-    for (entity, handle) in meshes.iter() {
-        let handle = handle.deref().clone();
-        if let Ok(handle) = handle.try_typed::<CustomMaterial>() {
-            commands.entity(entity).insert(CustomMaterial3d(handle));
+        if let Ok(handle) = handle.clone().try_typed::<ProcessingExtendedMaterial>() {
+            entity
+                .insert(MeshMaterial3d(handle))
+                .remove::<CustomMaterial3d>()
+                .remove::<MeshMaterial3d<ParticlesMaterial>>();
+        } else if let Ok(handle) = handle.clone().try_typed::<CustomMaterial>() {
+            entity
+                .insert(CustomMaterial3d(handle))
+                .remove::<MeshMaterial3d<ProcessingExtendedMaterial>>()
+                .remove::<MeshMaterial3d<ParticlesMaterial>>();
+        } else if let Ok(handle) = handle.try_typed::<ParticlesMaterial>() {
+            entity
+                .insert(MeshMaterial3d(handle))
+                .remove::<MeshMaterial3d<ProcessingExtendedMaterial>>()
+                .remove::<CustomMaterial3d>();
         }
     }
 }
diff --git a/crates/processing_render/src/render/mod.rs b/crates/processing_render/src/render/mod.rs
index bd892e9f..c7155689 100644
--- a/crates/processing_render/src/render/mod.rs
+++ b/crates/processing_render/src/render/mod.rs
@@ -12,6 +12,7 @@ use bevy::{
         visibility::{NoFrustumCulling, RenderLayers},
     },
     ecs::system::SystemParam,
+    log::warn_once,
     math::{Affine2, Affine3A, Mat4, Vec3A, Vec4},
     pbr::gpu_instance_batch::GpuBatchedMesh3d,
     prelude::*,
@@ -25,7 +26,7 @@ use primitive::{
     cone_mesh, conical_frustum_mesh, curve, cylinder_mesh, ellipse, empty_mesh, line, plane_mesh,
     quad, sphere_mesh, tetrahedron_mesh, torus_mesh, triangle,
 };
-use style::{Fill, StyleStack};
+use style::{Fill, Style, StyleStack};
 use transform::TransformStack;
 
 use crate::{
@@ -40,8 +41,21 @@ use crate::{
     text::font::TextContext,
 };
 
+/// How far each successive batch in a frame steps TOWARD the camera, so that
+/// draws resolve in painter's order: later submissions are nearer, which is
+/// what both arbiters of order want. The reverse-z depth test (GreaterEqual)
+/// keeps the nearest fragment, and `Transparent3d` sorts back-to-front and
+/// paints the nearest last. Stepping away from the camera instead inverts
+/// BOTH -- the frame renders in exact reverse submission order.
 pub(crate) const BATCH_INDEX_STEP: f32 = 0.001;
 
+/// View-space slab the 2d projection opens on the near side, so the
+/// `BATCH_INDEX_STEP` staircase has somewhere to climb before it reaches the
+/// near plane. At 0.001 units a batch this is room for 64k draws in one
+/// frame. It only ever adds visible volume, so nothing a sketch used to draw
+/// can fall out of the frustum because of it.
+pub(crate) const NEAR_HEADROOM: f32 = 64.0;
+
 #[derive(Component)]
 #[relationship(relationship_target = TransientMeshes)]
 pub struct BelongsToGraphics(pub Entity);
@@ -934,12 +948,32 @@ pub fn flush_draw_commands(
                                 *blend_state,
                             )
                         }
+                        // The Color key relies on per-vertex colors, which 2D
+                        // tessellation bakes in but shared model meshes lack —
+                        // the fill has to become the material's base color.
+                        MaterialKey::Color { .. } => {
+                            let mut base = material_key.to_standard_material();
+                            base.base_color = state
+                                .style
+                                .fill
+                                .color()
+                                .unwrap_or(bevy::color::Color::WHITE);
+                            res.materials
+                                .add(ProcessingExtendedMaterial {
+                                    base,
+                                    extension: ProcessingMaterial {
+                                        blend_state: material_key.blend_state(),
+                                        depth_write: None,
+                                    },
+                                })
+                                .untyped()
+                        }
                         _ => material_key.to_material(&mut res.materials),
                     };
 
                     flush_batch(&mut res, &mut batch, &p_material_handles);
 
-                    let z_offset = -(batch.draw_index as f32 * BATCH_INDEX_STEP);
+                    let z_offset = batch.draw_index as f32 * BATCH_INDEX_STEP;
                     let mut transform = state.transform.to_bevy_transform();
 
                     // if the "source" geometry was parented in a gltf scene, we need to make sure that
@@ -951,13 +985,16 @@ pub fn flush_draw_commands(
                     }
                     transform.translation.z += z_offset;
 
-                    res.commands.spawn((
+                    let mut entity = res.commands.spawn((
                         Mesh3d(geometry.handle.clone()),
                         UntypedMaterial(material_handle),
                         BelongsToGraphics(batch.graphics_entity),
                         transform,
                         batch.render_layers.clone(),
                     ));
+                    apply_stroke(&mut entity, &state.style);
+                    warn_if_unstrokeable(&res.meshes, &geometry.handle, &state.style);
+                    warn_if_skinned(&res.meshes, &geometry.handle);
 
                     batch.draw_index += 1;
                 }
@@ -1675,7 +1712,7 @@ fn flush_batch(
     material_handles: &Query<&UntypedMaterial>,
 ) {
     if let Some(mesh) = batch.current_mesh.take() {
-        let z_offset = -(batch.draw_index as f32 * BATCH_INDEX_STEP);
+        let z_offset = batch.draw_index as f32 * BATCH_INDEX_STEP;
         spawn_mesh(res, batch, mesh, z_offset, material_handles);
         batch.draw_index += 1;
     }
@@ -1689,8 +1726,6 @@ fn add_shape3d(
     mesh: Mesh,
     material_handles: &Query<&UntypedMaterial>,
 ) {
-    use bevy::pbr::wireframe::{Wireframe, WireframeColor, WireframeLineWidth, WireframeTopology};
-
     flush_batch(res, batch, material_handles);
 
     let mesh_handle = res.meshes.add(mesh);
@@ -1737,7 +1772,7 @@ fn add_shape3d(
         }
     };
 
-    let z_offset = -(batch.draw_index as f32 * BATCH_INDEX_STEP);
+    let z_offset = batch.draw_index as f32 * BATCH_INDEX_STEP;
     let mut transform = state.transform.to_bevy_transform();
     transform.translation.z += z_offset;
 
@@ -1749,22 +1784,102 @@ fn add_shape3d(
         batch.render_layers.clone(),
     ));
 
-    if let Some(stroke_color) = state.style.stroke_color {
-        entity.insert((
-            Wireframe,
-            WireframeColor {
-                color: stroke_color,
-            },
-            WireframeLineWidth {
-                width: state.style.stroke_weight,
-            },
-            WireframeTopology::Quads,
-        ));
-    }
+    apply_stroke(&mut entity, &state.style);
 
     batch.draw_index += 1;
 }
 
+/// Say so when a mesh has a `stroke()` that cannot be drawn.
+///
+/// The wireframe pass pulls vertices through the index buffer, so it silently
+/// skips a mesh that has none -- the stroke just does not appear, with no
+/// error anywhere. Meshes built in-engine are always indexed; ones that
+/// arrive through `Geometry` are whatever the file and the loader between
+/// them produced, which for a gltf primitive is often non-indexed.
+fn warn_if_unstrokeable(meshes: &Assets<Mesh>, handle: &Handle<Mesh>, style: &Style) {
+    if style.stroke_color.is_none() {
+        return;
+    }
+    if meshes
+        .get(handle)
+        .is_some_and(|mesh| mesh.indices().is_none())
+    {
+        warn_once!(
+            "stroke() is set on a mesh with no index buffer, so no outline will be drawn. \
+             The wireframe pass reads vertices through the indices; a mesh loaded without \
+             them (a gltf primitive with no normals, for instance) cannot be outlined."
+        );
+    }
+}
+
+/// Say so when a rigged mesh is drawn immediate-mode and its fill will not
+/// appear.
+///
+/// bevy decides a mesh is skinned from its vertex layout alone -- joint index
+/// and joint weight attributes present -- and specializes the pipeline for
+/// skinning on that basis, without reference to the entity or the material. A
+/// single `shape()` draw has no skin to hand it, so the fill quietly produces
+/// nothing: no error, no pixels, whatever material is set. `stroke()` is
+/// unaffected, because the wireframe pass reads positions straight out of the
+/// vertex buffer and never asks about skinning -- which is how a rigged mesh
+/// can come out as an outline with nothing inside it.
+///
+/// The instanced path is the one that can pose a rigged mesh: `particles()`
+/// with a skin pool supplies the per-instance skin this draw cannot.
+fn warn_if_skinned(meshes: &Assets<Mesh>, handle: &Handle<Mesh>) {
+    let is_skinned = meshes.get(handle).is_some_and(|mesh| {
+        mesh.attribute(Mesh::ATTRIBUTE_JOINT_INDEX).is_some()
+            && mesh.attribute(Mesh::ATTRIBUTE_JOINT_WEIGHT).is_some()
+    });
+    if is_skinned {
+        warn_once!(
+            "a rigged (skinned) mesh is being drawn as a single shape, so its fill will \
+             not appear: the mesh's joint attributes make the pipeline expect per-instance \
+             skin data that a single draw does not supply, whatever material is set. \
+             stroke() still outlines it. To draw a rigged mesh posed, put it through the \
+             instanced path with a skin pool."
+        );
+    }
+}
+
+/// Attach `stroke()` to a just-spawned 3d mesh, as a wireframe over its edges.
+///
+/// Every 3d mesh spawn goes through here, because in Processing `stroke()`
+/// applies to whatever you draw rather than to a privileged list of shapes:
+/// the built-in primitives `add_shape3d` builds, and the `DrawCommand::Geometry`
+/// path that `shape()`, `createShape()` meshes and loaded glTF models take.
+///
+/// `WireframeTopology::Quads` suppresses the diagonal shared by a pair of
+/// triangles that form a quad, which is what makes `box()` draw its 12 real
+/// edges instead of all 18 with face diagonals -- the classic Processing look.
+/// Detection is index-order based (consecutive triangle pairs sharing two
+/// vertices), so a quad-derived mesh -- cuboid, uv sphere, plane -- gets the
+/// quad edges, and a mesh that is genuinely triangles falls through to its
+/// triangle edges instead of getting a wrong answer.
+///
+/// `WireframeLineWidth` is in screen-space pixels, which is the unit
+/// `strokeWeight` already means everywhere else.
+fn apply_stroke(entity: &mut EntityCommands, style: &Style) {
+    use bevy::pbr::wireframe::{Wireframe, WireframeColor, WireframeLineWidth, WireframeTopology};
+
+    // `no_stroke()` clears the color, and that is the whole switch -- there is
+    // no separate enable flag to consult.
+    let Some(stroke_color) = style.stroke_color else {
+        return;
+    };
+
+    entity.insert((
+        Wireframe,
+        WireframeColor {
+            color: stroke_color,
+        },
+        WireframeLineWidth {
+            width: style.stroke_weight,
+        },
+        WireframeTopology::Quads,
+    ));
+}
+
 /// fullscreen quad built by transforming NDC corners by the inverse clip-from-world matrix,
 /// so the vertex shader's `clip_from_world` brings them back to NDC.
 fn create_ndc_background_quad(world_from_clip: Mat4, color: Color, with_uvs: bool) -> Mesh {
diff --git a/crates/processing_render/src/render/primitive/mod.rs b/crates/processing_render/src/render/primitive/mod.rs
index c4f20d63..bc6e66ae 100644
--- a/crates/processing_render/src/render/primitive/mod.rs
+++ b/crates/processing_render/src/render/primitive/mod.rs
@@ -31,8 +31,8 @@ pub use shape::{
     build_polygon_stroke,
 };
 pub use shape3d::{
-    box_mesh, capsule_mesh, cone_mesh, conical_frustum_mesh, cylinder_mesh, grid_mesh, plane_mesh,
-    sphere_mesh, tetrahedron_mesh, torus_mesh,
+    box_mesh, capsule_mesh, cone_mesh, conical_frustum_mesh, cylinder_mesh, ensure_vertex_colors,
+    grid_mesh, plane_mesh, sphere_mesh, tetrahedron_mesh, torus_mesh,
 };
 pub use triangle::triangle;
 
diff --git a/crates/processing_render/src/render/primitive/shape3d.rs b/crates/processing_render/src/render/primitive/shape3d.rs
index 1e4889b3..bb5f4583 100644
--- a/crates/processing_render/src/render/primitive/shape3d.rs
+++ b/crates/processing_render/src/render/primitive/shape3d.rs
@@ -3,7 +3,15 @@ use bevy::mesh::PrimitiveTopology;
 use bevy::prelude::*;
 use bevy::render::mesh::VertexAttributeValues;
 
-fn ensure_vertex_colors(mesh: &mut Mesh) {
+/// Give a mesh the white vertex-color attribute if it has none.
+///
+/// Every mesh the engine draws is expected to carry one -- the `VertexLayout`
+/// the geometry paths declare names `color` -- so a mesh that arrives without
+/// it (from a gltf primitive, say) has to be brought up to the same shape.
+/// White is the identity for the shaders that consume it, so a mesh that
+/// already has colors keeps them and one that does not is unchanged in
+/// appearance.
+pub fn ensure_vertex_colors(mesh: &mut Mesh) {
     if mesh.attribute(Mesh::ATTRIBUTE_COLOR).is_none() {
         let vertex_count = mesh
             .attribute(Mesh::ATTRIBUTE_POSITION)
diff --git a/crates/processing_render/src/surface.rs b/crates/processing_render/src/surface.rs
index 4feb630f..0b098509 100644
--- a/crates/processing_render/src/surface.rs
+++ b/crates/processing_render/src/surface.rs
@@ -24,11 +24,13 @@ use bevy::{
     camera::RenderTarget,
     ecs::query::QueryEntityError,
     math::{IRect, IVec2},
-    prelude::{Commands, Component, Entity, In, Query, ResMut, Window, With, default},
+    prelude::{
+        Commands, Component, Entity, In, MessageWriter, Query, ResMut, Window, With, default,
+    },
     render::render_resource::{Extent3d, TextureFormat},
     window::{
-        CompositeAlphaMode, Monitor, RawHandleWrapper, WindowLevel, WindowMode, WindowPosition,
-        WindowRef, WindowResolution, WindowWrapper,
+        CompositeAlphaMode, Monitor, PresentMode, RawHandleWrapper, WindowLevel, WindowMode,
+        WindowPosition, WindowRef, WindowResized, WindowResolution, WindowWrapper,
     },
 };
 use raw_window_handle::{
@@ -418,6 +420,7 @@ pub fn resize(
     In((window_entity, width, height)): In<(Entity, u32, u32)>,
     mut windows: Query<&mut Window>,
     mut graphics_query: Query<(&RenderTarget, &mut SurfaceSize)>,
+    mut resized: MessageWriter<WindowResized>,
 ) -> Result<()> {
     let width = width.max(1);
     let height = height.max(1);
@@ -439,9 +442,68 @@ pub fn resize(
             *surface_size = SurfaceSize(width, height);
         }
     }
+
+    // `camera_system` recomputes a camera's `clip_from_view` off this message
+    // and nothing else -- it does not watch `Window` for changes. Without it a
+    // resized surface keeps the projection it was built with: the swapchain and
+    // `SurfaceSize` follow, but 2d drawing coordinates stop meaning content
+    // pixels and a 3d camera keeps the stale aspect ratio. The Rust-side GLFW
+    // runner used to write this itself, which left the FFI path (every
+    // JVM-hosted sketch, and every `window_set_size` on a secondary window)
+    // without it. Writing it here covers both callers.
+    resized.write(WindowResized {
+        window: window_entity,
+        width: width as f32,
+        height: height as f32,
+    });
     Ok(())
 }
 
+/// Set a window surface's swapchain present mode.
+///
+/// `vsync` false selects [`PresentMode::AutoNoVsync`], asking for a draw loop
+/// that is not paced to the display's refresh rate (falling back `Immediate`
+/// -> `Mailbox` -> `Fifo` where the platform lacks it, unlike bare
+/// `Immediate` / `Mailbox`, which panic when unsupported). That is what an
+/// offline render wants: nothing is watching the window, and captures read
+/// back the canvas texture rather than the swapchain, so tearing cannot reach
+/// the file.
+///
+/// `vsync` true restores [`PresentMode::AutoVsync`]. The window is created
+/// vsynced ([`PresentMode::Fifo`], bevy's `Window` default), so a caller that
+/// never touches this keeps the paced behaviour.
+///
+/// **This buys nothing on macOS** (measured 2026-08-30, `quil/dev/vsync_probe.clj`).
+/// Metal offers only `Fifo` and `Immediate`, so `AutoNoVsync` resolves to
+/// `Immediate` = `CAMetalLayer.setDisplaySyncEnabled(false)` — and a composited
+/// `CAMetalLayer` still gets its drawables released on the compositor's
+/// cadence, so `nextDrawable` stays paced by refresh regardless. A trivial
+/// draw measures 120.0 fps vsynced and 118.4 fps not, on a 120 Hz display.
+/// What actually sets the ceiling there is the window's SIZE: a 3840x4320
+/// window paces at exactly 60 fps in both modes, because compositing it does
+/// not fit in one vblank. Render offscreen behind a small window instead.
+pub fn set_vsync(
+    In((window_entity, vsync)): In<(Entity, bool)>,
+    mut windows: Query<&mut Window>,
+) -> Result<()> {
+    let mode = if vsync {
+        PresentMode::AutoVsync
+    } else {
+        PresentMode::AutoNoVsync
+    };
+    if let Ok(mut window) = windows.get_mut(window_entity) {
+        // Guarded so an unchanged mode doesn't trip change detection: bevy
+        // reconfigures the swapchain whenever `present_mode` differs from the
+        // extracted one, and there is no reason to churn it every call.
+        if window.present_mode != mode {
+            window.present_mode = mode;
+        }
+        Ok(())
+    } else {
+        Err(error::ProcessingError::SurfaceNotFound)
+    }
+}
+
 pub fn set_pixel_density(
     In((window_entity, density)): In<(Entity, f32)>,
     mut windows: Query<&mut Window>,
diff --git a/crates/processing_video/Cargo.toml b/crates/processing_video/Cargo.toml
index 3a6f0fbe..fcb3870b 100644
--- a/crates/processing_video/Cargo.toml
+++ b/crates/processing_video/Cargo.toml
@@ -14,5 +14,19 @@ processing_render = { workspace = true }
 thiserror = "2"
 video-rs = "0.11"
 
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = "0.6"
+objc2-foundation = "0.3"
+objc2-core-foundation = "0.3"
+objc2-core-video = { version = "0.3", features = ["objc2-io-surface"] }
+objc2-core-media = "0.3"
+objc2-av-foundation = { version = "0.3", features = [
+    "objc2-core-media",
+    "objc2-core-video",
+    "block2",
+] }
+objc2-io-surface = "0.3"
+block2 = "0.6"
+
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/processing_video/src/lib.rs b/crates/processing_video/src/lib.rs
index 5f1fbf6b..4c353d90 100644
--- a/crates/processing_video/src/lib.rs
+++ b/crates/processing_video/src/lib.rs
@@ -14,6 +14,10 @@ pub use record::{
     RecorderCodec, RecorderPixelFormat, VideoRecordError, VideoRecorder, VideoRecorderConfig,
 };
 
+/// GPU-resident recording through AVFoundation; macOS only.
+#[cfg(target_os = "macos")]
+pub mod macos;
+
 use processing_core::app_mut;
 use processing_core::error::{ProcessingError, Result};
 use processing_render::image;
diff --git a/crates/processing_video/src/macos.rs b/crates/processing_video/src/macos.rs
new file mode 100644
index 00000000..f4eeb55d
--- /dev/null
+++ b/crates/processing_video/src/macos.rs
@@ -0,0 +1,660 @@
+//! GPU-resident video recording via AVFoundation (macOS only).
+//!
+//! The zero-copy counterpart to [`crate::record`]: instead of reading frames
+//! back to the CPU and feeding them through ffmpeg, the render side blits each
+//! frame straight into an IOSurface-backed `CVPixelBuffer` and the buffer is
+//! handed to an `AVAssetWriter`, which drives the hardware (media engine)
+//! encoder and muxes the container. The CPU never touches a pixel.
+//!
+//! This module owns everything AVFoundation/CoreVideo. It knows nothing about
+//! wgpu; the render side receives only a raw `IOSurfaceRef` pointer from
+//! [`AvfFrame::iosurface_ptr`] and reports GPU completion through
+//! [`AvfCompleter::complete`], which may be called from any thread.
+//!
+//! Per-frame flow (all bookkeeping, no pixel work):
+//!   acquire_frame() ── pool buffer, bounded by MAX_IN_FLIGHT ──▶ GPU blit
+//!   ──▶ AvfCompleter::complete(frame) on GPU completion ──▶ writer thread
+//!   reorders by frame index and appends with pts = index / fps.
+
+use std::collections::BTreeMap;
+use std::ffi::c_void;
+use std::path::Path;
+use std::ptr::NonNull;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{Receiver, Sender, channel};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+use std::time::{Duration, Instant};
+
+use objc2::AnyThread;
+use objc2::rc::Retained;
+use objc2::runtime::AnyObject;
+use objc2_av_foundation::{
+    AVAssetWriter, AVAssetWriterInput, AVAssetWriterInputPixelBufferAdaptor, AVAssetWriterStatus,
+    AVFileType, AVFileTypeAppleM4V, AVFileTypeMPEG4, AVFileTypeQuickTimeMovie, AVMediaTypeVideo,
+    AVVideoAllowFrameReorderingKey, AVVideoAverageBitRateKey, AVVideoCodecKey,
+    AVVideoCodecTypeH264, AVVideoCodecTypeHEVC, AVVideoColorPrimaries_ITU_R_709_2,
+    AVVideoColorPrimariesKey, AVVideoColorPropertiesKey, AVVideoCompressionPropertiesKey,
+    AVVideoExpectedSourceFrameRateKey, AVVideoHeightKey, AVVideoTransferFunction_ITU_R_709_2,
+    AVVideoTransferFunctionKey, AVVideoWidthKey, AVVideoYCbCrMatrix_ITU_R_709_2,
+    AVVideoYCbCrMatrixKey,
+};
+use objc2_core_foundation::{CFRetained, CFString};
+use objc2_core_media::{CMTime, CMTimeFlags};
+use objc2_core_video::{
+    CVAttachmentMode, CVPixelBuffer, CVPixelBufferGetIOSurface, CVPixelBufferPool,
+    kCVImageBufferColorPrimaries_ITU_R_709_2, kCVImageBufferColorPrimariesKey,
+    kCVImageBufferTransferFunction_ITU_R_709_2, kCVImageBufferTransferFunctionKey,
+    kCVImageBufferYCbCrMatrix_ITU_R_709_2, kCVImageBufferYCbCrMatrixKey, kCVPixelBufferHeightKey,
+    kCVPixelBufferIOSurfacePropertiesKey, kCVPixelBufferMetalCompatibilityKey,
+    kCVPixelBufferPixelFormatTypeKey, kCVPixelBufferWidthKey, kCVPixelFormatType_32BGRA,
+    kCVReturnSuccess,
+};
+use objc2_foundation::{NSCopying, NSDictionary, NSNumber, NSString, NSURL};
+use objc2_io_surface::IOSurfaceRef;
+
+/// Frames allowed between `acquire_frame` and their append completing.
+/// Bounds pool memory and how far the render loop can run ahead of the
+/// encoder — the same role as `READBACK_RING_DEPTH` on the CPU path.
+pub const MAX_IN_FLIGHT: usize = 3;
+
+/// How long to wait on a stalled encoder before giving up. The media engine
+/// encodes far faster than any sketch renders, so hitting this means the
+/// writer thread died or the device was torn down mid-frame.
+const STALL_TIMEOUT: Duration = Duration::from_secs(10);
+
+#[derive(Debug, thiserror::Error)]
+#[error("avf record: {0}")]
+pub struct AvfRecordError(pub String);
+
+type Result<T> = std::result::Result<T, AvfRecordError>;
+
+fn err(msg: impl Into<String>) -> AvfRecordError {
+    AvfRecordError(msg.into())
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AvfCodec {
+    H264,
+    Hevc,
+}
+
+#[derive(Debug, Clone)]
+pub struct AvfRecorderConfig {
+    pub width: u32,
+    pub height: u32,
+    pub fps: f64,
+    pub codec: AvfCodec,
+    /// Target bitrate in bits per second. `None` picks ~0.1 bits/pixel/frame,
+    /// matching the ffmpeg VideoToolbox path.
+    pub bitrate: Option<u64>,
+    /// `Some(0)` disables frame reordering (no B frames). Other values are
+    /// left to the encoder — AVFoundation exposes only the on/off switch.
+    pub bframes: Option<u32>,
+}
+
+impl AvfRecorderConfig {
+    fn bitrate_bps(&self) -> f64 {
+        match self.bitrate {
+            Some(b) => b as f64,
+            None => (self.width as f64 * self.height as f64 * self.fps * 0.1).max(1_000_000.0),
+        }
+    }
+}
+
+/// CF objects are thread-safe refcounted; the pixel data is only ever touched
+/// by the GPU and the encoder, so moving the handles across threads is fine.
+struct SendCf<T>(CFRetained<T>);
+unsafe impl<T> Send for SendCf<T> {}
+
+/// The AVFoundation objects live on whatever thread uses them; Apple's
+/// contract is "don't call concurrently", which the writer thread upholds by
+/// being their only user after `startWriting`.
+struct WriterObjects {
+    writer: Retained<AVAssetWriter>,
+    input: Retained<AVAssetWriterInput>,
+    adaptor: Retained<AVAssetWriterInputPixelBufferAdaptor>,
+}
+unsafe impl Send for WriterObjects {}
+
+/// Decrements the in-flight count when dropped — after a successful append,
+/// or when a frame is abandoned (device teardown drops the GPU callback).
+struct InFlightPermit(Arc<(Mutex<usize>, Condvar)>);
+
+impl Drop for InFlightPermit {
+    fn drop(&mut self) {
+        let (count, cv) = &*self.0;
+        *count.lock().unwrap() -= 1;
+        cv.notify_all();
+    }
+}
+
+/// One frame's pixel buffer, checked out of the pool. Blit into its IOSurface
+/// on the GPU, then pass it to [`AvfCompleter::complete`] once the GPU work is
+/// done. Dropping it without completing simply skips the frame.
+pub struct AvfFrame {
+    buffer: SendCf<CVPixelBuffer>,
+    surface: SendCf<IOSurfaceRef>,
+    index: u64,
+    _permit: InFlightPermit,
+}
+
+impl AvfFrame {
+    /// Raw `IOSurfaceRef` pointer for the render side to wrap as a texture.
+    /// Valid for the lifetime of this frame.
+    pub fn iosurface_ptr(&self) -> *mut c_void {
+        CFRetained::as_ptr(&self.surface.0).as_ptr().cast()
+    }
+
+    /// Stable identity of the underlying IOSurface, for caching texture wraps
+    /// across the pool's recycling.
+    pub fn iosurface_id(&self) -> u32 {
+        self.surface.0.id()
+    }
+
+    pub fn index(&self) -> u64 {
+        self.index
+    }
+}
+
+/// Cloneable handle for reporting GPU completion of a frame; safe to call
+/// from any thread (wgpu's completion callback thread, in practice).
+#[derive(Clone)]
+pub struct AvfCompleter {
+    tx: Sender<AvfFrame>,
+}
+
+impl AvfCompleter {
+    /// Queue the frame for appending. Ignores a finished/failed recorder —
+    /// the frame is dropped and its permit released either way.
+    pub fn complete(&self, frame: AvfFrame) {
+        let _ = self.tx.send(frame);
+    }
+}
+
+/// Hardware video recorder writing through AVAssetWriter. Frames are appended
+/// in index order with timestamps from the frame index and configured fps,
+/// never wall-clock time.
+pub struct AvfRecorder {
+    tx: Option<Sender<AvfFrame>>,
+    handle: Option<thread::JoinHandle<Result<u64>>>,
+    pool: SendCf<CVPixelBufferPool>,
+    in_flight: Arc<(Mutex<usize>, Condvar)>,
+    died: Arc<AtomicBool>,
+    next_index: u64,
+    config: AvfRecorderConfig,
+}
+
+/// Resolve one of AVFoundation's weak-linked string constants.
+fn avk(v: Option<&'static NSString>, name: &str) -> Result<&'static NSString> {
+    v.ok_or_else(|| err(format!("AVFoundation constant {name} unavailable")))
+}
+
+/// The CV pixel-buffer keys are CFStrings; the AV settings dictionaries want
+/// NSStrings. Toll-free bridged, so the cast is the sanctioned conversion.
+fn cf_as_ns(s: &CFString) -> &NSString {
+    let ptr: *const CFString = s;
+    unsafe { &*ptr.cast::<NSString>() }
+}
+
+fn any(obj: Retained<NSNumber>) -> Retained<AnyObject> {
+    unsafe { Retained::cast_unchecked(obj) }
+}
+
+fn any_str(obj: &NSString) -> Retained<AnyObject> {
+    unsafe { Retained::cast_unchecked(obj.copy()) }
+}
+
+/// pts timescale: fps × 1000 keeps fractional rates (59.94 → 59940) exact
+/// enough that no two frames collapse onto one timestamp.
+fn timescale(fps: f64) -> i32 {
+    (fps * 1000.0).round().clamp(1.0, i32::MAX as f64) as i32
+}
+
+fn pts(index: u64, ts: i32) -> CMTime {
+    CMTime {
+        value: index as i64 * 1000,
+        timescale: ts,
+        flags: CMTimeFlags::Valid,
+        epoch: 0,
+    }
+}
+
+fn file_type(path: &Path) -> Result<&'static AVFileType> {
+    let ext = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.to_ascii_lowercase())
+        .unwrap_or_default();
+    let ft = match ext.as_str() {
+        "mp4" => unsafe { AVFileTypeMPEG4 },
+        "mov" => unsafe { AVFileTypeQuickTimeMovie },
+        "m4v" => unsafe { AVFileTypeAppleM4V },
+        other => {
+            return Err(err(format!(
+                "unsupported container .{other} for the hardware recorder \
+                 (expected .mp4, .mov, or .m4v)"
+            )));
+        }
+    };
+    ft.ok_or_else(|| err("AVFoundation file type constant unavailable"))
+}
+
+fn writer_error(writer: &AVAssetWriter, context: &str) -> AvfRecordError {
+    let detail = unsafe { writer.error() }
+        .map(|e| e.localizedDescription().to_string())
+        .unwrap_or_else(|| "no error detail".to_string());
+    err(format!("{context}: {detail}"))
+}
+
+impl AvfRecorder {
+    pub fn new(path: impl AsRef<Path>, config: AvfRecorderConfig) -> Result<Self> {
+        let path = path.as_ref();
+        if config.width == 0 || config.height == 0 {
+            return Err(err("width and height must be non-zero"));
+        }
+        if !(config.fps.is_finite() && config.fps > 0.0 && config.fps <= 1_000_000.0) {
+            return Err(err(format!(
+                "fps must be a positive number, got {}",
+                config.fps
+            )));
+        }
+        let file_type = file_type(path)?;
+        // AVAssetWriter refuses to overwrite; ffmpeg's behavior (and ours so
+        // far) is to replace the file.
+        if path.exists() {
+            std::fs::remove_file(path)
+                .map_err(|e| err(format!("cannot replace {}: {e}", path.display())))?;
+        }
+        let path_str = path
+            .to_str()
+            .ok_or_else(|| err("output path is not valid UTF-8"))?;
+        let url = NSURL::fileURLWithPath(&NSString::from_str(path_str));
+
+        let writer = unsafe {
+            AVAssetWriter::initWithURL_fileType_error(AVAssetWriter::alloc(), &url, file_type)
+        }
+        .map_err(|e| err(format!("creating AVAssetWriter: {}", e.localizedDescription())))?;
+
+        let codec_name = match config.codec {
+            AvfCodec::H264 => avk(unsafe { AVVideoCodecTypeH264 }, "H264")?,
+            AvfCodec::Hevc => avk(unsafe { AVVideoCodecTypeHEVC }, "HEVC")?,
+        };
+
+        // Tag the track 709 across the board: the canvas bytes are
+        // sRGB-encoded, and 709-in/709-out means the RGB→YCbCr conversion is
+        // a pure matrix with no transfer-function resampling — the same
+        // treatment the ffmpeg path gives them, but with the file explicitly
+        // tagged instead of left for players to guess.
+        let color_props = NSDictionary::<NSString, AnyObject>::from_retained_objects(
+            &[
+                avk(unsafe { AVVideoColorPrimariesKey }, "ColorPrimariesKey")?,
+                avk(unsafe { AVVideoTransferFunctionKey }, "TransferFunctionKey")?,
+                avk(unsafe { AVVideoYCbCrMatrixKey }, "YCbCrMatrixKey")?,
+            ],
+            &[
+                any_str(avk(
+                    unsafe { AVVideoColorPrimaries_ITU_R_709_2 },
+                    "Primaries709",
+                )?),
+                any_str(avk(
+                    unsafe { AVVideoTransferFunction_ITU_R_709_2 },
+                    "Transfer709",
+                )?),
+                any_str(avk(unsafe { AVVideoYCbCrMatrix_ITU_R_709_2 }, "Matrix709")?),
+            ],
+        );
+
+        let compression = NSDictionary::<NSString, AnyObject>::from_retained_objects(
+            &[
+                avk(unsafe { AVVideoAverageBitRateKey }, "AverageBitRateKey")?,
+                avk(
+                    unsafe { AVVideoExpectedSourceFrameRateKey },
+                    "ExpectedSourceFrameRateKey",
+                )?,
+                avk(
+                    unsafe { AVVideoAllowFrameReorderingKey },
+                    "AllowFrameReorderingKey",
+                )?,
+            ],
+            &[
+                any(NSNumber::numberWithDouble(config.bitrate_bps())),
+                any(NSNumber::numberWithDouble(config.fps)),
+                any(NSNumber::numberWithBool(config.bframes != Some(0))),
+            ],
+        );
+
+        let settings = NSDictionary::<NSString, AnyObject>::from_retained_objects(
+            &[
+                avk(unsafe { AVVideoCodecKey }, "CodecKey")?,
+                avk(unsafe { AVVideoWidthKey }, "WidthKey")?,
+                avk(unsafe { AVVideoHeightKey }, "HeightKey")?,
+                avk(unsafe { AVVideoColorPropertiesKey }, "ColorPropertiesKey")?,
+                avk(
+                    unsafe { AVVideoCompressionPropertiesKey },
+                    "CompressionPropertiesKey",
+                )?,
+            ],
+            &[
+                any_str(codec_name),
+                any(NSNumber::numberWithUnsignedInt(config.width)),
+                any(NSNumber::numberWithUnsignedInt(config.height)),
+                unsafe { Retained::cast_unchecked(color_props) },
+                unsafe { Retained::cast_unchecked(compression) },
+            ],
+        );
+
+        let media_type = unsafe { AVMediaTypeVideo }
+            .ok_or_else(|| err("AVMediaTypeVideo constant unavailable"))?;
+        let input = unsafe {
+            AVAssetWriterInput::initWithMediaType_outputSettings(
+                AVAssetWriterInput::alloc(),
+                media_type,
+                Some(&settings),
+            )
+        };
+        // Offline source: readyForMoreMediaData throttles us instead of
+        // dropping frames.
+        unsafe { input.setExpectsMediaDataInRealTime(false) };
+        if !unsafe { writer.canAddInput(&input) } {
+            return Err(err("AVAssetWriter rejected the video input"));
+        }
+        unsafe { writer.addInput(&input) };
+
+        // The adaptor's own pool vends the IOSurface-backed, Metal-compatible
+        // BGRA buffers the GPU blits into.
+        let empty = NSDictionary::<NSString, AnyObject>::new();
+        let attrs = NSDictionary::<NSString, AnyObject>::from_retained_objects(
+            &[
+                cf_as_ns(unsafe { kCVPixelBufferPixelFormatTypeKey }),
+                cf_as_ns(unsafe { kCVPixelBufferWidthKey }),
+                cf_as_ns(unsafe { kCVPixelBufferHeightKey }),
+                cf_as_ns(unsafe { kCVPixelBufferIOSurfacePropertiesKey }),
+                cf_as_ns(unsafe { kCVPixelBufferMetalCompatibilityKey }),
+            ],
+            &[
+                any(NSNumber::numberWithUnsignedInt(kCVPixelFormatType_32BGRA)),
+                any(NSNumber::numberWithUnsignedInt(config.width)),
+                any(NSNumber::numberWithUnsignedInt(config.height)),
+                unsafe { Retained::cast_unchecked(empty) },
+                any(NSNumber::numberWithBool(true)),
+            ],
+        );
+        let adaptor = unsafe {
+            AVAssetWriterInputPixelBufferAdaptor::initWithAssetWriterInput_sourcePixelBufferAttributes(
+                AVAssetWriterInputPixelBufferAdaptor::alloc(),
+                &input,
+                Some(&attrs),
+            )
+        };
+
+        if !unsafe { writer.startWriting() } {
+            return Err(writer_error(&writer, "startWriting failed"));
+        }
+        unsafe { writer.startSessionAtSourceTime(pts(0, timescale(config.fps))) };
+
+        let pool = unsafe { adaptor.pixelBufferPool() }
+            .ok_or_else(|| err("adaptor vended no pixel buffer pool"))?;
+        let pool = SendCf(unsafe {
+            CFRetained::retain(NonNull::new_unchecked(Retained::as_ptr(&pool) as *mut _))
+        });
+
+        let (tx, rx) = channel();
+        let in_flight = Arc::new((Mutex::new(0usize), Condvar::new()));
+        let died = Arc::new(AtomicBool::new(false));
+        let objects = WriterObjects {
+            writer,
+            input,
+            adaptor,
+        };
+        let ts = timescale(config.fps);
+        let died_w = Arc::clone(&died);
+        let handle = thread::Builder::new()
+            .name("processing_avf_encode".to_string())
+            .spawn(move || {
+                let r = writer_main(objects, rx, ts);
+                if r.is_err() {
+                    died_w.store(true, Ordering::Release);
+                }
+                r
+            })
+            .expect("failed to spawn AVF writer thread");
+
+        Ok(Self {
+            tx: Some(tx),
+            handle: Some(handle),
+            pool,
+            in_flight,
+            died,
+            next_index: 0,
+            config,
+        })
+    }
+
+    pub fn width(&self) -> u32 {
+        self.config.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.config.height
+    }
+
+    pub fn fps(&self) -> f64 {
+        self.config.fps
+    }
+
+    /// Frames checked out so far (the eventual frame count, minus any frames
+    /// abandoned at teardown).
+    pub fn frames_acquired(&self) -> u64 {
+        self.next_index
+    }
+
+    /// Handle for reporting GPU completion; clone one per frame into the
+    /// completion callback.
+    pub fn completer(&self) -> AvfCompleter {
+        AvfCompleter {
+            tx: self.tx.as_ref().expect("recorder already finished").clone(),
+        }
+    }
+
+    /// Check out the next frame's pixel buffer. Blocks while `MAX_IN_FLIGHT`
+    /// frames are still working their way through the GPU and encoder — this
+    /// is what paces the render loop, exactly like the readback ring did,
+    /// except the bound is now encode throughput rather than copy throughput.
+    ///
+    /// `pump` is called between waits and must make GPU completion callbacks
+    /// deliverable (a non-blocking wgpu device poll): the completions this
+    /// wait depends on only fire while the device is being pumped, and the
+    /// caller is the thread that normally pumps it by rendering.
+    pub fn acquire_frame(&mut self, pump: &mut dyn FnMut()) -> Result<AvfFrame> {
+        if self.died.load(Ordering::Acquire) {
+            return Err(self.take_error());
+        }
+        let died = {
+            let (count, cv) = &*self.in_flight;
+            let deadline = Instant::now() + STALL_TIMEOUT;
+            let mut count = count.lock().unwrap();
+            loop {
+                if self.died.load(Ordering::Acquire) {
+                    break true;
+                }
+                if *count < MAX_IN_FLIGHT {
+                    *count += 1;
+                    break false;
+                }
+                if Instant::now() >= deadline {
+                    return Err(err("encoder stalled: no frame completed in 10s"));
+                }
+                drop(count);
+                pump();
+                let (guard, _) = {
+                    let (m, _) = &*self.in_flight;
+                    let guard = m.lock().unwrap();
+                    cv.wait_timeout(guard, Duration::from_millis(1)).unwrap()
+                };
+                count = guard;
+            }
+        };
+        if died {
+            return Err(self.take_error());
+        }
+        let permit = InFlightPermit(Arc::clone(&self.in_flight));
+
+        let mut raw: *mut CVPixelBuffer = std::ptr::null_mut();
+        let ret = unsafe {
+            CVPixelBufferPool::create_pixel_buffer(
+                None,
+                &self.pool.0,
+                NonNull::new_unchecked(&mut raw),
+            )
+        };
+        if ret != kCVReturnSuccess || raw.is_null() {
+            return Err(err(format!("CVPixelBufferPoolCreatePixelBuffer: {ret}")));
+        }
+        // Create rule: the pool hands back +1.
+        let buffer = unsafe { CFRetained::from_raw(NonNull::new_unchecked(raw)) };
+
+        for (key, value) in [
+            (unsafe { kCVImageBufferColorPrimariesKey }, unsafe {
+                kCVImageBufferColorPrimaries_ITU_R_709_2
+            }),
+            (unsafe { kCVImageBufferTransferFunctionKey }, unsafe {
+                kCVImageBufferTransferFunction_ITU_R_709_2
+            }),
+            (unsafe { kCVImageBufferYCbCrMatrixKey }, unsafe {
+                kCVImageBufferYCbCrMatrix_ITU_R_709_2
+            }),
+        ] {
+            unsafe {
+                buffer.set_attachment(key, value, CVAttachmentMode::ShouldPropagate);
+            }
+        }
+
+        let surface = CVPixelBufferGetIOSurface(Some(&buffer))
+            .ok_or_else(|| err("pool pixel buffer has no IOSurface backing"))?;
+
+        let index = self.next_index;
+        self.next_index += 1;
+        Ok(AvfFrame {
+            buffer: SendCf(buffer),
+            surface: SendCf(surface),
+            index,
+            _permit: permit,
+        })
+    }
+
+    fn take_error(&mut self) -> AvfRecordError {
+        self.tx.take();
+        match self.handle.take().map(|h| h.join()) {
+            Some(Ok(Err(e))) => e,
+            Some(Err(_)) => err("writer thread panicked"),
+            _ => err("writer thread terminated unexpectedly"),
+        }
+    }
+
+    /// Wait for in-flight frames, finalize the file, and return the number of
+    /// frames written. `pump` as in [`Self::acquire_frame`].
+    pub fn finish(mut self, pump: &mut dyn FnMut()) -> Result<u64> {
+        // Wait for the GPU completions of everything checked out; permits are
+        // released even for frames whose callbacks are dropped at teardown.
+        {
+            let (count, cv) = &*self.in_flight;
+            let deadline = Instant::now() + STALL_TIMEOUT;
+            loop {
+                {
+                    let guard = count.lock().unwrap();
+                    if *guard == 0 {
+                        break;
+                    }
+                    if Instant::now() >= deadline {
+                        break; // proceed; the writer appends what it has
+                    }
+                    let _ = cv.wait_timeout(guard, Duration::from_millis(1)).unwrap();
+                }
+                pump();
+            }
+        }
+        drop(self.tx.take());
+        match self.handle.take() {
+            Some(handle) => handle.join().map_err(|_| err("writer thread panicked"))?,
+            None => Err(err("writer thread terminated unexpectedly")),
+        }
+    }
+}
+
+impl Drop for AvfRecorder {
+    fn drop(&mut self) {
+        // Abnormal teardown (an error aborted the recording): close our end
+        // and DETACH. Joining here can deadlock — completion closures still
+        // hold channel senders, and they only resolve while the dropping
+        // thread pumps the device. The writer thread finalizes a playable
+        // partial file on its own once the last sender goes away.
+        drop(self.tx.take());
+        drop(self.handle.take());
+    }
+}
+
+fn append(objects: &WriterObjects, frame: AvfFrame, ts: i32) -> Result<()> {
+    // Offline pacing: wait for the input to drain rather than dropping.
+    let deadline = Instant::now() + STALL_TIMEOUT;
+    while !unsafe { objects.input.isReadyForMoreMediaData() } {
+        if unsafe { objects.writer.status() } == AVAssetWriterStatus::Failed {
+            return Err(writer_error(&objects.writer, "append"));
+        }
+        if Instant::now() >= deadline {
+            return Err(err("AVAssetWriterInput never became ready"));
+        }
+        thread::sleep(Duration::from_micros(500));
+    }
+    let ok = unsafe {
+        objects
+            .adaptor
+            .appendPixelBuffer_withPresentationTime(&frame.buffer.0, pts(frame.index, ts))
+    };
+    if !ok {
+        return Err(writer_error(&objects.writer, "appendPixelBuffer failed"));
+    }
+    Ok(())
+}
+
+fn writer_main(objects: WriterObjects, rx: Receiver<AvfFrame>, ts: i32) -> Result<u64> {
+    let mut written: u64 = 0;
+    // GPU completion callbacks arrive in submission order in practice, but
+    // wgpu doesn't promise it; reorder by frame index to be sure.
+    let mut queue: BTreeMap<u64, AvfFrame> = BTreeMap::new();
+    let mut next: u64 = 0;
+
+    while let Ok(frame) = rx.recv() {
+        queue.insert(frame.index, frame);
+        while let Some(frame) = queue.remove(&next) {
+            append(&objects, frame, ts)?;
+            next += 1;
+            written += 1;
+        }
+    }
+    // Channel closed: everything still queued is appendable, in order. Gaps
+    // are frames abandoned at teardown; their pts slots simply go unused.
+    for (_, frame) in queue {
+        append(&objects, frame, ts)?;
+        written += 1;
+    }
+
+    unsafe { objects.input.markAsFinished() };
+    if written == 0 {
+        // Nothing was appended; cancel instead of finalizing an empty file.
+        unsafe { objects.writer.cancelWriting() };
+        return Ok(0);
+    }
+    let (done_tx, done_rx) = channel::<()>();
+    let block = block2::RcBlock::new(move || {
+        let _ = done_tx.send(());
+    });
+    unsafe { objects.writer.finishWritingWithCompletionHandler(&block) };
+    done_rx
+        .recv_timeout(Duration::from_secs(60))
+        .map_err(|_| err("finishWriting did not complete"))?;
+    if unsafe { objects.writer.status() } != AVAssetWriterStatus::Completed {
+        return Err(writer_error(&objects.writer, "finishWriting"));
+    }
+    Ok(written)
+}
diff --git a/crates/processing_video/src/record.rs b/crates/processing_video/src/record.rs
index bb18924c..79453bcc 100644
--- a/crates/processing_video/src/record.rs
+++ b/crates/processing_video/src/record.rs
@@ -123,6 +123,16 @@ pub struct VideoRecorderConfig {
     /// Target bitrate in bits per second. VideoToolbox only; `None` picks
     /// ~0.1 bits/pixel/frame from the resolution and fps.
     pub bitrate: Option<u64>,
+    /// Maximum consecutive B frames. `None` leaves the encoder default (3 for
+    /// x264).
+    ///
+    /// B frames are cheap to encode and can come out several times smaller
+    /// than the P frames around them. On content the codec predicts badly --
+    /// dense instanced geometry tumbling, say -- that size gap becomes a
+    /// visible periodic pulse in quality, at the period of the GOP pattern.
+    /// `Some(0)` turns them off, which removes the pulse without the bitrate
+    /// increase that raising quality would cost.
+    pub bframes: Option<u32>,
 }
 
 impl VideoRecorderConfig {
@@ -138,6 +148,7 @@ impl VideoRecorderConfig {
             crf: None,
             preset: None,
             bitrate: None,
+            bframes: None,
         }
     }
 
@@ -176,6 +187,11 @@ impl VideoRecorderConfig {
         self
     }
 
+    pub fn with_bframes(mut self, bframes: u32) -> Self {
+        self.bframes = Some(bframes);
+        self
+    }
+
     /// Default VideoToolbox bitrate: ~0.1 bits per pixel per frame, clamped
     /// to a sane range. 3840×4320@60 ≈ 100 Mbps, 7680×4320@60 ≈ 200 Mbps.
     fn auto_bitrate(&self) -> u64 {
@@ -202,7 +218,12 @@ pub enum VideoRecordError {
     Encode { frame: u64, source: ffmpeg::Error },
     #[error("failed to finalize video: {0}")]
     Finish(ffmpeg::Error),
-    #[error("frame has {got} bytes but {expected} were expected ({width}x{height} {format:?})")]
+    #[error(
+        "frame has {got} bytes but {expected} were expected ({width}x{height} {format:?}) — \
+         the recorder is sized to the frame it first captured, so this usually means a \
+         DIFFERENT canvas (an offscreen/state buffer) was captured into the same recording; \
+         record the primary canvas only"
+    )]
     FrameSize {
         expected: usize,
         got: usize,
@@ -295,6 +316,11 @@ impl FrameEncoder {
         if let Some(interval) = config.keyframe_interval {
             video.set_gop(interval as u32);
         }
+        // Set on the codec context rather than as an x264 private option, so
+        // it reaches the VideoToolbox encoders too.
+        if let Some(bframes) = config.bframes {
+            video.set_max_b_frames(bframes as usize);
+        }
 
         let mut options = HashMap::new();
         if config.codec.is_videotoolbox() {
diff --git a/src/lib.rs b/src/lib.rs
index 9e1cbd36..22946c71 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -71,6 +71,9 @@ fn create_app(config: Config) -> App {
     #[cfg(feature = "video")]
     app.add_plugins(processing_video::NannouVideoPlugin);
 
+    #[cfg(feature = "physics")]
+    app.add_plugins(processing_physics::ProcessingPhysicsPlugin);
+
     #[cfg(feature = "webcam")]
     app.add_plugins(processing_webcam::WebcamPlugin);