diff --git a/examples/perf_spike.rs b/examples/perf_spike.rs
new file mode 100644
index 0000000..755058c
--- /dev/null
+++ b/examples/perf_spike.rs
@@ -0,0 +1,490 @@
+//! Throwaway performance spike for InfiniTower.
+//!
+//! Answers one question only: how many enemies and projectiles does Bevy 0.19 carry
+//! in 2D before the frame budget of 16.6 ms (60 fps) is gone?
+//!
+//! Deliberately minimal: no gameplay, no UI, no assets. Enemies walk radially towards
+//! the centre, a single tower fires at the nearest one, projectiles fly straight, a hit
+//! removes enemy and projectile. The enemy population is held constant so the load
+//! does not drift during a run.
+//!
+//! Run (release profile, otherwise the numbers are meaningless):
+//!   cargo run --release --example perf_spike -- 2000
+//!   PERF_N=2000 cargo run --release --example perf_spike
+//!
+//! Knobs (env vars, CLI arg 1 overrides PERF_N):
+//!   PERF_N           enemy population held constant            (default 1000)
+//!   PERF_FIRE_RATE   tower shots per second                    (default 20)
+//!   PERF_RENDER      1 = window + sprites, 0 = headless logic   (default 1)
+//!   PERF_COLLIDE     1 = run naive O(n*m) collision            (default 1)
+//!   PERF_MOVE        1 = run enemy movement                    (default 1)
+//!   PERF_SECONDS     length of the measurement window          (default 12)
+//!   PERF_WARMUP      seconds discarded before measuring        (default 4)
+//!
+//! Every run prints a `=== PERF SPIKE RESULT ===` block with medians (not first-frame
+//! values) and then exits on its own.
+
+use std::time::Instant;
+
+use bevy::{
+    diagnostic::{
+        Diagnostic, DiagnosticPath, Diagnostics, DiagnosticsPlugin, DiagnosticsStore,
+        FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin, RegisterDiagnostic,
+    },
+    platform::collections::HashSet,
+    prelude::*,
+};
+use core::{f32::consts::TAU, time::Duration};
+
+/// Radius of the ring the enemies spawn on. Chosen so the whole arena fits into a
+/// 1920x1080 window: nothing is frustum-culled, so the render cost is honest.
+const ARENA_RADIUS: f32 = 500.0;
+const ENEMY_SPEED: f32 = 50.0;
+const ENEMY_SIZE: f32 = 8.0;
+const PROJECTILE_SPEED: f32 = 700.0;
+const PROJECTILE_SIZE: f32 = 4.0;
+/// A projectile within this distance of an enemy counts as a hit.
+const HIT_RADIUS: f32 = 10.0;
+/// An enemy this close to the centre has "arrived" and is recycled to the rim.
+const CENTER_RADIUS: f32 = 24.0;
+/// Enough history to hold every frame of a long run at high fps.
+const HISTORY: usize = 120_000;
+
+const D_MAINTAIN: DiagnosticPath = DiagnosticPath::const_new("spike/maintain_us");
+const D_MOVE_ENEMIES: DiagnosticPath = DiagnosticPath::const_new("spike/move_enemies_us");
+const D_FIRE: DiagnosticPath = DiagnosticPath::const_new("spike/tower_fire_us");
+const D_MOVE_PROJ: DiagnosticPath = DiagnosticPath::const_new("spike/move_projectiles_us");
+const D_COLLIDE: DiagnosticPath = DiagnosticPath::const_new("spike/collide_us");
+const D_ENEMIES: DiagnosticPath = DiagnosticPath::const_new("spike/enemies");
+const D_PROJECTILES: DiagnosticPath = DiagnosticPath::const_new("spike/projectiles");
+const D_CHECKS: DiagnosticPath = DiagnosticPath::const_new("spike/pair_checks");
+
+#[derive(Resource, Clone, Copy)]
+struct SpikeConfig {
+    enemy_count: usize,
+    fire_rate: f32,
+    render: bool,
+    collide: bool,
+    move_enemies: bool,
+    warmup_secs: f64,
+    measure_secs: f64,
+}
+
+impl SpikeConfig {
+    fn from_env() -> Self {
+        let cli_n = std::env::args().nth(1).and_then(|a| a.parse::<usize>().ok());
+        Self {
+            enemy_count: cli_n.unwrap_or_else(|| env_num("PERF_N", 1000.0) as usize),
+            fire_rate: env_num("PERF_FIRE_RATE", 20.0) as f32,
+            render: env_flag("PERF_RENDER", true),
+            collide: env_flag("PERF_COLLIDE", true),
+            move_enemies: env_flag("PERF_MOVE", true),
+            warmup_secs: env_num("PERF_WARMUP", 4.0),
+            measure_secs: env_num("PERF_SECONDS", 12.0),
+        }
+    }
+}
+
+fn env_num(key: &str, default: f64) -> f64 {
+    std::env::var(key)
+        .ok()
+        .and_then(|v| v.parse::<f64>().ok())
+        .unwrap_or(default)
+}
+
+fn env_flag(key: &str, default: bool) -> bool {
+    std::env::var(key)
+        .ok()
+        .map(|v| !matches!(v.as_str(), "0" | "false" | "off"))
+        .unwrap_or(default)
+}
+
+#[derive(Component)]
+struct Enemy;
+
+#[derive(Component)]
+struct Projectile {
+    velocity: Vec2,
+}
+
+#[derive(Resource)]
+struct TowerGun {
+    timer: Timer,
+}
+
+/// Monotonic counter, used as the seed for respawn angles so runs are deterministic.
+#[derive(Resource, Default)]
+struct SpawnSeed(u32);
+
+#[derive(Resource)]
+struct Harness {
+    elapsed: f64,
+    measuring: bool,
+    done: bool,
+}
+
+fn main() {
+    let cfg = SpikeConfig::from_env();
+
+    let mut app = App::new();
+
+    if cfg.render {
+        app.add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "InfiniTower perf spike".into(),
+                // Uncapped: with vsync the frame time would just be the monitor's.
+                present_mode: bevy::window::PresentMode::AutoNoVsync,
+                resolution: bevy::window::WindowResolution::new(1920, 1080)
+                    .with_scale_factor_override(1.0),
+                ..default()
+            }),
+            ..default()
+        }))
+        .insert_resource(bevy::winit::WinitSettings::continuous());
+    } else {
+        // Headless: same simulation, no renderer at all. The delta against the
+        // rendered run is the render cost.
+        app.add_plugins((MinimalPlugins, bevy::log::LogPlugin::default(), DiagnosticsPlugin));
+    }
+
+    app.add_plugins((
+        FrameTimeDiagnosticsPlugin::new(HISTORY),
+        LogDiagnosticsPlugin {
+            wait_duration: Duration::from_secs(2),
+            ..default()
+        },
+    ))
+    .insert_resource(cfg)
+    .init_resource::<SpawnSeed>()
+    .insert_resource(TowerGun {
+        timer: Timer::from_seconds(1.0 / cfg.fire_rate.max(0.01), TimerMode::Repeating),
+    })
+    .insert_resource(Harness {
+        elapsed: 0.0,
+        measuring: false,
+        done: false,
+    });
+
+    for path in [
+        &D_MAINTAIN,
+        &D_MOVE_ENEMIES,
+        &D_FIRE,
+        &D_MOVE_PROJ,
+        &D_COLLIDE,
+        &D_ENEMIES,
+        &D_PROJECTILES,
+        &D_CHECKS,
+    ] {
+        app.register_diagnostic(Diagnostic::new(path.clone()).with_max_history_length(HISTORY));
+    }
+
+    app.add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                maintain_population,
+                move_enemies.run_if(|c: Res<SpikeConfig>| c.move_enemies),
+                tower_fire,
+                move_projectiles,
+                collide.run_if(|c: Res<SpikeConfig>| c.collide),
+            )
+                .chain(),
+        )
+        .add_systems(Last, harness)
+        .run();
+}
+
+fn setup(mut commands: Commands, cfg: Res<SpikeConfig>) {
+    if cfg.render {
+        commands.spawn(Camera2d);
+        // The tower itself. Purely cosmetic, the firing logic lives in a resource.
+        commands.spawn((
+            Sprite::from_color(Color::srgb(0.9, 0.9, 0.2), Vec2::splat(24.0)),
+            Transform::default(),
+        ));
+    }
+
+    // Initial population: angles evenly spread over the circle, radii staggered.
+    // Without the stagger every enemy would reach the centre in the same frame and
+    // the frame time would oscillate instead of settling.
+    let n = cfg.enemy_count.max(1);
+    for i in 0..cfg.enemy_count {
+        let angle = (i as f32 / n as f32) * TAU;
+        let radius = ARENA_RADIUS * (0.2 + 0.8 * hash01(i as u32));
+        spawn_enemy(&mut commands, angle, radius, cfg.render);
+    }
+}
+
+/// Keeps the enemy population at exactly `PERF_N`, so the load stays constant while
+/// hits and centre-arrivals despawn entities. Also the place where spawn cost shows up.
+fn maintain_population(
+    mut commands: Commands,
+    cfg: Res<SpikeConfig>,
+    enemies: Query<(), With<Enemy>>,
+    mut seed: ResMut<SpawnSeed>,
+    mut diagnostics: Diagnostics,
+) {
+    let t0 = Instant::now();
+    let alive = enemies.iter().len();
+    for _ in alive..cfg.enemy_count {
+        seed.0 = seed.0.wrapping_add(1);
+        spawn_enemy(&mut commands, hash01(seed.0) * TAU, ARENA_RADIUS, cfg.render);
+    }
+    let us = t0.elapsed().as_secs_f64() * 1e6;
+    diagnostics.add_measurement(&D_MAINTAIN, || us);
+    diagnostics.add_measurement(&D_ENEMIES, || alive as f64);
+}
+
+fn move_enemies(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut enemies: Query<(Entity, &mut Transform), With<Enemy>>,
+    mut diagnostics: Diagnostics,
+) {
+    let t0 = Instant::now();
+    let dt = time.delta_secs();
+    for (entity, mut transform) in &mut enemies {
+        let pos = transform.translation.truncate();
+        let dist = pos.length();
+        if dist <= CENTER_RADIUS {
+            // Reached the tower: despawn, `maintain_population` puts it back on the rim.
+            commands.entity(entity).despawn();
+            continue;
+        }
+        let step = pos / dist * (-ENEMY_SPEED * dt);
+        transform.translation.x += step.x;
+        transform.translation.y += step.y;
+    }
+    let us = t0.elapsed().as_secs_f64() * 1e6;
+    diagnostics.add_measurement(&D_MOVE_ENEMIES, || us);
+}
+
+/// Single tower, fixed rate, nearest target. The target scan is a full O(n) sweep
+/// and only runs on frames where the timer actually fires.
+fn tower_fire(
+    mut commands: Commands,
+    time: Res<Time>,
+    cfg: Res<SpikeConfig>,
+    mut gun: ResMut<TowerGun>,
+    enemies: Query<&Transform, With<Enemy>>,
+    mut diagnostics: Diagnostics,
+) {
+    let t0 = Instant::now();
+    gun.timer.tick(time.delta());
+    let shots = gun.timer.times_finished_this_tick();
+    if shots > 0 {
+        let mut best: Option<(f32, Vec2)> = None;
+        for transform in &enemies {
+            let pos = transform.translation.truncate();
+            let d2 = pos.length_squared();
+            if best.is_none_or(|(best_d2, _)| d2 < best_d2) {
+                best = Some((d2, pos));
+            }
+        }
+        if let Some((_, target)) = best {
+            let dir = target.normalize_or_zero();
+            for i in 0..shots {
+                // Fan a multi-shot tick out slightly so the projectiles do not overlap.
+                let offset = (i as f32 - (shots as f32 - 1.0) * 0.5) * 0.04;
+                let velocity = Vec2::from_angle(offset).rotate(dir) * PROJECTILE_SPEED;
+                spawn_projectile(&mut commands, velocity, cfg.render);
+            }
+        }
+    }
+    let us = t0.elapsed().as_secs_f64() * 1e6;
+    diagnostics.add_measurement(&D_FIRE, || us);
+}
+
+fn move_projectiles(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut projectiles: Query<(Entity, &mut Transform, &Projectile)>,
+    mut diagnostics: Diagnostics,
+) {
+    let t0 = Instant::now();
+    let dt = time.delta_secs();
+    let mut alive = 0usize;
+    for (entity, mut transform, projectile) in &mut projectiles {
+        transform.translation.x += projectile.velocity.x * dt;
+        transform.translation.y += projectile.velocity.y * dt;
+        if transform.translation.truncate().length() > ARENA_RADIUS * 1.2 {
+            commands.entity(entity).despawn();
+        } else {
+            alive += 1;
+        }
+    }
+    let us = t0.elapsed().as_secs_f64() * 1e6;
+    diagnostics.add_measurement(&D_MOVE_PROJ, || us);
+    diagnostics.add_measurement(&D_PROJECTILES, || alive as f64);
+}
+
+/// Deliberately naive O(n*m) broad phase: every projectile against every enemy.
+/// The whole point of the spike is to find out where this stops being good enough.
+fn collide(
+    mut commands: Commands,
+    projectiles: Query<(Entity, &Transform), With<Projectile>>,
+    enemies: Query<(Entity, &Transform), With<Enemy>>,
+    mut diagnostics: Diagnostics,
+) {
+    let t0 = Instant::now();
+    let hit_radius_sq = HIT_RADIUS * HIT_RADIUS;
+    let mut killed: HashSet<Entity> = HashSet::default();
+    let mut checks = 0u64;
+
+    for (projectile, projectile_tf) in &projectiles {
+        let p = projectile_tf.translation.truncate();
+        for (enemy, enemy_tf) in &enemies {
+            checks += 1;
+            if killed.contains(&enemy) {
+                continue;
+            }
+            if p.distance_squared(enemy_tf.translation.truncate()) < hit_radius_sq {
+                killed.insert(enemy);
+                commands.entity(enemy).despawn();
+                commands.entity(projectile).despawn();
+                break;
+            }
+        }
+    }
+
+    let us = t0.elapsed().as_secs_f64() * 1e6;
+    diagnostics.add_measurement(&D_COLLIDE, || us);
+    diagnostics.add_measurement(&D_CHECKS, || checks as f64);
+}
+
+fn spawn_enemy(commands: &mut Commands, angle: f32, radius: f32, render: bool) {
+    let pos = Vec2::from_angle(angle) * radius;
+    let transform = Transform::from_xyz(pos.x, pos.y, 0.0);
+    if render {
+        commands.spawn((
+            Enemy,
+            Sprite::from_color(Color::srgb(0.85, 0.25, 0.25), Vec2::splat(ENEMY_SIZE)),
+            transform,
+        ));
+    } else {
+        commands.spawn((Enemy, transform));
+    }
+}
+
+fn spawn_projectile(commands: &mut Commands, velocity: Vec2, render: bool) {
+    let transform = Transform::from_xyz(0.0, 0.0, 1.0);
+    if render {
+        commands.spawn((
+            Projectile { velocity },
+            Sprite::from_color(Color::srgb(0.3, 0.8, 1.0), Vec2::splat(PROJECTILE_SIZE)),
+            transform,
+        ));
+    } else {
+        commands.spawn((Projectile { velocity }, transform));
+    }
+}
+
+/// Cheap deterministic hash into [0, 1). Avoids pulling in `rand` for a throwaway example.
+fn hash01(n: u32) -> f32 {
+    let mut x = n.wrapping_mul(0x9E37_79B9).wrapping_add(0x1234_5678);
+    x ^= x >> 16;
+    x = x.wrapping_mul(0x85EB_CA6B);
+    x ^= x >> 13;
+    (x >> 8) as f32 / (1u32 << 24) as f32
+}
+
+/// Drives warmup -> measurement -> summary -> exit, so a run is scriptable and the
+/// reported numbers are medians of the settled phase, never the first frame.
+fn harness(
+    time: Res<Time<Real>>,
+    cfg: Res<SpikeConfig>,
+    mut state: ResMut<Harness>,
+    mut store: ResMut<DiagnosticsStore>,
+    mut exit: MessageWriter<AppExit>,
+) {
+    if state.done {
+        return;
+    }
+    state.elapsed += time.delta_secs_f64();
+
+    if !state.measuring {
+        if state.elapsed >= cfg.warmup_secs {
+            // Throw away everything from startup, shader compilation and the first
+            // population wave.
+            for diagnostic in store.iter_mut() {
+                diagnostic.clear_history();
+            }
+            state.measuring = true;
+            info!("warmup done, measuring for {} s", cfg.measure_secs);
+        }
+        return;
+    }
+
+    if state.elapsed < cfg.warmup_secs + cfg.measure_secs {
+        return;
+    }
+    state.done = true;
+
+    let frame_ms = sorted(&store, &FrameTimeDiagnosticsPlugin::FRAME_TIME);
+    let frames = frame_ms.len();
+    let median_ms = percentile(&frame_ms, 0.5);
+    let p95_ms = percentile(&frame_ms, 0.95);
+    let p99_ms = percentile(&frame_ms, 0.99);
+
+    let m = |path: &DiagnosticPath| percentile(&sorted(&store, path), 0.5);
+    let maintain = m(&D_MAINTAIN);
+    let move_enemies_us = m(&D_MOVE_ENEMIES);
+    let fire = m(&D_FIRE);
+    let move_proj = m(&D_MOVE_PROJ);
+    let collide_us = m(&D_COLLIDE);
+    let logic_us = maintain + move_enemies_us + fire + move_proj + collide_us;
+
+    println!("=== PERF SPIKE RESULT ===");
+    println!(
+        "mode            {}",
+        if cfg.render { "render" } else { "headless" }
+    );
+    println!("N (enemies)     {}", cfg.enemy_count);
+    println!("fire rate       {} shots/s", cfg.fire_rate);
+    println!(
+        "systems         move={} collide={}",
+        cfg.move_enemies, cfg.collide
+    );
+    println!("frames measured {frames}");
+    println!(
+        "frame time      median {median_ms:.3} ms | p95 {p95_ms:.3} ms | p99 {p99_ms:.3} ms"
+    );
+    println!(
+        "fps             median {:.1} | p95 {:.1}",
+        1000.0 / median_ms.max(f64::EPSILON),
+        1000.0 / p95_ms.max(f64::EPSILON)
+    );
+    println!("enemies alive   median {:.0}", m(&D_ENEMIES));
+    println!("projectiles     median {:.0}", m(&D_PROJECTILES));
+    println!("pair checks     median {:.0} /frame", m(&D_CHECKS));
+    println!(
+        "system medians  maintain {maintain:.1} us | move_enemies {move_enemies_us:.1} us | \
+         tower_fire {fire:.1} us | move_projectiles {move_proj:.1} us | collide {collide_us:.1} us"
+    );
+    println!(
+        "logic total     {:.3} ms ({:.1} % of the median frame)",
+        logic_us / 1000.0,
+        (logic_us / 1000.0) / median_ms.max(f64::EPSILON) * 100.0
+    );
+    println!("=========================");
+
+    exit.write(AppExit::Success);
+}
+
+fn sorted(store: &DiagnosticsStore, path: &DiagnosticPath) -> Vec<f64> {
+    let mut values: Vec<f64> = store
+        .get(path)
+        .map(|d| d.values().copied().collect())
+        .unwrap_or_default();
+    values.sort_by(|a, b| a.total_cmp(b));
+    values
+}
+
+/// Returns 0.0 for an empty history, which is what a disabled system should report.
+fn percentile(sorted_values: &[f64], q: f64) -> f64 {
+    if sorted_values.is_empty() {
+        return 0.0;
+    }
+    let idx = ((sorted_values.len() - 1) as f64 * q).round() as usize;
+    sorted_values[idx]
+}