diff --git a/README.md b/README.md
index 6755d086..f3a90a6e 100644
--- a/README.md
+++ b/README.md
@@ -392,6 +392,21 @@ keyboard as a sheet — with a legend of what the ten annunciators mean — and
 diagnostics: frame time and entity count, terrain, air detail, axles, temperatures, signals
 and the network, which is where everything a driver has no use for lives.
 
+**Finding what costs frame budget.** The top of the `F6` block is a frame profiler:
+average, p95 and maximum frame time over the last 300 frames with a hitch count, a
+per-system CPU breakdown (`sim`, `ai`, `stream`, `hud`, `audio`, … plus how many fixed
+sim steps the last frame ran), an ASCII history graph and the worst spikes with what they
+were made of. Whatever the named spans leave over shows as `rest` — render, present and
+vsync — so a high `rest` next to high triangle/entity counts points at the GPU and a high
+named span at the CPU side. The `F8` console's `prof` prints the same table, `prof reset`
+clears it, `prof pause`/`resume` freezes it, and `prof csv <file>` writes the history for
+analysis outside the simulator. Leaving a run for the menu or quitting to the desktop logs
+the same summary automatically, so every run ends up measurable in the log without
+photographing the overlay. A `--frames N` run logs the summary and the worst spikes
+on exit, which is the scriptable form of the overlay. For deeper dives (per render pass,
+GPU timings) run with Bevy's Tracy feature and connect the Tracy viewer — the in-game
+profiler stays for the quick question of *which* system lags.
+
 **`F7` walks three steps** — full, reduced, off — and rounds back. The reduced step keeps
 what the train is *driven* by (the desk and the protection lamps) and everything that
 interrupts (the banner, scenario messages), and drops what it is *planned* by: the run, the
@@ -461,7 +476,7 @@ The table below is what everything ships with.
 | `F1`–`F4` | Camera: driver's seat / external / lineside / first person |
 | `F5` / `F6` | Keyboard sheet / diagnostics overlay |
 | `F7` | Display: full → reduced → off, and round again |
-| `F8` | Console: `weather` and `time` move the world (`Tab` completes, `↑`/`↓` history, `Enter` runs, `Esc` closes). Against a server the weather is asked of it, the clock stays single player |
+| `F8` | Console: `weather` and `time` move the world, `prof` profiles the frames (`Tab` completes, `↑`/`↓` history, `Enter` runs, `Esc` closes). Against a server the weather is asked of it, the clock stays single player |
 | `F9` | Mod manager (↑/↓ select, `Enter` toggles; in-game it applies on the next restart, on the main menu it applies on start, rows are clickable) |
 | Arrow keys | View direction, `Numpad +/-` camera distance |
 | `WASD` / `Shift` | First person (`F4`): walk (1.5 m/s) and run (5 m/s) through the train and over the ground. The walker falls where the ground drops away, climbs what is no higher than a step, is stopped by what stands at chest height and walks on through the train from vehicle to vehicle. The mouse looks around on its own, the cursor is caught on the crosshair and the driving keys rest until `F1` puts the driver back on the seat |
diff --git a/crates/app/src/audio.rs b/crates/app/src/audio.rs
index 06ab1d36..68980a52 100644
--- a/crates/app/src/audio.rs
+++ b/crates/app/src/audio.rs
@@ -46,7 +46,7 @@
 //!   volumes have no shared head-room otherwise.
 
 use crate::render::VehicleView;
-use crate::{PlayerTrain, SimResource, settings, ui};
+use crate::{PlayerTrain, SimResource, profiler, settings, ui};
 use bevy::prelude::*;
 use kira::effect::compressor::CompressorBuilder;
 use kira::effect::filter::{FilterBuilder, FilterHandle};
@@ -421,7 +421,9 @@ pub fn update_audio(
     walker: Res<crate::walk::Walker>,
     camera: Query<&GlobalTransform, With<ui::CabCamera>>,
     views: Query<(&VehicleView, &GlobalTransform)>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("audio");
     let Some(mut audio) = audio else {
         return;
     };
diff --git a/crates/app/src/console.rs b/crates/app/src/console.rs
index f80fdf58..f981a492 100644
--- a/crates/app/src/console.rs
+++ b/crates/app/src/console.rs
@@ -19,6 +19,7 @@
 //! it needs no wire at all.
 
 use crate::bindings;
+use crate::profiler::Profiler;
 use crate::theme::{Face, Fonts, TEXT_BRIGHT, TEXT_FAINT, TEXT_MID, text};
 use crate::ui::{CameraMode, CameraState};
 use crate::{GameState, SimResource, net};
@@ -245,13 +246,16 @@ pub fn console(
             Without<SuggestMarker>,
         ),
     >,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let prof_start = std::time::Instant::now();
     if input.just_pressed(bindings::Action::Console) {
         state.open = !state.open;
         state.completing = None;
         state.history_pos = None;
     }
     if !state.open {
+        profiler.record("console", prof_start.elapsed().as_secs_f64() * 1000.0);
         return;
     }
     // Characters with a modifier held are shortcuts, not text — except AltRight, which
@@ -273,6 +277,7 @@ pub fn console(
                     &mut state,
                     &mut sim.0,
                     &mut camera,
+                    &mut profiler,
                     is_client(role.as_deref()),
                 ) {
                     wishes.write(net::WeatherRequest(preset));
@@ -316,6 +321,7 @@ pub fn console(
         return;
     };
     **line = format!("> {}", state.input);
+    profiler.record("console", prof_start.elapsed().as_secs_f64() * 1000.0);
 }
 
 fn is_client(role: Option<&net::Role>) -> bool {
@@ -443,6 +449,9 @@ struct Ctx<'a> {
     console: &'a mut Console,
     /// The view state, which `fly` flips — the camera is nothing the simulation holds.
     camera: &'a mut CameraState,
+    /// The frame profiler, which `prof` reads and controls — local measurement,
+    /// never replicated.
+    profiler: &'a mut Profiler,
     /// True on a multiplayer client — the world is the server's, so commands wish.
     client: bool,
     /// The weather a client's `weather` command asked the server for.
@@ -460,7 +469,7 @@ struct Command {
     run: fn(&mut Ctx, &[&str]),
 }
 
-const COMMANDS: [Command; 5] = [
+const COMMANDS: [Command; 6] = [
     Command {
         name: "weather",
         usage: "console-usage-weather",
@@ -496,6 +505,13 @@ const COMMANDS: [Command; 5] = [
         args: no_args,
         run: cmd_clear,
     },
+    Command {
+        name: "prof",
+        usage: "console-usage-prof",
+        help: "console-help-prof",
+        args: prof_args,
+        run: cmd_prof,
+    },
 ];
 
 fn no_args(_: usize) -> Vec<String> {
@@ -518,6 +534,18 @@ fn weather_args(word: usize) -> Vec<String> {
     }
 }
 
+/// The subcommands `prof` takes on its first argument.
+fn prof_args(word: usize) -> Vec<String> {
+    if word == 0 {
+        ["reset", "pause", "resume", "csv"]
+            .into_iter()
+            .map(Into::into)
+            .collect()
+    } else {
+        Vec::new()
+    }
+}
+
 /// The name a preset is typed and printed under — its own English name, in whatever
 /// case the code spells it, lower. Commands and arguments do not follow the interface
 /// language; the sentences around them do.
@@ -637,6 +665,91 @@ fn cmd_clear(ctx: &mut Ctx, _: &[&str]) {
     ctx.console.log.clear();
 }
 
+/// The frame profiler (`crate::profiler`): prints what the last frames cost,
+/// freezes or clears the history, or writes it to a CSV file for analysis
+/// outside the simulator. Local measurement only — nothing here travels.
+fn cmd_prof(ctx: &mut Ctx, args: &[&str]) {
+    let profiler = &mut *ctx.profiler;
+    match args.first().map(|word| word.to_ascii_lowercase()) {
+        None => {
+            let stats = profiler.frame_stats();
+            if stats.count == 0 {
+                ctx.console.print(t!("console-prof-empty"));
+                return;
+            }
+            ctx.console.print(t!(
+                "console-prof-summary",
+                frames = stats.count,
+                avg = i18n::decimal(stats.avg, 1),
+                p95 = i18n::decimal(stats.p95, 1),
+                max = i18n::decimal(stats.max, 1),
+                hitches = stats.hitches,
+            ));
+            for span in profiler.span_stats().iter().take(12) {
+                ctx.console.print(t!(
+                    "console-prof-span",
+                    name = span.name,
+                    avg = i18n::decimal(span.avg, 2),
+                    max = i18n::decimal(span.max, 1),
+                    share = i18n::decimal(100.0 * span.avg / stats.avg.max(1e-9), 0),
+                ));
+            }
+            ctx.console.print(t!(
+                "console-prof-rest",
+                rest = i18n::decimal(profiler.rest_ms(), 1),
+            ));
+            for spike in profiler.spikes().iter().take(3) {
+                let breakdown = spike
+                    .spans
+                    .iter()
+                    .take(3)
+                    .map(|(name, ms)| format!("{name} {ms:.1}"))
+                    .collect::<Vec<_>>()
+                    .join(" ");
+                ctx.console.print(t!(
+                    "console-prof-spike",
+                    frame = spike.frame,
+                    total = i18n::decimal(spike.total_ms, 1),
+                    breakdown = breakdown,
+                ));
+            }
+        }
+        Some(action) if action == "reset" => {
+            profiler.reset();
+            ctx.console.print(t!("console-prof-reset"));
+        }
+        Some(action) if action == "pause" => {
+            profiler.set_paused(true);
+            ctx.console.print(t!("console-prof-paused"));
+        }
+        Some(action) if action == "resume" => {
+            profiler.set_paused(false);
+            ctx.console.print(t!("console-prof-resumed"));
+        }
+        Some(action) if action == "csv" => {
+            let Some(path) = args.get(1) else {
+                ctx.console.print(t!("console-usage-prof"));
+                return;
+            };
+            match std::fs::write(path, profiler.csv()) {
+                Ok(()) => ctx.console.print(t!(
+                    "console-prof-saved",
+                    rows = profiler.frames().len(),
+                    path = *path,
+                )),
+                Err(error) => ctx.console.print(t!(
+                    "console-prof-failed",
+                    path = *path,
+                    error = error.to_string(),
+                )),
+            }
+        }
+        Some(other) => {
+            ctx.console.print(t!("console-unknown", name = other));
+        }
+    }
+}
+
 /// The wall clock of the run as `HH:MM:SS`.
 fn clock_text(clock: f64) -> String {
     let seconds = clock.rem_euclid(DAY).floor() as u64;
@@ -668,6 +781,7 @@ fn run_line(
     state: &mut Console,
     sim: &mut Sim,
     camera: &mut CameraState,
+    profiler: &mut Profiler,
     client: bool,
 ) -> Option<Preset> {
     let line = state.input.trim().to_string();
@@ -694,6 +808,7 @@ fn run_line(
         sim,
         console: state,
         camera,
+        profiler,
         client,
         wish: None,
     };
@@ -755,10 +870,12 @@ mod tests {
         sim.start.minute = 0;
         sim.time = 20.0 * 3_600.0;
         let mut camera = CameraState::default();
+        let mut profiler = Profiler::default();
         let mut ctx = Ctx {
             sim: &mut sim,
             console: &mut console,
             camera: &mut camera,
+            profiler: &mut profiler,
             client: false,
             wish: None,
         };
@@ -811,8 +928,12 @@ mod tests {
         let mut console = Console::default();
         let mut sim = sim();
         let mut camera = CameraState::default();
+        let mut profiler = Profiler::default();
         console.input = "frobnicate now".into();
-        assert_eq!(run_line(&mut console, &mut sim, &mut camera, false), None);
+        assert_eq!(
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, false),
+            None
+        );
         assert!(
             console.log.iter().any(|l| l.contains("> frobnicate now")),
             "the line is echoed before it is answered"
@@ -825,7 +946,10 @@ mod tests {
         );
         // A known command runs, and a client's weather becomes a wish for the server.
         console.input = "weather rain".into();
-        assert_eq!(run_line(&mut console, &mut sim, &mut camera, false), None);
+        assert_eq!(
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, false),
+            None
+        );
         assert_eq!(
             sim.weather.now.precip,
             Precip::None,
@@ -833,7 +957,7 @@ mod tests {
         );
         console.input = "weather snow".into();
         assert_eq!(
-            run_line(&mut console, &mut sim, &mut camera, true),
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, true),
             Some(Preset::Snow)
         );
         assert_eq!(
@@ -855,11 +979,18 @@ mod tests {
         let mut console = Console::default();
         let mut sim = sim();
         let mut camera = CameraState::default();
+        let mut profiler = Profiler::default();
         console.input = "fly".into();
-        assert_eq!(run_line(&mut console, &mut sim, &mut camera, false), None);
+        assert_eq!(
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, false),
+            None
+        );
         assert_eq!(camera.mode, CameraMode::Fly);
         console.input = "/fly".into();
-        assert_eq!(run_line(&mut console, &mut sim, &mut camera, false), None);
+        assert_eq!(
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, false),
+            None
+        );
         assert_eq!(camera.mode, CameraMode::Cab);
         assert!(
             console.log.iter().any(|l| l.contains("> /fly")),
@@ -867,10 +998,61 @@ mod tests {
         );
         // A client flies its own camera: no wish for the server comes of it.
         console.input = "/fly".into();
-        assert_eq!(run_line(&mut console, &mut sim, &mut camera, true), None);
+        assert_eq!(
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, true),
+            None
+        );
         assert_eq!(camera.mode, CameraMode::Fly);
     }
 
+    #[test]
+    fn prof_reports_and_controls_the_profiler() {
+        let mut console = Console::default();
+        let mut sim = sim();
+        let mut camera = CameraState::default();
+        let mut profiler = Profiler::default();
+        profiler.record("sim", 2.0);
+        profiler.end(16.0);
+        profiler.begin();
+
+        console.input = "prof".into();
+        let lines = console.log.len();
+        assert_eq!(
+            run_line(&mut console, &mut sim, &mut camera, &mut profiler, false),
+            None,
+            "prof prints and wishes nothing"
+        );
+        assert!(
+            console.log.len() > lines + 1,
+            "the summary is a header plus span rows"
+        );
+
+        console.input = "prof pause".into();
+        run_line(&mut console, &mut sim, &mut camera, &mut profiler, false);
+        assert!(profiler.paused());
+        console.input = "prof resume".into();
+        run_line(&mut console, &mut sim, &mut camera, &mut profiler, false);
+        assert!(!profiler.paused());
+
+        console.input = "prof frobnicate".into();
+        run_line(&mut console, &mut sim, &mut camera, &mut profiler, false);
+
+        let path = std::env::temp_dir().join("connected-rails-prof-test.csv");
+        console.input = format!("prof csv {}", path.display());
+        run_line(&mut console, &mut sim, &mut camera, &mut profiler, false);
+        let csv = std::fs::read_to_string(&path).expect("the csv is written");
+        assert!(
+            csv.starts_with("frame,total_ms,sim_steps"),
+            "header plus span columns, got {csv:?}"
+        );
+        std::fs::remove_file(&path).ok();
+
+        console.input = "prof reset".into();
+        run_line(&mut console, &mut sim, &mut camera, &mut profiler, false);
+        assert!(profiler.frames().is_empty());
+        assert!(profiler.spikes().is_empty());
+    }
+
     #[test]
     fn the_history_walks_back_and_forward_over_the_draft() {
         let mut console = Console {
diff --git a/crates/app/src/displays.rs b/crates/app/src/displays.rs
index c30af80b..07ab7446 100644
--- a/crates/app/src/displays.rs
+++ b/crates/app/src/displays.rs
@@ -14,6 +14,7 @@
 //! every camera here renders every frame.
 
 use crate::models::{Bound, ModelRoot};
+use crate::profiler::Profiler;
 use crate::{Mods, PlayerTrain, SimResource};
 use bevy::camera::visibility::RenderLayers;
 use bevy::camera::{RenderTarget, ScalingMode};
@@ -263,7 +264,9 @@ pub fn update_displays(
     time: Res<Time>,
     mut gauges: NonSendMut<HtmlGauges>,
     mut throttle: Local<HtmlThrottle>,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let _scope = profiler.scope("displays");
     let Some(train) = sim.0.trains.get(player.0) else {
         return;
     };
diff --git a/crates/app/src/hud.rs b/crates/app/src/hud.rs
index 68f65bdd..82d916db 100644
--- a/crates/app/src/hud.rs
+++ b/crates/app/src/hud.rs
@@ -73,6 +73,7 @@ use sim_core::{Sim, TrainRuntime};
 use crate::bindings::{self, Action, Binds};
 use crate::cab::CabMouse;
 use crate::glyphs::{self, Icon};
+use crate::profiler::Profiler;
 use crate::settings::{Gameplay, HudMode};
 use crate::streaming::TerrainStreamer;
 use crate::theme::{
@@ -2389,9 +2390,12 @@ pub fn update_hud(
     session: Option<Res<crate::net::Session>>,
     diagnostics: Res<DiagnosticsStore>,
     mut nodes: Nodes,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let start = std::time::Instant::now();
     let mode = mode(&gameplay, over.as_deref());
     if !mode.drawn() {
+        profiler.record("hud", start.elapsed().as_secs_f64() * 1000.0);
         return;
     }
     let perf = Perf::read(&diagnostics);
@@ -2407,7 +2411,9 @@ pub fn update_hud(
         &view,
         session.as_deref(),
         &perf,
+        &profiler,
     ) else {
+        profiler.record("hud", start.elapsed().as_secs_f64() * 1000.0);
         return;
     };
 
@@ -2458,6 +2464,7 @@ pub fn update_hud(
             node.display = display;
         }
     }
+    profiler.record("hud", start.elapsed().as_secs_f64() * 1000.0);
 }
 
 /// Which stop of the timetable a row of the ribbon shows. Row 1 is always the next stop,
@@ -2552,6 +2559,7 @@ impl<'a> Frame<'a> {
         view: &ViewDistance,
         session: Option<&crate::net::Session>,
         perf: &Perf,
+        profiler: &Profiler,
     ) -> Option<Self> {
         let train = &sim.trains[player];
         // A consist that was coupled away has no leading vehicle to read (plan ch. 11);
@@ -2615,7 +2623,8 @@ impl<'a> Frame<'a> {
         };
         // Only worked out while the panel is open — it walks every signal of the line.
         if overlays.diagnostics {
-            frame.diagnostics = Some(frame.diagnose(terrain, streamer, view, session, perf));
+            frame.diagnostics =
+                Some(frame.diagnose(terrain, streamer, view, session, perf, profiler));
         }
         Some(frame)
     }
@@ -3270,6 +3279,7 @@ impl<'a> Frame<'a> {
         view: &ViewDistance,
         session: Option<&crate::net::Session>,
         perf: &Perf,
+        profiler: &Profiler,
     ) -> String {
         let drive = self.loco.traction.drives[0];
         let aspects: Vec<String> = self
@@ -3295,6 +3305,26 @@ impl<'a> Frame<'a> {
                 millis = decimal(perf.frame_ms, 1),
                 entities = perf.entities,
             ),
+            diagnose_prof(profiler),
+            diagnose_spans(profiler),
+            t!("hud-diag-graph", graph = profiler.graph()),
+        ];
+        if let Some(spike) = profiler.spikes().first() {
+            let breakdown = spike
+                .spans
+                .iter()
+                .take(3)
+                .map(|(name, ms)| format!("{name} {ms:.1}"))
+                .collect::<Vec<_>>()
+                .join(" ");
+            lines.push(t!(
+                "hud-diag-spike",
+                frame = spike.frame,
+                total = decimal(spike.total_ms, 1),
+                breakdown = breakdown,
+            ));
+        }
+        lines.extend([
             t!(
                 "hud-diag-terrain",
                 tiles = terrain.0.tiles,
@@ -3326,7 +3356,7 @@ impl<'a> Frame<'a> {
                 resistor = format!("{:.0}", drive.resistor_temp.max(drive.brake_resistor_temp)),
             ),
             t!("hud-diag-signals", aspects = aspects.join("  ")),
-        ];
+        ]);
         if let Some(session) = session {
             lines.push(t!(
                 "hud-diag-network",
@@ -3339,10 +3369,52 @@ impl<'a> Frame<'a> {
                 correction = decimal(session.correction(self.sim.score.train) * 100.0, 1),
             ));
         }
+        lines.push(t!("hud-diag-prof-hint"));
         lines.join("\n")
     }
 }
 
+/// The profiler's frame line for F6: average, p95 and maximum over the history,
+/// the hitch count, and how many fixed sim steps the last frame ran.
+fn diagnose_prof(profiler: &Profiler) -> String {
+    let stats = profiler.frame_stats();
+    let steps = profiler.frames().back().map_or(0, |f| f.sim_steps);
+    // While paused the numbers are the frozen history, not the run — without
+    // the marker a still graph reads as a still simulator.
+    let state = if profiler.paused() {
+        t!("hud-diag-paused")
+    } else {
+        String::new()
+    };
+    t!(
+        "hud-diag-prof",
+        frames = stats.count,
+        avg = decimal(stats.avg, 1),
+        p95 = decimal(stats.p95, 1),
+        max = decimal(stats.max, 1),
+        hitches = stats.hitches,
+        steps = steps,
+        state = state,
+    )
+}
+
+/// The CPU breakdown for F6: the slowest spans by average, and what they leave
+/// for render, present and vsync.
+fn diagnose_spans(profiler: &Profiler) -> String {
+    let spans = profiler
+        .span_stats()
+        .into_iter()
+        .take(6)
+        .map(|span| format!("{} {:.1}", span.name, span.avg))
+        .collect::<Vec<_>>()
+        .join(" ");
+    t!(
+        "hud-diag-spans",
+        spans = spans,
+        rest = decimal(profiler.rest_ms(), 1),
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/app/src/main.rs b/crates/app/src/main.rs
index 02e6d3db..3a8254d2 100644
--- a/crates/app/src/main.rs
+++ b/crates/app/src/main.rs
@@ -17,6 +17,7 @@ mod menu;
 mod models;
 mod mods_ui;
 mod net;
+mod profiler;
 mod render;
 mod services;
 mod settings;
@@ -446,6 +447,7 @@ fn main() {
         .init_resource::<cab::CabMouse>()
         .init_resource::<mods_ui::ModManager>()
         .init_resource::<hud::Overlays>()
+        .init_resource::<profiler::Profiler>()
         .init_resource::<menu::MenuState>()
         .init_resource::<menu::Selection>()
         // HTML cab screens hold a boa script context, which is `!Send` — a non-send
@@ -566,6 +568,21 @@ fn main() {
                 .chain()
                 .run_if(in_state(GameState::Driving)),
         )
+        // The frame profiler (`profiler.rs`): opens the frame before the driving
+        // systems run and closes it after all of them, so every timed system lands
+        // inside exactly one frame. Local measurement only, never replicated.
+        .add_systems(
+            PreUpdate,
+            profiler::begin_frame.run_if(in_state(GameState::Driving)),
+        )
+        .add_systems(
+            PostUpdate,
+            profiler::end_frame.run_if(in_state(GameState::Driving)),
+        )
+        // Logs the profiler when the process quits, whatever state it is in.
+        // After the window's own exit systems: they write `AppExit` in `Last`,
+        // and an unordered reader runs before them and never sees it.
+        .add_systems(Last, watch_exit.after(bevy::window::ExitSystems))
         // Vehicle models from mods: bind glTF nodes, switch LODs, move parts (plan ch. 15.3).
         .add_systems(
             Update,
@@ -632,6 +649,64 @@ fn main() {
     app.run();
 }
 
+/// Logs the profiler's view of the run: averages and p95 rather than the last
+/// frame's numbers, the CPU breakdown, and the worst spikes with what they
+/// were made of. Called wherever a run ends up in the log — back to the menu
+/// ([`tear_down_run`]), quit to the desktop (`watch_exit`) or `--frames`
+/// ([`exit_after_frames`]) — so a run nobody photographed still says what it
+/// cost. Silent where no frame was ever recorded.
+fn log_profiler(profiler: &profiler::Profiler) {
+    let stats = profiler.frame_stats();
+    if stats.count == 0 {
+        return;
+    }
+    info!(
+        "profiler: {} frames, {:.1} ms avg, {:.1} ms p95, {:.1} ms max, {} hitches; \
+         cpu {} rest {:.1}",
+        stats.count,
+        stats.avg,
+        stats.p95,
+        stats.max,
+        stats.hitches,
+        profiler.top_spans(8),
+        profiler.rest_ms(),
+    );
+    for spike in profiler.spikes().iter().take(3) {
+        let breakdown = spike
+            .spans
+            .iter()
+            .take(4)
+            .map(|(name, ms)| format!("{name} {ms:.1}"))
+            .collect::<Vec<_>>()
+            .join(" ");
+        info!(
+            "spike #{}: {:.1} ms ({breakdown})",
+            spike.frame, spike.total_ms,
+        );
+    }
+}
+
+/// Logs the profiler when the process is asked to quit — the window close and
+/// the menu's quit both arrive as [`AppExit`], and neither passes through a
+/// state exit. Runs in every state; [`log_profiler`] stays silent where the
+/// run left nothing behind, and [`tear_down_run`] has already logged and
+/// cleared a run that went back to the menu first, so nothing is logged twice.
+/// A `--frames` run logs through [`exit_after_frames`] instead and is left out
+/// here for the same reason.
+fn watch_exit(
+    mut exits: MessageReader<AppExit>,
+    frame_limit: Option<Res<FrameLimit>>,
+    mut profiler: ResMut<profiler::Profiler>,
+) {
+    if frame_limit.is_some() {
+        return;
+    }
+    if exits.read().next().is_some() {
+        log_profiler(&profiler);
+        profiler.reset();
+    }
+}
+
 /// Exits the app after the given number of frames — with `--screenshot` the window is
 /// captured beforehand.
 ///
@@ -649,6 +724,7 @@ fn exit_after_frames(
     // None in the menu: there is no terrain there, and `--menu <page> --screenshot`
     // is exactly how its pages get photographed.
     terrain: Option<Res<TerrainInfo>>,
+    profiler: Res<profiler::Profiler>,
     mut commands: Commands,
     mut count: Local<u32>,
     mut exit: MessageWriter<AppExit>,
@@ -673,6 +749,7 @@ fn exit_after_frames(
             terrain.map_or(0, |t| t.triangles),
             terrain.map_or(0.0, |t| t.memory() as f64 / (1024.0 * 1024.0)),
         );
+        log_profiler(&profiler);
     }
     let Some(shot) = shot else {
         if *count >= limit.0 {
@@ -751,11 +828,16 @@ fn tear_down_run(
     mixer: Option<ResMut<audio::Audio>>,
     mut walker: ResMut<walk::Walker>,
     mut camera: ResMut<ui::CameraState>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
     // No run has been built yet — this is the title screen the program starts on.
     let Some(before) = before else {
         return;
     };
+    // The run's frame numbers go into the log while they still exist — a new run
+    // starts its history from zero, so each one is measured on its own.
+    log_profiler(&profiler);
+    profiler.reset();
     for entity in &roots {
         if !before.0.contains(&entity) {
             commands.entity(entity).despawn();
@@ -835,7 +917,9 @@ fn terrain_visibility(
     view: Res<ViewDistance>,
     camera: Query<&GlobalTransform, With<ui::CabCamera>>,
     mut tiles: Query<(&TerrainChunk, &Transform, &mut Visibility)>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("cull");
     let Ok(camera) = camera.single() else {
         return;
     };
@@ -1113,7 +1197,9 @@ pub(crate) fn dispatch_services(
     host: Option<Res<net::Host>>,
     mods: Res<Mods>,
     role: Option<Res<net::Role>>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("dispatch");
     let Some(run) = run else { return };
     // A service that names no vehicle of its own gets the built-in one rather than
     // whatever the player picked in the menu: two clients would otherwise put different
@@ -1183,7 +1269,9 @@ pub(crate) fn drive_ai(
     time: Res<Time>,
     host: Option<Res<net::Host>>,
     role: Option<Res<net::Role>>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("ai");
     // On a client every train but the player's is driven from the server's setpoints — a
     // second AI running here would fight them.
     if role.is_some_and(|role| *role == net::Role::Client) {
@@ -1206,8 +1294,15 @@ pub(crate) fn drive_ai(
     }
 }
 
-pub(crate) fn step_simulation(mut sim: ResMut<SimResource>, time: Res<Time>) {
-    sim.0.advance(time.delta_secs_f64());
+pub(crate) fn step_simulation(
+    mut sim: ResMut<SimResource>,
+    time: Res<Time>,
+    mut profiler: ResMut<profiler::Profiler>,
+) {
+    let start = std::time::Instant::now();
+    let steps = sim.0.advance(time.delta_secs_f64());
+    profiler.set_sim_steps(steps);
+    profiler.record("sim", start.elapsed().as_secs_f64() * 1000.0);
 }
 
 /// Hands the walkers their clock (`world_render::PeopleClock`): the
@@ -1226,7 +1321,9 @@ pub(crate) fn run_mod_scripts(
     mut sim: ResMut<SimResource>,
     mut mods: ResMut<Mods>,
     time: Res<Time>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("lua");
     let dt = time.delta_secs_f64().min(0.25);
     mods.0.post_step(&mut sim.0, dt);
 }
@@ -1261,7 +1358,9 @@ fn sync_vehicles(
     sim: Res<SimResource>,
     origin: Res<Origin>,
     mut query: Query<(&VehicleView, &mut Transform, &mut Visibility)>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("sync");
     for (view, mut transform, mut visibility) in query.iter_mut() {
         let Some(train) = sim.0.trains.get(view.train) else {
             continue;
@@ -1299,7 +1398,9 @@ fn feed_sky(
     mut sky: ResMut<sky::Sky>,
     mut ambient: Query<&mut AmbientLight, With<ui::CabCamera>>,
     mut fog: Query<&mut DistanceFog, With<ui::CabCamera>>,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("sky");
     let (latitude, longitude, _) = world_coords::geo::from_ecef(origin.0.position());
     let start = sim.0.start;
     *sky = sky::Sky {
@@ -1487,7 +1588,9 @@ fn update_precipitation(
         ),
         Without<ui::CabCamera>,
     >,
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("precip");
     let Ok(cam) = camera.single() else {
         return;
     };
@@ -1604,6 +1707,7 @@ mod tests {
             .insert_resource(net::Role::Server)
             .insert_resource(run)
             .insert_resource(SimResource(built.sim))
+            .init_resource::<profiler::Profiler>()
             .add_systems(Update, dispatch_services);
 
         let before = app.world().resource::<SimResource>().0.trains.len();
@@ -1628,6 +1732,7 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<walk::Walker>();
         world.init_resource::<ui::CameraState>();
+        world.init_resource::<profiler::Profiler>();
         let mut snapshot = Schedule::default();
         snapshot.add_systems(remember_before_run);
         let mut leave = Schedule::default();
@@ -1707,6 +1812,7 @@ mod tests {
             .init_resource::<Builds>()
             .init_resource::<walk::Walker>()
             .init_resource::<ui::CameraState>()
+            .init_resource::<profiler::Profiler>()
             .insert_state(GameState::Menu)
             .add_systems(OnEnter(GameState::Menu), tear_down_run)
             .add_systems(
diff --git a/crates/app/src/models.rs b/crates/app/src/models.rs
index 1706a0b5..dafd1726 100644
--- a/crates/app/src/models.rs
+++ b/crates/app/src/models.rs
@@ -6,6 +6,7 @@
 
 use crate::SimResource;
 use crate::cab::{self, ControlMesh, ControlNode, Highlightable};
+use crate::profiler::Profiler;
 use bevy::gltf::GltfAssetLabel;
 use bevy::picking::Pickable;
 use bevy::prelude::*;
@@ -339,7 +340,9 @@ pub fn update_lod(
     camera: Query<&GlobalTransform, With<Camera3d>>,
     vehicles: Query<(&VehicleView, &GlobalTransform)>,
     mut nodes: Query<(&LodNode, &mut Visibility)>,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let _scope = profiler.scope("lod");
     let Ok(eye) = camera.single() else {
         return;
     };
@@ -429,7 +432,9 @@ pub fn animate_parts(
     sim: Res<SimResource>,
     mut nodes: Query<(&PartNode, &mut Transform, &mut Visibility)>,
     mut loads: Query<(&LoadNode, &Name, &mut Visibility), Without<PartNode>>,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let _scope = profiler.scope("parts");
     for (node, mut transform, mut visibility) in nodes.iter_mut() {
         let Some((part, value)) = part_of(&sim, node) else {
             continue;
@@ -832,6 +837,7 @@ mod tests {
 
         let mut app = App::new();
         app.insert_resource(SimResource(sim));
+        app.init_resource::<Profiler>();
         app.add_systems(Update, animate_parts);
         let nodes: Vec<Entity> = ["coal", "container"]
             .iter()
diff --git a/crates/app/src/net.rs b/crates/app/src/net.rs
index 097c05ca..0609585d 100644
--- a/crates/app/src/net.rs
+++ b/crates/app/src/net.rs
@@ -658,6 +658,13 @@ pub fn run_dedicated(address: &str) {
         .insert_resource(world.dispatch)
         .insert_resource(SimResource(world.sim))
         .init_resource::<Host>()
+        // The driving systems time themselves into this; without the frame
+        // bracket their spans would only accumulate. Nobody reads it here yet —
+        // the F6 overlay and the console are the client's — but the numbers are
+        // real and cost nothing to keep.
+        .init_resource::<crate::profiler::Profiler>()
+        .add_systems(PreUpdate, crate::profiler::begin_frame)
+        .add_systems(PostUpdate, crate::profiler::end_frame)
         // Nobody stands in a cab on a dedicated server; the clients' trains are protected
         // through `Host::driven` instead.
         .init_resource::<crate::crew::Duty>()
diff --git a/crates/app/src/profiler.rs b/crates/app/src/profiler.rs
new file mode 100644
index 00000000..c9db9f63
--- /dev/null
+++ b/crates/app/src/profiler.rs
@@ -0,0 +1,480 @@
+//! Frame profiler: what costs frame budget and what causes lags (plan 16.3).
+//!
+//! Bevy's own diagnostics say how long a frame took, but not where it went. This
+//! module closes that gap with per-system CPU timings on the main thread: every
+//! expensive driving system records its time into [`Profiler`], which keeps a
+//! rolling history, per-span averages, the worst spikes with their breakdown,
+//! and an ASCII history graph for the F6 overlay. The console's `prof` command
+//! prints the same numbers and exports the history as CSV.
+//!
+//! What it does not do on purpose: GPU timings (those need timestamp queries on
+//! Vulkan/DX12 — Bevy's `RenderDiagnosticsPlugin` — or an external viewer via
+//! `trace_tracy`; see README). Whatever the CPU spans do not account for shows
+//! as `rest` and is render, present and vsync. A high `rest` next to high
+//! triangle/entity counts points at the GPU, a high named span at the CPU side.
+//!
+//! **Multiplayer.** The profiler measures the local machine only — frame times
+//! are nothing the simulation owns and nothing any peer could use. Like the
+//! camera it is client-owned state (`CLAUDE.md` ch. 20): no setpoint, no
+//! message, nothing replicated.
+
+use bevy::prelude::*;
+use std::collections::VecDeque;
+use std::time::Instant;
+
+/// Frames of history kept — five seconds at 60 fps, enough to catch a hitch
+/// after it happened and still have the context around it.
+pub const HISTORY: usize = 300;
+/// A frame slower than this counts as a hitch — one and a half frames at 60 Hz,
+/// where a single dropped vsync stops being noise.
+pub const HITCH_MS: f64 = 25.0;
+/// Worst spikes remembered with their breakdown.
+pub const SPIKES: usize = 5;
+/// Full scale of the history graph [ms] — everything slower clamps to `@`.
+pub const GRAPH_MAX_MS: f64 = 50.0;
+/// Columns of the history graph. 56 columns of 11 px mono fit the F6 panel.
+pub const GRAPH_WIDTH: usize = 56;
+
+/// One finished frame: its total wall time, how many fixed sim steps it ran,
+/// and what the instrumented systems cost inside it [ms].
+#[derive(Debug, Clone)]
+pub struct FrameSample {
+    pub frame: u64,
+    pub total_ms: f64,
+    pub sim_steps: usize,
+    pub spans: Vec<(&'static str, f64)>,
+}
+
+impl FrameSample {
+    fn span(&self, name: &str) -> f64 {
+        self.spans
+            .iter()
+            .find(|(n, _)| *n == name)
+            .map_or(0.0, |(_, ms)| *ms)
+    }
+}
+
+/// Frame totals over the history: what the budget looks like.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct FrameStats {
+    pub count: usize,
+    pub avg: f64,
+    pub p95: f64,
+    pub max: f64,
+    pub hitches: usize,
+}
+
+/// One span aggregated over the history, sorted by `avg` where it is read.
+#[derive(Debug, Clone, Copy)]
+pub struct SpanStat {
+    pub name: &'static str,
+    pub avg: f64,
+    pub max: f64,
+}
+
+/// The profiler itself. A resource from `main`, filled by the driving systems,
+/// read by the F6 overlay, the console and the `--frames` log.
+#[derive(Resource, Debug, Default)]
+pub struct Profiler {
+    frames: VecDeque<FrameSample>,
+    current: Vec<(&'static str, f64)>,
+    current_steps: usize,
+    frame: u64,
+    paused: bool,
+    worst: Vec<FrameSample>,
+}
+
+impl Profiler {
+    /// Adds `ms` to the current frame's span, accumulating where a span is
+    /// recorded twice in one frame.
+    pub fn record(&mut self, name: &'static str, ms: f64) {
+        if let Some(slot) = self.current.iter_mut().find(|(n, _)| *n == name) {
+            slot.1 += ms;
+        } else {
+            self.current.push((name, ms));
+        }
+    }
+
+    /// How many fixed sim steps the last `advance` ran — the number that says
+    /// whether a slow `sim` span is one expensive step or catch-up after a hitch.
+    pub fn set_sim_steps(&mut self, steps: usize) {
+        self.current_steps = steps;
+    }
+
+    /// Times one system. The guard records on drop, so early returns are timed too:
+    /// `let _scope = profiler.scope("sim");` as the first line of the system.
+    pub fn scope(&mut self, name: &'static str) -> Scope<'_> {
+        Scope {
+            profiler: self,
+            name,
+            start: Instant::now(),
+        }
+    }
+
+    /// Whether new frames are recorded. While paused the overlay and the console
+    /// keep showing the frozen history.
+    pub fn paused(&self) -> bool {
+        self.paused
+    }
+
+    pub fn set_paused(&mut self, paused: bool) {
+        self.paused = paused;
+    }
+
+    /// Forgets every frame and spike sampled so far.
+    pub fn reset(&mut self) {
+        self.frames.clear();
+        self.current.clear();
+        self.current_steps = 0;
+        self.worst.clear();
+    }
+
+    /// Frames sampled, oldest first.
+    pub fn frames(&self) -> &VecDeque<FrameSample> {
+        &self.frames
+    }
+
+    /// Worst spikes, slowest first.
+    pub fn spikes(&self) -> &[FrameSample] {
+        &self.worst
+    }
+
+    /// Frame totals over the history.
+    pub fn frame_stats(&self) -> FrameStats {
+        let mut totals: Vec<f64> = self.frames.iter().map(|f| f.total_ms).collect();
+        if totals.is_empty() {
+            return FrameStats::default();
+        }
+        totals.sort_by(|a, b| a.total_cmp(b));
+        let count = totals.len();
+        let avg = totals.iter().sum::<f64>() / count as f64;
+        let p95 = totals[(count * 95 / 100).min(count - 1)];
+        FrameStats {
+            count,
+            avg,
+            p95,
+            max: totals[count - 1],
+            hitches: totals.iter().filter(|ms| **ms >= HITCH_MS).count(),
+        }
+    }
+
+    /// Every span seen in the history, slowest average first. A span missing
+    /// from a frame counts as zero there — an average over present frames only
+    /// would hide how rarely it runs.
+    pub fn span_stats(&self) -> Vec<SpanStat> {
+        if self.frames.is_empty() {
+            return Vec::new();
+        }
+        let mut names: Vec<&'static str> = Vec::new();
+        for frame in &self.frames {
+            for (name, _) in &frame.spans {
+                if !names.contains(name) {
+                    names.push(name);
+                }
+            }
+        }
+        let count = self.frames.len() as f64;
+        let mut stats: Vec<SpanStat> = names
+            .into_iter()
+            .map(|name| {
+                let mut sum: f64 = 0.0;
+                let mut max: f64 = 0.0;
+                for frame in &self.frames {
+                    let ms = frame.span(name);
+                    sum += ms;
+                    max = max.max(ms);
+                }
+                SpanStat {
+                    name,
+                    avg: sum / count,
+                    max,
+                }
+            })
+            .collect();
+        stats.sort_by(|a, b| b.avg.total_cmp(&a.avg));
+        stats
+    }
+
+    /// What the spans do not account for [ms]: render, present and vsync, plus
+    /// the systems too small to instrument. Negative by an epsilon where the
+    /// clocks disagree — clamped to zero, which is what it means.
+    pub fn rest_ms(&self) -> f64 {
+        let stats = self.frame_stats();
+        let accounted: f64 = self.span_stats().iter().map(|s| s.avg).sum();
+        (stats.avg - accounted).max(0.0)
+    }
+
+    /// The history as one line of ` .:-=+*#@`, oldest to newest, bucketed down
+    /// to [`GRAPH_WIDTH`] columns by maximum. Pure ASCII: it has to survive the
+    /// HUD font on every platform.
+    pub fn graph(&self) -> String {
+        const LEVELS: &[u8] = b" .:-=+*#@";
+        if self.frames.is_empty() {
+            return String::new();
+        }
+        let bucket = self.frames.len().div_ceil(GRAPH_WIDTH);
+        self.frames
+            .iter()
+            .collect::<Vec<_>>()
+            .chunks(bucket.max(1))
+            .map(|chunk| {
+                let peak = chunk.iter().map(|f| f.total_ms).fold(0.0, f64::max);
+                let level = ((peak / GRAPH_MAX_MS * (LEVELS.len() - 1) as f64) as usize)
+                    .min(LEVELS.len() - 1);
+                LEVELS[level] as char
+            })
+            .collect()
+    }
+
+    /// The slowest spans as `name avg …`, for log lines (the F6 overlay and the
+    /// console word the same numbers through i18n instead).
+    pub fn top_spans(&self, n: usize) -> String {
+        self.span_stats()
+            .into_iter()
+            .take(n)
+            .map(|span| format!("{} {:.2}", span.name, span.avg))
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
+
+    /// The history as CSV: one row per frame, one column per span seen. Spans a
+    /// frame did not record stay empty, so a missing column reads as missing
+    /// rather than as free.
+    pub fn csv(&self) -> String {
+        let mut names: Vec<&'static str> = Vec::new();
+        for frame in &self.frames {
+            for (name, _) in &frame.spans {
+                if !names.contains(name) {
+                    names.push(name);
+                }
+            }
+        }
+        names.sort_unstable();
+        let mut out = String::from("frame,total_ms,sim_steps");
+        for name in &names {
+            out.push(',');
+            out.push_str(name);
+        }
+        out.push('\n');
+        for frame in &self.frames {
+            out.push_str(&format!(
+                "{},{:.3},{}",
+                frame.frame, frame.total_ms, frame.sim_steps
+            ));
+            for name in &names {
+                match frame.spans.iter().find(|(n, _)| n == name) {
+                    Some((_, ms)) => out.push_str(&format!(",{ms:.3}")),
+                    None => out.push(','),
+                }
+            }
+            out.push('\n');
+        }
+        out
+    }
+
+    pub(crate) fn begin(&mut self) {
+        self.current.clear();
+        self.current_steps = 0;
+    }
+
+    pub(crate) fn end(&mut self, total_ms: f64) {
+        if self.paused {
+            self.current.clear();
+            return;
+        }
+        self.frame += 1;
+        let sample = FrameSample {
+            frame: self.frame,
+            total_ms,
+            sim_steps: self.current_steps,
+            spans: std::mem::take(&mut self.current),
+        };
+        self.worst.push(sample.clone());
+        self.worst.sort_by(|a, b| b.total_ms.total_cmp(&a.total_ms));
+        self.worst.truncate(SPIKES);
+        self.frames.push_back(sample);
+        while self.frames.len() > HISTORY {
+            self.frames.pop_front();
+        }
+    }
+}
+
+/// The guard [`Profiler::scope`] hands out. Records on drop, so the timed
+/// system needs no bookkeeping at its exits.
+pub struct Scope<'a> {
+    profiler: &'a mut Profiler,
+    name: &'static str,
+    start: Instant,
+}
+
+impl Drop for Scope<'_> {
+    fn drop(&mut self) {
+        self.profiler
+            .record(self.name, self.start.elapsed().as_secs_f64() * 1000.0);
+    }
+}
+
+/// Opens the current frame. `PreUpdate` while driving, before every timed system.
+pub fn begin_frame(mut profiler: ResMut<Profiler>) {
+    profiler.begin();
+}
+
+/// Closes the current frame. `PostUpdate` while driving, after every timed
+/// system: the wall time between frames is the budget, render and vsync included.
+pub fn end_frame(time: Res<Time>, mut profiler: ResMut<Profiler>) {
+    profiler.end(time.delta_secs_f64() * 1000.0);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn profiler_with(totals: &[f64]) -> Profiler {
+        let mut profiler = Profiler::default();
+        for (i, total) in totals.iter().enumerate() {
+            profiler.record("sim", *total * 0.6);
+            profiler.record("rest-span", *total * 0.2);
+            profiler.set_sim_steps(i % 3);
+            profiler.end(*total);
+            profiler.begin();
+        }
+        profiler
+    }
+
+    #[test]
+    fn a_span_recorded_twice_accumulates() {
+        let mut profiler = Profiler::default();
+        profiler.record("sim", 1.5);
+        profiler.record("sim", 2.5);
+        profiler.end(10.0);
+        assert_eq!(profiler.frames().back().unwrap().span("sim"), 4.0);
+    }
+
+    #[test]
+    fn totals_average_and_percentile_over_the_history() {
+        let profiler = profiler_with(&[10.0, 20.0, 30.0, 40.0]);
+        let stats = profiler.frame_stats();
+        assert_eq!(stats.count, 4);
+        assert_eq!(stats.avg, 25.0);
+        assert_eq!(stats.max, 40.0);
+        // p95 of four samples is the slowest one.
+        assert_eq!(stats.p95, 40.0);
+        assert_eq!(stats.hitches, 2, "30 and 40 ms clear 25 ms");
+    }
+
+    #[test]
+    fn an_empty_profiler_reports_zeroes() {
+        let profiler = Profiler::default();
+        let stats = profiler.frame_stats();
+        assert_eq!(stats.count, 0);
+        assert_eq!(stats.avg, 0.0);
+        assert!(profiler.span_stats().is_empty());
+        assert!(profiler.spikes().is_empty());
+        assert_eq!(profiler.graph(), "");
+        assert_eq!(profiler.csv(), "frame,total_ms,sim_steps\n");
+    }
+
+    #[test]
+    fn history_is_bounded_and_spikes_keep_the_worst() {
+        let mut profiler = Profiler::default();
+        for i in 0..HISTORY + 50 {
+            profiler.record("sim", 1.0);
+            profiler.end(if i == HISTORY + 10 { 100.0 } else { 5.0 });
+            profiler.begin();
+        }
+        assert_eq!(profiler.frames().len(), HISTORY);
+        assert_eq!(profiler.spikes().len(), SPIKES.min(HISTORY + 50));
+        assert_eq!(profiler.spikes()[0].total_ms, 100.0);
+    }
+
+    #[test]
+    fn pausing_freezes_the_history() {
+        let mut profiler = Profiler::default();
+        profiler.record("sim", 2.0);
+        profiler.end(16.0);
+        profiler.set_paused(true);
+        profiler.begin();
+        profiler.record("sim", 9.0);
+        profiler.end(60.0);
+        assert_eq!(profiler.frames().len(), 1);
+        assert!(profiler.paused());
+        profiler.set_paused(false);
+        profiler.begin();
+        profiler.end(16.0);
+        assert_eq!(profiler.frames().len(), 2);
+    }
+
+    #[test]
+    fn spans_sort_by_average_and_missing_counts_as_zero() {
+        let mut profiler = Profiler::default();
+        profiler.record("often", 4.0);
+        profiler.record("rare", 10.0);
+        profiler.end(20.0);
+        profiler.begin();
+        profiler.record("often", 4.0);
+        profiler.end(20.0);
+        profiler.begin();
+        let stats = profiler.span_stats();
+        assert_eq!(stats[0].name, "rare", "10/2 beats 8/2");
+        assert_eq!(stats[0].avg, 5.0);
+        assert_eq!(stats[1].avg, 4.0);
+        assert_eq!(stats[1].max, 4.0);
+    }
+
+    #[test]
+    fn the_scope_guard_times_the_enclosing_block() {
+        let mut profiler = Profiler::default();
+        {
+            let _scope = profiler.scope("work");
+            std::thread::sleep(std::time::Duration::from_millis(5));
+        }
+        profiler.end(16.0);
+        let took = profiler.frames().back().unwrap().span("work");
+        assert!(took >= 4.0, "the guard records wall time, got {took:.1} ms");
+    }
+
+    #[test]
+    fn the_graph_buckets_the_history_into_columns() {
+        // 112 frames at bucket 2 land exactly on the column count.
+        let totals: Vec<f64> = (0..112).map(|i| i as f64).collect();
+        let profiler = profiler_with(&totals);
+        let graph = profiler.graph();
+        assert_eq!(graph.len(), GRAPH_WIDTH);
+        assert!(
+            graph.ends_with('@'),
+            "the newest bucket peaks far past {GRAPH_MAX_MS} ms"
+        );
+        assert!(graph.starts_with(' '), "the oldest bucket is near zero");
+        assert!(
+            graph.bytes().all(|b| b" .:-=+*#@".contains(&b)),
+            "ASCII only, for the HUD font"
+        );
+    }
+
+    #[test]
+    fn top_spans_lists_the_slowest_averages_first() {
+        let profiler = profiler_with(&[10.0, 20.0]);
+        assert_eq!(profiler.top_spans(1), "sim 9.00");
+        assert_eq!(profiler.top_spans(5), "sim 9.00 rest-span 3.00");
+    }
+
+    #[test]
+    fn csv_lists_every_span_seen() {
+        let mut profiler = Profiler::default();
+        profiler.record("sim", 2.5);
+        profiler.end(16.25);
+        profiler.begin();
+        profiler.record("stream", 6.0);
+        profiler.end(20.0);
+        profiler.begin();
+        let csv = profiler.csv();
+        let mut lines = csv.lines();
+        assert_eq!(lines.next().unwrap(), "frame,total_ms,sim_steps,sim,stream");
+        let first = lines.next().unwrap();
+        assert!(
+            first.starts_with("1,16.250,0,2.500,"),
+            "missing spans stay empty, got {first:?}"
+        );
+        assert!(lines.next().unwrap().ends_with(",6.000"));
+    }
+}
diff --git a/crates/app/src/signals.rs b/crates/app/src/signals.rs
index f91b53c3..1bc49645 100644
--- a/crates/app/src/signals.rs
+++ b/crates/app/src/signals.rs
@@ -15,6 +15,7 @@
 //! that follows the running interlocking: lamp image, arm travel, placeholder
 //! colour.
 
+use crate::profiler::Profiler;
 use crate::{SimResource, models};
 use bevy::prelude::*;
 use sim_core::train::Motion;
@@ -104,7 +105,12 @@ pub fn update_signal_lods(
 }
 
 /// Shows exactly the lamp nodes whose string is in the signal's lamp image.
-pub fn update_lamps(sim: Res<SimResource>, mut lamps: Query<(&SignalLamp, &mut Visibility)>) {
+pub fn update_lamps(
+    sim: Res<SimResource>,
+    mut lamps: Query<(&SignalLamp, &mut Visibility)>,
+    mut profiler: ResMut<Profiler>,
+) {
+    let _scope = profiler.scope("lamps");
     for (lamp, mut visibility) in lamps.iter_mut() {
         let lit = sim
             .0
diff --git a/crates/app/src/streaming.rs b/crates/app/src/streaming.rs
index f4e65206..259cf5c3 100644
--- a/crates/app/src/streaming.rs
+++ b/crates/app/src/streaming.rs
@@ -21,7 +21,7 @@ use content::terrain::{self, TerrainBuilder, TerrainOptions, TerrainStats, Terra
 use glam::DVec2;
 
 use crate::render;
-use crate::{Origin, SimResource, TerrainInfo, ui};
+use crate::{Origin, SimResource, TerrainInfo, profiler, ui};
 
 /// How many tiles are built at the same time. One per worker thread is the
 /// most that can run; the rest only queue.
@@ -174,7 +174,9 @@ pub fn stream_terrain(
         ResMut<world_render::ConductorMaterials>,
         ResMut<Assets<world_render::ConductorMaterial>>,
     ),
+    mut profiler: ResMut<profiler::Profiler>,
 ) {
+    let _scope = profiler.scope("stream");
     let options = streamer.options;
     // Every train counts, not just the player's — otherwise an AI train would drive
     // through a hole in the world as soon as someone looks at it.
diff --git a/crates/app/src/ui.rs b/crates/app/src/ui.rs
index 916d5212..7fa059b8 100644
--- a/crates/app/src/ui.rs
+++ b/crates/app/src/ui.rs
@@ -5,6 +5,7 @@
 
 use crate::bindings::{Action, Input, Lever};
 use crate::mods_ui::ModManager;
+use crate::profiler::Profiler;
 use crate::settings::Gameplay;
 use crate::{Origin, PlayerTrain, SimResource};
 use bevy::input::mouse::AccumulatedMouseMotion;
@@ -71,6 +72,7 @@ impl CameraMode {
 
 /// Bound keys and controller buttons → cab inputs. Which key does what is
 /// `bindings.rs`; this is only what each action moves.
+#[allow(clippy::too_many_arguments)]
 pub fn player_input(
     input: Input,
     console: Res<crate::console::Console>,
@@ -79,7 +81,9 @@ pub fn player_input(
     duty: Res<crate::crew::Duty>,
     time: Res<Time>,
     camera: Res<CameraState>,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let _scope = profiler.scope("input");
     // The console holds the keyboard while it is open: `W` is a letter there, not
     // throttle up (`crate::console`).
     if console.open {
@@ -335,7 +339,9 @@ pub fn camera_control(
     walker: Res<crate::walk::Walker>,
     mut state: ResMut<CameraState>,
     mut camera: Query<&mut Transform, With<CabCamera>>,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let _scope = profiler.scope("camera");
     let dt = time.delta_secs();
     if input.just_pressed(Action::ViewCab) {
         state.mode = CameraMode::Cab;
diff --git a/crates/app/src/walk.rs b/crates/app/src/walk.rs
index 07ab5de8..eddad3be 100644
--- a/crates/app/src/walk.rs
+++ b/crates/app/src/walk.rs
@@ -26,6 +26,7 @@ use sim_core::train::{Train, Vehicle};
 use world_coords::{EcefPos, RenderOrigin};
 use world_render::{CharacterGraphs, Dressed, Gait, Person, gait, play_gait};
 
+use crate::profiler::Profiler;
 use crate::ui::{CameraMode, CameraState};
 use crate::{Origin, PlayerTrain, Precipitation, SimResource};
 
@@ -106,7 +107,9 @@ pub fn walk_player(
     mut ray: MeshRayCast,
     precipitation: Query<(), With<Precipitation>>,
     console: Res<crate::console::Console>,
+    mut profiler: ResMut<Profiler>,
 ) {
+    let _scope = profiler.scope("walk");
     // The console holds the keyboard while it is open (`crate::console`) — W is a
     // letter there, not a step forward.
     if console.open {
diff --git a/crates/i18n/locales/de/main.ftl b/crates/i18n/locales/de/main.ftl
index d9d7a4fe..07c30587 100644
--- a/crates/i18n/locales/de/main.ftl
+++ b/crates/i18n/locales/de/main.ftl
@@ -1392,6 +1392,12 @@ hud-key-pause = Pause
 # Die Diagnose, F6. Maschinenausgabe — sie darf so dicht sein, wie sie will.
 hud-diagnostics = Diagnose
 hud-diag-frame = Bild     { $fps } fps, { $millis } ms, { $entities } Entitäten
+hud-diag-prof = Prof     { $frames } Bilder, { $avg } ms im Mittel, p95 { $p95 }, max { $max }, { $hitches } Ruckler, Sim { $steps } Schritte { $state }
+hud-diag-paused = · pausiert
+hud-diag-spans = CPU      { $spans } · Rest { $rest } ms
+hud-diag-graph = { $graph }
+hud-diag-spike = Spitze #{ $frame } { $total } ms ({ $breakdown })
+hud-diag-prof-hint = Konsole: prof · prof reset · prof pause/resume · prof csv <Datei>
 hud-diag-terrain = Gelände  { $tiles } Kacheln (+{ $pending }), { $triangles } Dreiecke, { $megabytes } MB, Sicht { $view } m
 hud-diag-air = Luft     R { $auxiliary } bar   Zusatz { $direct } bar   { $air } Nl verbraucht
 hud-diag-axles = Achsen   { $slipping }/{ $axles } schleudern, schlimmste { $worst } m/s
@@ -1754,11 +1760,23 @@ console-usage-time = time [HH:MM[:SS]]
 console-usage-fly = fly
 console-usage-help = help [command]
 console-usage-clear = clear
+console-usage-prof = prof [reset|pause|resume|csv <Datei>]
 console-help-weather = das Wetter ändern — ohne Name zeigt es das aktuelle
 console-help-time = die Uhr auf eine Tageszeit vorstellen — ohne Zeit zeigt sie die aktuelle
 console-help-fly = die Freikamera zum Überfliegen der Strecke umschalten — ein Werkzeug für die Entwicklung
 console-help-help = die Befehle auflisten
 console-help-clear = den Log leeren
+console-help-prof = zeigen, was die letzten Bilder gekostet haben — der Bild-Profiler
+console-prof-summary = { $frames } Bilder, { $avg } ms im Mittel, p95 { $p95 }, max { $max }, { $hitches } Ruckler
+console-prof-span = { $name } { $avg } ms im Mittel, { $max } ms max ({ $share } %)
+console-prof-rest = Rest (Rendern/Present/Vsync): { $rest } ms
+console-prof-spike = Spitze #{ $frame }: { $total } ms ({ $breakdown })
+console-prof-empty = Noch keine Bilder aufgezeichnet
+console-prof-reset = Profiler-Verlauf gelöscht
+console-prof-paused = Profiler angehalten — die Anzeige zeigt den eingefrorenen Verlauf weiter
+console-prof-resumed = Profiler zeichnet wieder auf
+console-prof-saved = { $rows } Bilder nach { $path } geschrieben
+console-prof-failed = Konnte { $path } nicht schreiben: { $error }
 
 ## Wertung
 
diff --git a/crates/i18n/locales/en/main.ftl b/crates/i18n/locales/en/main.ftl
index ee56ed80..d74afc3e 100644
--- a/crates/i18n/locales/en/main.ftl
+++ b/crates/i18n/locales/en/main.ftl
@@ -1391,6 +1391,12 @@ hud-key-pause = Pause
 # The diagnostics, F6. Machine output — it may be as dense as it likes.
 hud-diagnostics = Diagnostics
 hud-diag-frame = Frame    { $fps } fps, { $millis } ms, { $entities } entities
+hud-diag-prof = Prof     { $frames } frames, { $avg } ms avg, p95 { $p95 }, max { $max }, { $hitches } hitches, sim { $steps } steps { $state }
+hud-diag-paused = · paused
+hud-diag-spans = CPU      { $spans } · rest { $rest } ms
+hud-diag-graph = { $graph }
+hud-diag-spike = Spike #{ $frame } { $total } ms ({ $breakdown })
+hud-diag-prof-hint = console: prof · prof reset · prof pause/resume · prof csv <file>
 hud-diag-terrain = Terrain  { $tiles } tiles (+{ $pending }), { $triangles } tri, { $megabytes } MB, view { $view } m
 hud-diag-air = Air      AR { $auxiliary } bar   direct { $direct } bar   { $air } Nl used
 hud-diag-axles = Axles    { $slipping }/{ $axles } slipping, worst { $worst } m/s
@@ -1752,11 +1758,23 @@ console-usage-time = time [HH:MM[:SS]]
 console-usage-fly = fly
 console-usage-help = help [command]
 console-usage-clear = clear
+console-usage-prof = prof [reset|pause|resume|csv <file>]
 console-help-weather = change the weather — without a name it shows the current one
 console-help-time = move the clock forward to a time of day — without a time it shows the current one
 console-help-fly = toggle the free camera for flying over the route — a developer tool
 console-help-help = list the commands
 console-help-clear = empty the log
+console-help-prof = show what the last frames cost — the frame profiler
+console-prof-summary = { $frames } frames, { $avg } ms avg, p95 { $p95 }, max { $max }, { $hitches } hitches
+console-prof-span = { $name } { $avg } ms avg, { $max } ms max ({ $share } %)
+console-prof-rest = rest (render/present/vsync): { $rest } ms
+console-prof-spike = spike #{ $frame }: { $total } ms ({ $breakdown })
+console-prof-empty = No frames recorded yet
+console-prof-reset = Profiler history cleared
+console-prof-paused = Profiler paused — the overlay keeps showing the frozen history
+console-prof-resumed = Profiler recording again
+console-prof-saved = Wrote { $rows } frames to { $path }
+console-prof-failed = Could not write { $path }: { $error }
 
 ## Scoring
 
diff --git a/crates/sim-core/src/lib.rs b/crates/sim-core/src/lib.rs
index ade9f3c3..e2533f9d 100644
--- a/crates/sim-core/src/lib.rs
+++ b/crates/sim-core/src/lib.rs
@@ -159,12 +159,17 @@ impl Sim {
     }
 
     /// Advances the simulation by `dt` seconds of real time (fixed time step internally).
-    pub fn advance(&mut self, dt: f64) {
+    /// Returns how many fixed steps ran — the profiler reads it to tell one expensive
+    /// step apart from catch-up after a hitch.
+    pub fn advance(&mut self, dt: f64) -> usize {
         self.accumulator = (self.accumulator + dt).min(Self::MAX_CATCHUP);
+        let mut steps = 0;
         while self.accumulator >= Self::DT {
             self.step(Self::DT);
             self.accumulator -= Self::DT;
+            steps += 1;
         }
+        steps
     }
 
     /// One fixed simulation step.