From f2e42f2e9fff67ba60a291cfad04df7100a0cecc Mon Sep 17 00:00:00 2001
From: Ashish Nagar <ashishnagar31@gmail.com>
Date: Fri, 31 Jul 2026 15:53:06 -0400
Subject: [PATCH 1/4] Add a live tidal-disruption light curve overlay

A small 2D-canvas chart that plots the disc's feeding boost against time
since the star came apart, on log-log axes, with the t^(-5/3) fallback law
drawn through the recorded peak. Off by default, one folder in the panel,
and it works on the touch layout.

It was asked for on the expectation that the fallback law would emerge from
the simulation. It does not, and the feature is built to show that rather
than to imply it. A realistic-mode star at the shipped clock decays like
t^(-7.3), and the fitted index tracks the Disruption speed slider (about
-12.5 at compression 4, -3.3 at 30) while barely moving with the seed or
the placement radius. That is the app's own machinery talking: the plotted
series is the absorbed-debris rate smeared by DISC_TUNING.boostDecayTau,
fed by debris that DEBRIS_TUNING drag circularizes on a fixed timescale and
maxAge truncates. So the reference line is anchored at the peak and never
fitted, the caption prints the fitted index next to the law's, and the
measurement is pinned by fallbackLaw.test.ts, documented in part 11 of
docs/THEORY.md and listed in its "What we cheat on" table.

The recorder is a fixed-capacity ring with no DOM and no WebGL, so all of
its maths is unit tested directly. The frame loop only gains one
recordFeeding call per fixed tick (an add, a compare, two typed-array
writes about once in 120 ticks); the chart repaints on its own 10 Hz timer
behind a dirty check, so no chart work happens inside frame().

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/THEORY.md                       |  67 +++++
 index.html                           |  39 +++
 src/config.ts                        |  35 +++
 src/main.ts                          |  41 +++-
 src/settings.ts                      |  12 +
 src/ui/__tests__/fallbackLaw.test.ts | 159 ++++++++++++
 src/ui/__tests__/lightCurve.test.ts  | 325 +++++++++++++++++++++++++
 src/ui/lightCurve.ts                 | 352 +++++++++++++++++++++++++++
 src/ui/lightCurveChart.ts            | 278 +++++++++++++++++++++
 src/ui/panel.ts                      |  14 ++
 10 files changed, 1320 insertions(+), 2 deletions(-)
 create mode 100644 src/ui/__tests__/fallbackLaw.test.ts
 create mode 100644 src/ui/__tests__/lightCurve.test.ts
 create mode 100644 src/ui/lightCurve.ts
 create mode 100644 src/ui/lightCurveChart.ts

diff --git a/docs/THEORY.md b/docs/THEORY.md
index aa35bcd..fe0ea7b 100644
--- a/docs/THEORY.md
+++ b/docs/THEORY.md
@@ -445,6 +445,35 @@ around the hole. That returning ribbon is the stream you see. The rate at
 which it comes back follows a famous power law, $\dot M \propto t^{-5/3}$
 (Rees, 1988), which is how real tidal disruption flares are identified.
 
+**Where the $-5/3$ comes from.** It falls out of Kepler and nothing else. Take
+the energy spread to be flat across the star, so equal masses of debris landed
+in equal slices of binding energy:
+
+$$\frac{dM}{d|\varepsilon|} = \text{constant}$$
+
+A bound fragment with binding energy $|\varepsilon|$ is on an ellipse whose size
+is fixed by that energy alone, $a = GM / (2|\varepsilon|)$, and Part 2's orbit
+equation gives the time it takes to come back:
+
+$$T = 2\pi\sqrt{\frac{a^3}{GM}} = 2\pi\, GM\, (2|\varepsilon|)^{-3/2}$$
+
+Tightly bound debris returns quickly, barely bound debris takes almost forever.
+Now turn the question round: at time $t$ after the disruption, *which* fragments
+are arriving? The ones whose period is $t$:
+
+$$|\varepsilon|(t) = \tfrac{1}{2}\left(\frac{2\pi GM}{t}\right)^{2/3}$$
+
+The mass arriving per second is the mass sitting in each slice of energy times
+how fast that energy window sweeps downward:
+
+$$\frac{dM}{dt} = \frac{dM}{d|\varepsilon|}\cdot\left|\frac{d|\varepsilon|}{dt}\right|
+= \frac{dM}{d|\varepsilon|}\cdot\frac{1}{3}\,(2\pi GM)^{2/3}\, t^{-5/3}$$
+
+$$\boxed{\dot M \propto t^{-5/3}}$$
+
+Everything about the star cancels except the constant out front. That is why the
+exponent, and not the brightness, is the thing surveys look for.
+
 **The trap.** Energy is not the only thing that matters: angular momentum
 decides how close the debris passes on its return. Give a particle a kick along
 its direction of travel and you change its energy *and* strip its angular
@@ -457,9 +486,44 @@ particle onto the star's own orbit at its own radius rather than copying the
 star's velocity vector. Both decisions were arrived at by watching the stream
 fail without them.
 
+**Watching for the law, and not finding it.** The app can plot its own version
+of that curve: turn on *Light curve* and it records how hard the disruption is
+feeding the disc against time since the star came apart, on log axes, with the
+$t^{-5/3}$ law drawn through the peak for comparison.
+
+The two do not agree, and the overlay is built to show that rather than hide it.
+A realistic-mode star at the shipped settings decays like $t^{-7.3}$, four times
+steeper than the law. Three reasons, all of them ours and none of them nature's:
+
+- **What is plotted is not the fallback rate.** It is the disc's feeding glow,
+  which is the absorbed-debris rate smeared by an exponential decay time
+  (`DISC_TUNING.boostDecayTau`). Once the last particle is swallowed the curve is
+  that decay and nothing else, and an exponential on log axes gets steeper
+  without limit.
+- **The debris is not left alone to return.** A small drag circularises it on a
+  fixed timescale, so the whole bound half is eaten within about a factor of two
+  in time instead of spreading over the decades a real energy distribution
+  covers. A hard age limit kills the longest-period debris, which is exactly the
+  material that would have made the late tail.
+- **The clock is compressed.** The feeding glow decays on the simulation clock
+  while the chart is drawn on the disruption clock, so the *Disruption speed*
+  slider changes the fitted slope: about $-12.5$ at compression 4, $-7.3$ at 8,
+  $-3.3$ at 30. A measurement of nature would not care where that slider is.
+
+Cinematic mode fits about $-1.85$, which looks like a match and is not one: that
+mode is a drag-driven spiral with no energy spread at all, so it has no fallback
+to obey, and its number moves with the same slider. The chart therefore prints
+the fitted index next to the law's and anchors the reference line at the
+recorded peak instead of fitting its height, so the gap is always on screen.
+
 > **In the code:** `spawnFromBody` in `src/sim/debris.ts`, the orbit
 > reconstruction in `src/sim/orbit.ts`, and the tests in
 > `src/sim/__tests__/stream.test.ts` that hold the resulting shape in place.
+> The light curve itself is `src/ui/lightCurve.ts` (the recorder and the
+> log-log projection) and `src/ui/lightCurveChart.ts` (the canvas), with
+> `src/ui/__tests__/lightCurve.test.ts` and
+> `src/ui/__tests__/fallbackLaw.test.ts`, the second of which drives real
+> disruptions and pins every number quoted above.
 
 ---
 
@@ -606,6 +670,7 @@ the other column.
 | **The disc is infinitely thin.** | A volumetric disc multiplies the per-pixel cost. | Raymarched volume with real optical depth. |
 | **The jet is drawn, not launched.** | Blandford-Znajek needs spin, which we do not have, plus magnetohydrodynamics. | GRMHD simulation data. The beaming, at least, is computed and not painted. |
 | **Two clocks run fast.** | A disruption takes days, an inspiral from $8\,r_s$ takes about 1600 time units. | Nothing: the trajectories are exact, only the clock is compressed, and the app says so in the interface. |
+| **The light curve is not the fallback law.** | We plot the disc's feeding glow, which is the absorbed-debris rate smeared by a decay time, fed by debris that a drag term circularises on a fixed timescale. | Leave the debris on its own orbits and plot the arrival rate directly. As it stands the curve decays like $t^{-7.3}$, so the app draws the law next to it and says which is which. |
 | **No light travel-time delay.** | You see the whole disc at one instant rather than each part as it was when its light left. | Track photon arrival times through the march. |
 | **The sky is invented.** | It follows real structure (luminosity function, dust extinction, clustering) but it is not a star catalogue. | A real survey texture, at the cost of every image looking identical. |
 
@@ -630,6 +695,8 @@ the other column.
 | Doppler + gravity shift | $g = \sqrt{1 - 3M/r}\,/\,\gamma(1 - \beta\cos\alpha)$ | `shaders/geodesic.frag` |
 | Tidal radius | $r_T \approx R_\star (M/m_\star)^{1/3}$ | `config.ts` |
 | Tidal energy spread | $\Delta\varepsilon \approx GMR_\star/r_p^2$ | `sim/debris.ts` |
+| Debris return period | $T = 2\pi GM(2\lvert\varepsilon\rvert)^{-3/2}$ | Part 11 |
+| Fallback rate | $\dot M \propto t^{-5/3}$ | `ui/lightCurve.ts` (drawn for comparison) |
 | Peters inspiral | $da/dt = -\tfrac{64}{5} G^3 m_1m_2(m_1{+}m_2)/c^5a^3$ | `sim/binary.ts` |
 | Radiated mass | $E_{\text{rad}} \approx 0.048 M_{\text{tot}}\,\eta/0.25$ | `sim/binary.ts` |
 | Flamm's paraboloid | $z = 2\sqrt{r_s(r - r_s)}$ | `render/spacetimeGrid.ts` |
diff --git a/index.html b/index.html
index be72042..b894454 100644
--- a/index.html
+++ b/index.html
@@ -48,12 +48,39 @@
         pointer-events: none;
         white-space: pre;
       }
+      /* The tidal-disruption light curve, drawn by src/ui/lightCurveChart.ts.
+         Visibility is a class, not the hidden attribute: `hidden` is only a
+         display:none at the lowest specificity, and any display: declaration
+         in this rule would silently defeat it. */
+      #light-curve {
+        display: none;
+        position: fixed;
+        right: calc(12px + env(safe-area-inset-right));
+        bottom: calc(12px + env(safe-area-inset-bottom));
+        width: 320px;
+        height: 200px;
+        /* Under the panel, and never a pointer target: a drag that starts on
+           the chart is still a camera move. */
+        z-index: 5;
+        pointer-events: none;
+      }
+      #light-curve.visible {
+        display: block;
+      }
+      #light-curve canvas {
+        display: block;
+        width: 100%;
+        height: 100%;
+        border-radius: 6px;
+      }
       /* Cinematic mode: fade the chrome, leave the render untouched. */
       #hud,
+      #light-curve,
       .lil-gui {
         transition: opacity 260ms ease;
       }
       body.cinematic #hud,
+      body.cinematic #light-curve,
       body.cinematic .lil-gui {
         opacity: 0;
         pointer-events: none;
@@ -176,11 +203,23 @@
         bottom: auto;
         top: calc(76px + env(safe-area-inset-top));
       }
+      /* The readout and the toggle own the top of a phone screen, so the chart
+         goes bottom left, clear of the collapsed sheet title (40px) and of the
+         toggle on the right. Opening the sheet covers it, which is the same
+         deal every other overlay gets. */
+      body.touch-ui #light-curve {
+        right: auto;
+        left: calc(8px + env(safe-area-inset-left));
+        bottom: calc(48px + env(safe-area-inset-bottom));
+        width: min(56vw, 260px);
+        height: 150px;
+      }
     </style>
   </head>
   <body>
     <div id="app"></div>
     <div id="hud"></div>
+    <div id="light-curve"></div>
     <div id="toast"></div>
     <!-- The button shows the action, not the state: an open eye while the
          interface is hidden (tap to bring it back), a struck-through eye while
diff --git a/src/config.ts b/src/config.ts
index 0d5f726..2518334 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -130,6 +130,41 @@ export const DISC_TUNING = {
   boostPerBody: 1.0,
 };
 
+export const LIGHT_CURVE_TUNING = {
+  /**
+   * Sampling period on the *disruption clock* (see the two-clocks note at the
+   * top of this file), so the recorded shape does not change when the
+   * Disruption speed slider does. Two disruption-seconds is fine enough to
+   * resolve the rise and coarse enough that a whole flare fits in the buffer.
+   */
+  sampleInterval: 2.0,
+  /**
+   * 512 samples at that interval is 1024 disruption-seconds, longer than
+   * DEBRIS_TUNING.maxAge, so a single flare plays out without ever having to
+   * decimate. The ring still halves itself if someone leaves one running.
+   */
+  maxSamples: 512,
+  /** Repaint period. The chart is a readout, not an animation. */
+  repaintMs: 100,
+  /** Decades of brightness shown below the peak. Three is where the noise
+   *  floor of the absorbed-particle count takes over. */
+  visibleDecades: 3,
+  /**
+   * The decay fit starts this many peak-times in, past the rise and the
+   * turnover, which are the shape of DISC_TUNING.boostDecayTau rather than of
+   * anything falling back. The fitted number describes the plotted curve and is
+   * not a measurement of the fallback index: at the shipped tuning it comes out
+   * near -7 and tracks tdeTimeCompression, for the reasons written out at the
+   * top of ui/lightCurve.ts.
+   */
+  fitStartFactor: 1.5,
+  /** Ignore samples below this fraction of the peak: down there the boost is
+   *  the exponential tail of the last few absorbed particles. */
+  fitFloorFraction: 0.02,
+  /** Fewer points than this is a slope through noise, so no number is shown. */
+  minFitSamples: 8,
+};
+
 export const PLACEMENT_TUNING = {
   rMin: 7.0,
   rMax: 20.0,
diff --git a/src/main.ts b/src/main.ts
index 4464856..079965f 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -24,6 +24,8 @@ import { clearBody, createWorld, placeBinary, placeBody, resetScene, stepWorld }
 import type { Body } from './sim/types';
 import { CinematicMode, isTypingIntoControl } from './ui/chrome';
 import { touchRenderBudget, usesTouchUi } from './ui/device';
+import { createFlareCurve, recordFeeding, resetFlare, startFlare } from './ui/lightCurve';
+import { LightCurveChart } from './ui/lightCurveChart';
 import { buildPanel } from './ui/panel';
 import type { Preset } from './ui/presets';
 import { PlacementController } from './ui/placement';
@@ -59,6 +61,7 @@ const app = requireElement('app');
 const hud = requireElement('hud');
 const toast = requireElement('toast');
 const chromeToggle = requireElement('chrome-toggle');
+const lightCurveContainer = requireElement('light-curve');
 
 // A finger-driven device gets the touch layout and a smaller render budget,
 // phone or tablet alike. Decided once at boot: a device does not grow a mouse
@@ -96,6 +99,16 @@ pipeline.overlayScene.add(debrisPoints.points);
 const spacetimeGrid = new SpacetimeGrid();
 pipeline.overlayScene.add(spacetimeGrid.lines);
 
+// The light curve records one disruption at a time and repaints itself off the
+// frame loop; the loop only ever feeds it samples. Constructed without a
+// binding because it lives as long as the page does.
+const flareCurve = createFlareCurve();
+new LightCurveChart(lightCurveContainer, () =>
+  settings.lightCurveEnabled
+    ? { curve: flareCurve, showReference: settings.lightCurveFallbackReference }
+    : null,
+);
+
 /** Current effective primary r_s (animated during merger ringdown). */
 function currentRs(): number {
   return displayRs(world.binary, world.primaryRs);
@@ -129,8 +142,14 @@ const placement = new PlacementController(
   pipeline.overlayScene,
   rig.controls,
   (kind, pos) => {
-    if (kind === 'bh2') placeBinary(world, pos);
-    else placeBody(world, kind, pos, settings.tdeMode);
+    if (kind === 'bh2') {
+      placeBinary(world, pos);
+      return;
+    }
+    placeBody(world, kind, pos, settings.tdeMode);
+    // A new body starts a new flare. Sharing one time axis across two
+    // disruptions would put an origin on the chart that neither curve has.
+    resetFlare(flareCurve);
   },
 );
 let aimInfo = '';
@@ -175,6 +194,7 @@ function applyPreset(preset: Preset): void {
   endTour();
   placement.cancel();
   resetScene(world);
+  resetFlare(flareCurve);
   wave = restingWave();
 
   const { sky, ...look } = preset.look;
@@ -417,6 +437,23 @@ function frame(now: number): void {
     mergerNow ||= events.mergerNow;
     shredNow ||= events.shredNow;
     if (events.bodyEscaped) showTransientNote('remnant escaped with the mass it kept');
+    // The light curve's clock starts when the star comes apart and runs on the
+    // disruption clock, so its time axis is unaffected by the speed sliders and
+    // freezes when the sim is paused. The plotted curve still moves with
+    // tdeTimeCompression, because the disc's feeding glow decays on the
+    // simulation clock; that is why the compression at disruption is recorded
+    // and printed. The body can already be gone on the tick it shredded, hence
+    // the fallback to the current mode.
+    if (events.shredNow) {
+      startFlare(flareCurve, {
+        mode: world.body?.mode ?? settings.tdeMode,
+        timeCompression: settings.tdeTimeCompression,
+      });
+    }
+    recordFeeding(flareCurve, {
+      disruptionDt: FIXED_DT * settings.tdeTimeCompression,
+      boost: world.discBoost,
+    });
     // The wave rides the simulation clock, so it freezes when the sim does.
     wave = nextWaveState(
       wave,
diff --git a/src/settings.ts b/src/settings.ts
index c24472d..4e71f83 100644
--- a/src/settings.ts
+++ b/src/settings.ts
@@ -43,6 +43,15 @@ export interface Settings {
   gwTimeCompression: number;
   /** Wall-clock compression of a disruption and its debris (same trick). */
   tdeTimeCompression: number;
+  /**
+   * The tidal-disruption light-curve overlay. The plotted series is the disc's
+   * feeding boost (world.discBoost), not settings.discBrightness: the fallback
+   * law describes the rate matter returns to the hole, and the boost is the
+   * only part of the disc's brightness a disruption drives.
+   */
+  lightCurveEnabled: boolean;
+  /** Draw the anchored t^(-5/3) fallback law next to the recorded curve. */
+  lightCurveFallbackReference: boolean;
   soundEnabled: boolean;
   volume: number;
   sky: SkySettings;
@@ -68,6 +77,9 @@ export function defaultSettings(): Settings {
     tdeMode: 'cinematic',
     gwTimeCompression: BINARY_TUNING.timeCompression,
     tdeTimeCompression: BODY_TUNING.timeCompression,
+    // A readout rather than part of the picture, so it ships off.
+    lightCurveEnabled: false,
+    lightCurveFallbackReference: true,
     soundEnabled: false,
     volume: 0.6,
     sky: {
diff --git a/src/ui/__tests__/fallbackLaw.test.ts b/src/ui/__tests__/fallbackLaw.test.ts
new file mode 100644
index 0000000..7144446
--- /dev/null
+++ b/src/ui/__tests__/fallbackLaw.test.ts
@@ -0,0 +1,159 @@
+/**
+ * End-to-end harness for the light curve: drive real disruptions through
+ * stepWorld with the recorder attached and hold in place what the recorded
+ * shape actually is.
+ *
+ * The feature was asked for on the expectation that t^(-5/3) would emerge from
+ * the simulation. It does not, and these tests say so rather than papering over
+ * it with a band wide enough to swallow the disagreement. The reasons are
+ * written out at the top of ui/lightCurve.ts and in part 11 of docs/THEORY.md;
+ * the third test below is the evidence for the main one.
+ *
+ * Lives next to the recorder rather than in sim/__tests__ because what is under
+ * test is the recorder. It drives the world only because a synthetic curve
+ * would prove nothing about what the simulation feeds it.
+ */
+import { describe, expect, it } from 'vitest';
+import { Vector3 } from 'three';
+import { createWorld, placeBody, stepWorld } from '../../sim/world';
+import { mulberry32 } from '../../sim/__tests__/rng';
+import { LIGHT_CURVE_TUNING } from '../../config';
+import type { TdeMode } from '../../settings';
+import {
+  createFlareCurve,
+  FALLBACK_INDEX,
+  findPeak,
+  fitDecaySlope,
+  recordFeeding,
+  startFlare,
+  type FlareCurve,
+} from '../lightCurve';
+
+const DT = 1 / 60;
+const GW_COMPRESSION = 40;
+/** The clock the app ships with, so these numbers are the ones users see. */
+const SHIPPED_COMPRESSION = 8;
+/**
+ * Every run covers the same span of *disruption* time, so changing the
+ * compression changes the feeding kernel and nothing else about the axis. One
+ * thousand seconds is past the point the last debris is absorbed at every
+ * compression tested, and stays inside the ring's 1024-second capacity, so no
+ * run is decimated.
+ */
+const DISRUPTION_SECONDS = 1000;
+
+interface DisruptionRun {
+  mode: TdeMode;
+  seed: number;
+  timeCompression: number;
+}
+
+/** Place a star and run the sim, recording exactly what main.ts records. */
+function recordDisruption({ mode, seed, timeCompression }: DisruptionRun): FlareCurve {
+  const world = createWorld(16384);
+  const rng = mulberry32(seed);
+  const curve = createFlareCurve();
+  placeBody(world, 'star', new Vector3(14, 0, 0), mode);
+
+  const ticks = Math.round(DISRUPTION_SECONDS / timeCompression / DT);
+  for (let tick = 0; tick < ticks; tick++) {
+    const events = stepWorld(world, DT, rng, GW_COMPRESSION, timeCompression);
+    if (events.shredNow) startFlare(curve, { mode, timeCompression });
+    recordFeeding(curve, { disruptionDt: DT * timeCompression, boost: world.discBoost });
+  }
+  return curve;
+}
+
+function fitWindowSize(curve: FlareCurve): number {
+  const peak = findPeak(curve)!;
+  const startTime = LIGHT_CURVE_TUNING.fitStartFactor * peak.time;
+  const floor = LIGHT_CURVE_TUNING.fitFloorFraction * peak.boost;
+  let n = 0;
+  for (let i = 0; i < curve.count; i++) {
+    if (curve.time[i]! >= startTime && curve.boost[i]! >= floor) n++;
+  }
+  return n;
+}
+
+describe('what the recorded light curve does', () => {
+  it('a realistic disruption records a flare that rises and then decays', () => {
+    const curve = recordDisruption({
+      mode: 'realistic',
+      seed: 20240,
+      timeCompression: SHIPPED_COMPRESSION,
+    });
+    const peak = findPeak(curve)!;
+
+    expect(curve.count).toBeGreaterThan(100);
+    expect(peak.boost).toBeGreaterThan(0.1);
+    // A rise and a fall, not a step: the peak is strictly inside the record.
+    expect(peak.index).toBeGreaterThan(0);
+    expect(peak.index).toBeLessThan(curve.count - 1);
+    expect(curve.boost[curve.count - 1]!).toBeLessThan(0.01 * peak.boost);
+    expect(fitWindowSize(curve)).toBeGreaterThanOrEqual(12);
+  });
+
+  it('that decay is several times steeper than the fallback law', () => {
+    const curve = recordDisruption({
+      mode: 'realistic',
+      seed: 20240,
+      timeCompression: SHIPPED_COMPRESSION,
+    });
+    const slope = fitDecaySlope(curve, findPeak(curve)!)!;
+
+    // Measured at about -7.3, and stable to two digits across seeds and
+    // placement radii. The assertion is deliberately the qualitative claim the
+    // app is allowed to make: the recorded feeding falls off far faster than
+    // bound debris returning on Kepler orbits would, so the reference line on
+    // the chart is there to be disagreed with. The outer bound is a sanity
+    // floor, not a prediction.
+    expect(slope).toBeLessThan(2 * FALLBACK_INDEX);
+    expect(slope).toBeGreaterThan(-12);
+  });
+
+  it('the fitted slope tracks the feeding kernel, not the debris', () => {
+    // Same disruption, same seed, same span of disruption time. The only thing
+    // that changes is settings.tdeTimeCompression, which does not touch a
+    // trajectory: it widens DISC_TUNING.boostDecayTau relative to this axis,
+    // because the boost decays on the simulation clock while the chart is drawn
+    // on the disruption clock. If the plotted decay were the debris returning,
+    // this would move the fit hardly at all. It moves it by more than the
+    // fallback index itself, which is why the caption prints the compression
+    // it recorded at, and why the fitted number is labelled a fit.
+    const fast = fittedSlope({ mode: 'realistic', seed: 20240, timeCompression: 8 });
+    const slow = fittedSlope({ mode: 'realistic', seed: 20240, timeCompression: 30 });
+
+    expect(slow - fast).toBeGreaterThan(2);
+    expect(slow).toBeLessThan(FALLBACK_INDEX);
+  });
+
+  it('a cinematic disruption is recorded, and its near-miss of the law is a coincidence', () => {
+    const curve = recordDisruption({
+      mode: 'cinematic',
+      seed: 991,
+      timeCompression: SHIPPED_COMPRESSION,
+    });
+    const peak = findPeak(curve)!;
+    const slope = fitDecaySlope(curve, peak)!;
+
+    expect(curve.count).toBeGreaterThan(100);
+    expect(peak.boost).toBeGreaterThan(0.1);
+    // About -1.85, which sits close enough to -5/3 to fool someone reading the
+    // caption. It is not agreement: the cinematic spiral has no energy spread
+    // and no fallback at all, it is a drag inspiral, and this number moves with
+    // the Disruption speed slider exactly like the realistic one does. Pinned
+    // here so that resemblance can never be quietly promoted to a claim.
+    expect(slope).toBeLessThan(-1.2);
+    expect(slope).toBeGreaterThan(-2.5);
+  });
+});
+
+/** Run one disruption and fit its decay, which has to produce a number. */
+function fittedSlope(run: DisruptionRun): number {
+  const curve = recordDisruption(run);
+  const peak = findPeak(curve);
+  expect(peak).not.toBeNull();
+  const slope = fitDecaySlope(curve, peak!);
+  expect(slope).not.toBeNull();
+  return slope!;
+}
diff --git a/src/ui/__tests__/lightCurve.test.ts b/src/ui/__tests__/lightCurve.test.ts
new file mode 100644
index 0000000..1bf4cd9
--- /dev/null
+++ b/src/ui/__tests__/lightCurve.test.ts
@@ -0,0 +1,325 @@
+import { describe, expect, it } from 'vitest';
+import { LIGHT_CURVE_TUNING } from '../../config';
+import {
+  axesFor,
+  createFlareCurve,
+  decadeTicks,
+  FALLBACK_INDEX,
+  findPeak,
+  fitDecaySlope,
+  halveResolution,
+  projectPoint,
+  recordFeeding,
+  referenceBoost,
+  referenceEndTime,
+  resetFlare,
+  startFlare,
+  type FlareCurve,
+} from '../lightCurve';
+
+const BOX = { left: 10, top: 5, width: 200, height: 100 };
+
+/** A curve holding exactly these samples, as if they had been recorded. */
+function curveOf(times: readonly number[], boosts: readonly number[]): FlareCurve {
+  const curve = createFlareCurve({ capacity: Math.max(times.length, 1) });
+  startFlare(curve, { mode: 'realistic', timeCompression: 8 });
+  for (let i = 0; i < times.length; i++) {
+    curve.time[i] = times[i]!;
+    curve.boost[i] = boosts[i]!;
+  }
+  curve.count = times.length;
+  return curve;
+}
+
+/** boost = amplitude * (t / tRef)^index, the shape the fit has to recover. */
+function powerLawCurve(index: number, amplitude: number, tRef: number, samples: number): FlareCurve {
+  const times: number[] = [];
+  const boosts: number[] = [];
+  for (let k = 0; k < samples; k++) {
+    const t = tRef * (k + 1);
+    times.push(t);
+    boosts.push(amplitude * Math.pow(t / tRef, index));
+  }
+  return curveOf(times, boosts);
+}
+
+describe('recordFeeding', () => {
+  it('samples on the configured interval', () => {
+    const curve = createFlareCurve({ sampleInterval: 2 });
+    startFlare(curve, { mode: 'realistic', timeCompression: 8 });
+    for (let step = 0; step < 200; step++) recordFeeding(curve, { disruptionDt: 0.5, boost: 1 });
+
+    expect(curve.elapsed).toBeCloseTo(100, 6);
+    expect(curve.count).toBe(50);
+    for (let i = 1; i < curve.count; i++) {
+      expect(curve.time[i]!).toBeGreaterThan(curve.time[i - 1]!);
+      expect(curve.time[i]! - curve.time[i - 1]!).toBeLessThanOrEqual(2 + 0.5);
+    }
+  });
+
+  it('records nothing before a flare starts', () => {
+    const curve = createFlareCurve({ sampleInterval: 2 });
+    for (let step = 0; step < 500; step++) recordFeeding(curve, { disruptionDt: 0.5, boost: 1 });
+
+    expect(curve.count).toBe(0);
+    expect(curve.elapsed).toBe(0);
+    expect(findPeak(curve)).toBeNull();
+  });
+
+  it('never exceeds capacity, and keeps both ends of the record', () => {
+    const capacity = 16;
+    const interval = 1;
+    const curve = createFlareCurve({ capacity, sampleInterval: interval });
+    startFlare(curve, { mode: 'realistic', timeCompression: 8 });
+
+    // Feeding boost = elapsed time, so every stored pair is self-checking.
+    const steps = 4 * capacity * interval * 4;
+    for (let step = 0; step < steps; step++) {
+      recordFeeding(curve, { disruptionDt: 0.25, boost: curve.elapsed + 0.25 });
+    }
+
+    expect(curve.count).toBeLessThanOrEqual(capacity);
+    expect(curve.interval).toBeGreaterThanOrEqual(4 * interval);
+    for (let i = 0; i < curve.count; i++) {
+      expect(curve.boost[i]!).toBeCloseTo(curve.time[i]!, 3);
+      if (i > 0) expect(curve.time[i]!).toBeGreaterThan(curve.time[i - 1]!);
+    }
+    // The newest sample is never the one thrown away: it is still within one
+    // (decimated) interval of now.
+    expect(curve.elapsed - curve.time[curve.count - 1]!).toBeLessThan(curve.interval);
+  });
+});
+
+describe('halveResolution', () => {
+  it('keeps the head and the newest sample of an even-length record', () => {
+    const curve = curveOf([1, 2, 3, 4, 5, 6], [6, 5, 4, 3, 2, 1]);
+    halveResolution(curve);
+
+    expect(curve.count).toBe(3);
+    expect(Array.from(curve.time.slice(0, 3))).toEqual([1, 3, 6]);
+    expect(Array.from(curve.boost.slice(0, 3))).toEqual([6, 4, 1]);
+    expect(curve.interval).toBe(2 * curve.baseInterval);
+  });
+
+  it('keeps the head and the newest sample of an odd-length record', () => {
+    const curve = curveOf([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]);
+    halveResolution(curve);
+
+    expect(curve.count).toBe(3);
+    expect(Array.from(curve.time.slice(0, 3))).toEqual([1, 3, 5]);
+  });
+});
+
+describe('findPeak', () => {
+  it('returns the last index of a saturated plateau', () => {
+    const curve = curveOf([1, 2, 3, 4, 5, 6], [0.5, 2, 2, 2, 1, 0.4]);
+    const peak = findPeak(curve)!;
+
+    expect(peak.boost).toBe(2);
+    expect(peak.time).toBe(4); // the end of the plateau, where the decay starts
+    expect(peak.index).toBe(3);
+  });
+
+  it('returns null with nothing recorded and with nothing positive recorded', () => {
+    expect(findPeak(createFlareCurve())).toBeNull();
+    expect(findPeak(curveOf([1, 2, 3], [0, 0, 0]))).toBeNull();
+  });
+});
+
+describe('referenceBoost', () => {
+  it('is the fallback power law anchored at the peak', () => {
+    const peak = { index: 0, time: 12, boost: 0.8 };
+
+    expect(referenceBoost(peak, 12)).toBeCloseTo(0.8, 12);
+    // 8^(5/3) = 32, so eight peak-times in the law has dropped by 32.
+    expect(referenceBoost(peak, 8 * 12)).toBeCloseTo(0.8 / 32, 12);
+  });
+
+  it('has log-log slope exactly -5/3 between any two points', () => {
+    const peak = { index: 0, time: 3, boost: 1.4 };
+    const a = 7.5;
+    const b = 91.2;
+    const slope =
+      (Math.log(referenceBoost(peak, b)) - Math.log(referenceBoost(peak, a))) /
+      (Math.log(b) - Math.log(a));
+
+    expect(slope).toBeCloseTo(FALLBACK_INDEX, 12);
+  });
+});
+
+describe('referenceEndTime', () => {
+  it('lands exactly on the brightness floor', () => {
+    const peak = { index: 0, time: 9, boost: 1.1 };
+    const floor = 0.0013;
+
+    expect(referenceBoost(peak, referenceEndTime(peak, floor))).toBeCloseTo(floor, 9);
+  });
+
+  it('is later than the peak for any floor below it', () => {
+    const peak = { index: 0, time: 9, boost: 1.1 };
+    expect(referenceEndTime(peak, 0.2)).toBeGreaterThan(peak.time);
+  });
+});
+
+describe('fitDecaySlope', () => {
+  it('recovers a synthetic fallback index', () => {
+    const curve = powerLawCurve(FALLBACK_INDEX, 0.7, 1, 12);
+    const slope = fitDecaySlope(curve, findPeak(curve)!)!;
+
+    expect(slope).toBeCloseTo(FALLBACK_INDEX, 6);
+  });
+
+  it('recovers a flat decay as zero', () => {
+    const times = [1];
+    const boosts = [1];
+    for (let k = 2; k <= 40; k++) {
+      times.push(k);
+      boosts.push(0.5);
+    }
+    const curve = curveOf(times, boosts);
+
+    expect(fitDecaySlope(curve, findPeak(curve)!)!).toBeCloseTo(0, 12);
+  });
+
+  it('ignores the smeared peak the window is set to exclude', () => {
+    const decay = powerLawCurve(FALLBACK_INDEX, 0.7, 1, 12);
+    const clean = fitDecaySlope(decay, findPeak(decay)!)!;
+
+    // Same decay, with a rising limb and a shallow turnover glued in front of
+    // it at times below fitStartFactor * peakTime.
+    const peakTime = 1;
+    const times = [peakTime * 0.4, peakTime * 0.7, peakTime, peakTime * 1.2, peakTime * 1.4];
+    const boosts = [0.2, 0.5, 0.7, 0.69, 0.68];
+    for (let i = 0; i < decay.count; i++) {
+      if (decay.time[i]! <= peakTime * 1.4) continue;
+      times.push(decay.time[i]!);
+      boosts.push(decay.boost[i]!);
+    }
+    const smeared = curveOf(times, boosts);
+    const peak = findPeak(smeared)!;
+    expect(peak.time).toBe(peakTime);
+
+    expect(fitDecaySlope(smeared, peak)!).toBeCloseTo(clean, 6);
+  });
+
+  it('returns null rather than a slope through too few points', () => {
+    const short = powerLawCurve(FALLBACK_INDEX, 0.7, 1, LIGHT_CURVE_TUNING.minFitSamples);
+    expect(fitDecaySlope(short, findPeak(short)!)).toBeNull();
+  });
+
+  it('returns null when every fitted sample shares one time value', () => {
+    const times = [1];
+    const boosts = [1];
+    for (let k = 0; k < LIGHT_CURVE_TUNING.minFitSamples + 1; k++) {
+      times.push(5);
+      boosts.push(0.5);
+    }
+    const curve = curveOf(times, boosts);
+
+    expect(fitDecaySlope(curve, findPeak(curve)!)).toBeNull();
+  });
+});
+
+describe('axesFor', () => {
+  it('brackets every recorded sample with ordered, finite bounds', () => {
+    const curve = powerLawCurve(FALLBACK_INDEX, 0.7, 3, 20);
+    const axes = axesFor(curve, findPeak(curve)!);
+
+    expect(axes.tMin).toBeLessThan(axes.tMax);
+    expect(axes.boostMin).toBeLessThan(axes.boostMax);
+    for (let i = 0; i < curve.count; i++) {
+      expect(curve.time[i]!).toBeGreaterThanOrEqual(axes.tMin);
+      expect(curve.time[i]!).toBeLessThanOrEqual(axes.tMax);
+    }
+    expect(axes.boostMax).toBeGreaterThan(findPeak(curve)!.boost);
+  });
+
+  it('gives a single-sample curve a decade of time headroom', () => {
+    const curve = curveOf([4], [0.5]);
+    const axes = axesFor(curve, findPeak(curve)!);
+
+    expect(Number.isFinite(axes.tMax)).toBe(true);
+    expect(axes.tMax).toBe(40);
+    expect(axes.boostMin).toBeGreaterThan(0);
+    expect(axes.boostMin).toBeLessThan(axes.boostMax);
+  });
+});
+
+describe('projectPoint', () => {
+  const axes = { tMin: 1, tMax: 1000, boostMin: 0.001, boostMax: 1 };
+
+  it('maps the axis corners to the box corners', () => {
+    const bottomLeft = projectPoint(axes, BOX, axes.tMin, axes.boostMin);
+    expect(bottomLeft.x).toBeCloseTo(BOX.left, 9);
+    expect(bottomLeft.y).toBeCloseTo(BOX.top + BOX.height, 9);
+
+    const topRight = projectPoint(axes, BOX, axes.tMax, axes.boostMax);
+    expect(topRight.x).toBeCloseTo(BOX.left + BOX.width, 9);
+    expect(topRight.y).toBeCloseTo(BOX.top, 9);
+  });
+
+  it('moves right with time and up with brightness', () => {
+    const early = projectPoint(axes, BOX, 3, 0.1);
+    const late = projectPoint(axes, BOX, 300, 0.1);
+    expect(late.x).toBeGreaterThan(early.x);
+
+    const dim = projectPoint(axes, BOX, 30, 0.01);
+    const bright = projectPoint(axes, BOX, 30, 0.5);
+    expect(bright.y).toBeLessThan(dim.y);
+  });
+
+  it('clamps anything outside the axes into the box', () => {
+    for (const [t, boost] of [
+      [1e-6, 1e-9],
+      [1e9, 1e6],
+      [0, 0],
+    ] as const) {
+      const point = projectPoint(axes, BOX, t, boost);
+      expect(point.x).toBeGreaterThanOrEqual(BOX.left);
+      expect(point.x).toBeLessThanOrEqual(BOX.left + BOX.width);
+      expect(point.y).toBeGreaterThanOrEqual(BOX.top);
+      expect(point.y).toBeLessThanOrEqual(BOX.top + BOX.height);
+    }
+  });
+});
+
+describe('decadeTicks', () => {
+  it('returns the powers of ten inside the range', () => {
+    expect(decadeTicks(0.5, 120)).toEqual([1, 10, 100]);
+    for (const tick of decadeTicks(0.5, 120)) {
+      expect(tick).toBeGreaterThanOrEqual(0.5);
+      expect(tick).toBeLessThanOrEqual(120);
+    }
+  });
+
+  it('returns nothing when the range spans no decade boundary', () => {
+    expect(decadeTicks(2, 9)).toEqual([]);
+  });
+
+  it('returns nothing for a degenerate or non-positive range', () => {
+    expect(decadeTicks(0, 100)).toEqual([]);
+    expect(decadeTicks(-5, 100)).toEqual([]);
+    expect(decadeTicks(100, 100)).toEqual([]);
+  });
+});
+
+describe('resetFlare', () => {
+  it('clears the record and restores the shipped sampling interval', () => {
+    const curve = createFlareCurve({ capacity: 8, sampleInterval: 1 });
+    startFlare(curve, { mode: 'realistic', timeCompression: 8 });
+    for (let step = 0; step < 400; step++) {
+      recordFeeding(curve, { disruptionDt: 0.25, boost: 1 });
+    }
+    expect(curve.interval).toBeGreaterThan(curve.baseInterval);
+
+    resetFlare(curve);
+
+    expect(curve.count).toBe(0);
+    expect(curve.elapsed).toBe(0);
+    expect(curve.lastSampleAt).toBe(0);
+    expect(curve.recording).toBe(false);
+    expect(curve.mode).toBeNull();
+    expect(curve.interval).toBe(curve.baseInterval);
+    expect(findPeak(curve)).toBeNull();
+  });
+});
diff --git a/src/ui/lightCurve.ts b/src/ui/lightCurve.ts
new file mode 100644
index 0000000..dfa7a63
--- /dev/null
+++ b/src/ui/lightCurve.ts
@@ -0,0 +1,352 @@
+/**
+ * The tidal-disruption light curve: a fixed-capacity recording of how hard the
+ * disruption is feeding the disc, plus the log-log projection maths the chart
+ * draws with. Pure CPU state and arithmetic, no DOM and no WebGL, so every
+ * function here is unit tested directly.
+ *
+ * ## Where t^(-5/3) comes from
+ *
+ * When a star is torn apart the debris leaves with a spread of orbital
+ * energies (Part 11 of docs/THEORY.md). Take that spread to be flat across the
+ * star, so equal masses of debris occupy equal slices of binding energy:
+ *
+ *     dM/d|eps| = const
+ *
+ * A bound fragment with binding energy |eps| is on a Kepler ellipse of
+ * semi-major axis a = GM / (2|eps|), and Kepler's third law gives its return
+ * period:
+ *
+ *     T = 2*pi * sqrt(a^3 / GM) = 2*pi * GM * (2|eps|)^(-3/2)
+ *
+ * Invert that to ask which fragments are arriving at time t:
+ *
+ *     |eps|(t) = (1/2) * (2*pi*GM / t)^(2/3)
+ *
+ * The fallback rate is then the chain rule, and the constant energy density
+ * drops straight out of the front:
+ *
+ *     dM/dt = (dM/d|eps|) * |d|eps|/dt| = (dM/d|eps|) * (1/3) * (2*pi*GM)^(2/3) * t^(-5/3)
+ *
+ * so dM/dt ~ t^(-5/3) (Rees, 1988). Only the exponent survives the algebra,
+ * which is why it is the signature real surveys hunt for, and why FALLBACK_INDEX
+ * below is an exact rational and not a tuned number.
+ *
+ * ## The app does not reproduce this law, and the chart says so
+ *
+ * This was measured, not assumed (src/ui/__tests__/fallbackLaw.test.ts). A
+ * realistic-mode star disruption at the shipped clock records a decay of about
+ * t^(-7.3), four times steeper than the law, and the fitted index moves with
+ * the Disruption speed slider (about -12.5 at compression 4, -3.3 at 30) while
+ * being all but independent of the seed and the placement radius. That is the
+ * signature of the app's own machinery, not of the debris:
+ *
+ * - `world.discBoost` is not the fallback rate. It is the absorbed-particle
+ *   rate convolved with the exponential feeding kernel in sim/disc.ts, whose
+ *   width on this chart's axis is DISC_TUNING.boostDecayTau multiplied by
+ *   settings.tdeTimeCompression. Once the last particle is absorbed the curve
+ *   is that kernel and nothing else, and an exponential in log-log steepens
+ *   without bound. Hence the slider dependence.
+ * - The debris is not left to return on its own orbits either. DEBRIS_TUNING
+ *   drag circularizes it on a fixed timescale, so the bound half is absorbed
+ *   within roughly one factor of two in time instead of spreading over the
+ *   decades a real energy distribution would, and DEBRIS_TUNING.maxAge kills
+ *   the longest-period material, which is exactly what would have made the
+ *   late-time tail.
+ * - Cinematic mode fits close to -1.85 at the shipped clock. That is a
+ *   coincidence of kernel width, not agreement: the cinematic spiral is a drag
+ *   inspiral with no energy spread at all, and its fitted index moves with the
+ *   same slider.
+ *
+ * So the reference line is drawn anchored at the recorded peak and never fitted
+ * to the data, and the caption prints the fitted index next to the law's. The
+ * honest claim for this overlay is "here is what the simulation's feeding
+ * actually does, next to what nature does", not "the law emerges".
+ */
+
+import { LIGHT_CURVE_TUNING } from '../config';
+import type { TdeMode } from '../settings';
+
+/** dM/dt ~ t^(-5/3): the fallback exponent derived in the header. */
+export const FALLBACK_INDEX = -5 / 3;
+
+/**
+ * A recording of one disruption. Times are in disruption-clock seconds since
+ * the star came apart (see BODY_TUNING.timeCompression), so the time axis is
+ * unaffected by the Disruption speed slider and by the simulation speed, and
+ * freezes when the simulation is paused. The recorded brightness still moves
+ * with the compression, which is why it is stored: see the header.
+ */
+export interface FlareCurve {
+  /** Sample times, strictly increasing, in disruption-clock seconds. */
+  readonly time: Float32Array;
+  /** Disc feeding boost at each sample time. */
+  readonly boost: Float32Array;
+  count: number;
+  readonly capacity: number;
+  /** Shipped sampling period, restored by resetFlare after a decimation. */
+  readonly baseInterval: number;
+  /** Current sampling period; doubles every time the record is decimated. */
+  interval: number;
+  /** Disruption-clock seconds since the flare started. */
+  elapsed: number;
+  lastSampleAt: number;
+  recording: boolean;
+  /** Disruption mode this flare was recorded in, for the chart's readout. */
+  mode: TdeMode | null;
+  /** Clock compression at the moment of disruption, also for the readout. */
+  timeCompression: number;
+}
+
+export interface FlarePeak {
+  index: number;
+  time: number;
+  boost: number;
+}
+
+/** Log-log bounds of a plot, all four strictly positive. */
+export interface LogAxes {
+  tMin: number;
+  tMax: number;
+  boostMin: number;
+  boostMax: number;
+}
+
+/** Pixel rectangle the curve is drawn into, y measured downward. */
+export interface PlotBox {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+export interface PlotPoint {
+  x: number;
+  y: number;
+}
+
+export interface FlareCurveOptions {
+  capacity?: number;
+  sampleInterval?: number;
+}
+
+export function createFlareCurve({
+  capacity = LIGHT_CURVE_TUNING.maxSamples,
+  sampleInterval = LIGHT_CURVE_TUNING.sampleInterval,
+}: FlareCurveOptions = {}): FlareCurve {
+  return {
+    time: new Float32Array(capacity),
+    boost: new Float32Array(capacity),
+    count: 0,
+    capacity,
+    baseInterval: sampleInterval,
+    interval: sampleInterval,
+    elapsed: 0,
+    lastSampleAt: 0,
+    recording: false,
+    mode: null,
+    timeCompression: 0,
+  };
+}
+
+/**
+ * Forget the recording and stop sampling. The sample arrays keep their stale
+ * contents on purpose: `count` is the only thing that says what is real, and
+ * zeroing 4 KB would buy nothing.
+ */
+export function resetFlare(curve: FlareCurve): void {
+  curve.count = 0;
+  curve.interval = curve.baseInterval;
+  curve.elapsed = 0;
+  curve.lastSampleAt = 0;
+  curve.recording = false;
+  curve.mode = null;
+  curve.timeCompression = 0;
+}
+
+export interface FlareStart {
+  mode: TdeMode;
+  /** settings.tdeTimeCompression when the star came apart. */
+  timeCompression: number;
+}
+
+/** Start the clock at the moment the star comes apart (WorldEvents.shredNow). */
+export function startFlare(curve: FlareCurve, { mode, timeCompression }: FlareStart): void {
+  resetFlare(curve);
+  curve.recording = true;
+  curve.mode = mode;
+  curve.timeCompression = timeCompression;
+}
+
+export interface FeedingSample {
+  /** Disruption-clock seconds advanced by this tick. */
+  disruptionDt: number;
+  /** world.discBoost after the tick. */
+  boost: number;
+}
+
+/**
+ * Advance the disruption clock and, at most once per sampling interval, store
+ * the current feeding boost. Called from the fixed-step loop, so it stays an
+ * add, a compare and two typed-array writes.
+ */
+export function recordFeeding(curve: FlareCurve, { disruptionDt, boost }: FeedingSample): void {
+  if (!curve.recording) return;
+  curve.elapsed += disruptionDt;
+  if (curve.elapsed - curve.lastSampleAt < curve.interval) return;
+
+  if (curve.count === curve.capacity) halveResolution(curve);
+  curve.time[curve.count] = curve.elapsed;
+  curve.boost[curve.count] = boost;
+  curve.count += 1;
+  curve.lastSampleAt = curve.elapsed;
+}
+
+/**
+ * Throw away every other sample and double the sampling period, so a flare
+ * that outlives the buffer degrades in resolution instead of in span. The
+ * newest sample is written over the last kept slot when the count is even,
+ * because losing the leading edge of the curve would make the chart lag the
+ * scene by up to one interval.
+ */
+export function halveResolution(curve: FlareCurve): void {
+  const kept = Math.ceil(curve.count / 2);
+  for (let i = 0; i < kept; i++) {
+    curve.time[i] = curve.time[2 * i]!;
+    curve.boost[i] = curve.boost[2 * i]!;
+  }
+  if (curve.count % 2 === 0) {
+    curve.time[kept - 1] = curve.time[curve.count - 1]!;
+    curve.boost[kept - 1] = curve.boost[curve.count - 1]!;
+  }
+  curve.count = kept;
+  curve.interval *= 2;
+}
+
+/**
+ * The brightest recorded sample, taking the LAST index that attains it: the
+ * boost saturates at DISC_TUNING.boostMax, so a tie is a plateau and the decay
+ * starts at its right-hand end. Null until something positive is recorded,
+ * since a peak of zero has no logarithm and nothing to anchor a law to.
+ */
+export function findPeak(curve: FlareCurve): FlarePeak | null {
+  let index = -1;
+  let best = 0;
+  for (let i = 0; i < curve.count; i++) {
+    const boost = curve.boost[i]!;
+    if (boost >= best && boost > 0) {
+      best = boost;
+      index = i;
+    }
+  }
+  if (index < 0) return null;
+  return { index, time: curve.time[index]!, boost: best };
+}
+
+/** The fallback law anchored at the recorded peak, never fitted to it. */
+export function referenceBoost(peak: FlarePeak, t: number): number {
+  return peak.boost * Math.pow(t / peak.time, FALLBACK_INDEX);
+}
+
+/**
+ * Where the anchored law crosses a given brightness floor. The reference is
+ * drawn as a single straight log-log segment, so ending it exactly on the axis
+ * floor beats clamping a point that has already fallen off the bottom.
+ */
+export function referenceEndTime(peak: FlarePeak, boostFloor: number): number {
+  return peak.time * Math.pow(peak.boost / boostFloor, 1 / -FALLBACK_INDEX);
+}
+
+/**
+ * Least-squares slope of log(boost) against log(t) over the decay only, so the
+ * chart can print what the recorded curve actually does next to what the law
+ * says. It is a description of the plotted series, not a measurement of the
+ * fallback index: see the header for why those are not the same thing here.
+ *
+ * The window starts past the peak because the rise and the turnover are the
+ * feeding kernel's shape, and stops at a fraction of the peak because down
+ * there the boost is the exponential tail of the last few absorbed particles.
+ * Returns null rather than a meaningless number when too few samples survive
+ * the window or when they all share one time value.
+ */
+export function fitDecaySlope(curve: FlareCurve, peak: FlarePeak): number | null {
+  const startTime = LIGHT_CURVE_TUNING.fitStartFactor * peak.time;
+  const floor = LIGHT_CURVE_TUNING.fitFloorFraction * peak.boost;
+
+  let n = 0;
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < curve.count; i++) {
+    const t = curve.time[i]!;
+    const boost = curve.boost[i]!;
+    if (t < startTime || boost < floor || t <= 0 || boost <= 0) continue;
+    sumX += Math.log(t);
+    sumY += Math.log(boost);
+    n += 1;
+  }
+  if (n < LIGHT_CURVE_TUNING.minFitSamples) return null;
+
+  const meanX = sumX / n;
+  const meanY = sumY / n;
+  let covariance = 0;
+  let varianceX = 0;
+  for (let i = 0; i < curve.count; i++) {
+    const t = curve.time[i]!;
+    const boost = curve.boost[i]!;
+    if (t < startTime || boost < floor || t <= 0 || boost <= 0) continue;
+    const dx = Math.log(t) - meanX;
+    covariance += dx * (Math.log(boost) - meanY);
+    varianceX += dx * dx;
+  }
+  if (varianceX < 1e-9) return null;
+  return covariance / varianceX;
+}
+
+/**
+ * Log-log bounds for the recorded curve. The time axis is given at least one
+ * decade so a curve that has just started is not drawn on a degenerate axis,
+ * and the brightness axis shows a fixed number of decades below the peak so the
+ * plot does not rescale under its own noise floor.
+ */
+export function axesFor(curve: FlareCurve, peak: FlarePeak): LogAxes {
+  const tMin = curve.time[0]!;
+  const tMax = Math.max(curve.time[curve.count - 1]!, tMin * 10);
+  const boostMax = peak.boost * 1.3;
+  return {
+    tMin,
+    tMax,
+    boostMin: boostMax * Math.pow(10, -LIGHT_CURVE_TUNING.visibleDecades),
+    boostMax,
+  };
+}
+
+function clamp01(value: number): number {
+  if (!(value > 0)) return 0; // also catches NaN and -Infinity from log(0)
+  return value < 1 ? value : 1;
+}
+
+/** Place one (t, boost) pair inside the plot box, clamping to its edges. */
+export function projectPoint(
+  axes: LogAxes,
+  box: PlotBox,
+  t: number,
+  boost: number,
+): PlotPoint {
+  const u = (Math.log(t) - Math.log(axes.tMin)) / (Math.log(axes.tMax) - Math.log(axes.tMin));
+  const v =
+    (Math.log(boost) - Math.log(axes.boostMin)) /
+    (Math.log(axes.boostMax) - Math.log(axes.boostMin));
+  return {
+    x: box.left + box.width * clamp01(u),
+    y: box.top + box.height * (1 - clamp01(v)),
+  };
+}
+
+/** Powers of ten inside [min, max]: the only gridlines a log axis should have. */
+export function decadeTicks(min: number, max: number): number[] {
+  if (!(min > 0) || !(max > min)) return [];
+  const ticks: number[] = [];
+  for (let k = Math.ceil(Math.log10(min)); k <= Math.floor(Math.log10(max)); k++) {
+    ticks.push(Math.pow(10, k));
+  }
+  return ticks;
+}
diff --git a/src/ui/lightCurveChart.ts b/src/ui/lightCurveChart.ts
new file mode 100644
index 0000000..4fc6a38
--- /dev/null
+++ b/src/ui/lightCurveChart.ts
@@ -0,0 +1,278 @@
+/**
+ * The light-curve overlay: a small 2D canvas that plots the disc's feeding
+ * boost against time since the star came apart, on log-log axes.
+ *
+ * Deliberately not part of the render pipeline. Drawing it into
+ * pipeline.overlayScene would push it through bloom and the camera-tour fade,
+ * cost a draw call inside the raymarch pass, and leave us hand-rolling text on
+ * a WebGL surface. A plain canvas on top of the app costs nothing the frame
+ * loop can feel.
+ *
+ * It also repaints on its own timer rather than in frame(): a readout that
+ * updates ten times a second is more legible than one that updates sixty, and
+ * the frame loop stays free of chart work. All the maths lives in
+ * ui/lightCurve.ts; this file only draws.
+ */
+
+import { LIGHT_CURVE_TUNING } from '../config';
+import {
+  axesFor,
+  decadeTicks,
+  FALLBACK_INDEX,
+  findPeak,
+  fitDecaySlope,
+  projectPoint,
+  referenceBoost,
+  referenceEndTime,
+  type FlareCurve,
+  type FlarePeak,
+  type LogAxes,
+  type PlotBox,
+} from './lightCurve';
+
+/** What the chart should show right now, or null to hide it entirely. */
+export interface LightCurveView {
+  curve: FlareCurve;
+  showReference: boolean;
+}
+
+const COLORS = {
+  panel: 'rgba(10, 12, 22, 0.62)',
+  border: 'rgba(159, 216, 232, 0.18)',
+  grid: 'rgba(159, 216, 232, 0.14)',
+  label: 'rgba(159, 216, 232, 0.72)',
+  curve: '#ffd9a0',
+  reference: 'rgba(120, 200, 235, 0.85)',
+};
+
+const FONT = '10px ui-monospace, SFMono-Regular, Menlo, monospace';
+/**
+ * Room for the brightness labels on the left, the caption above, and the time
+ * labels plus the axis name below.
+ */
+const MARGIN = { left: 36, right: 10, top: 18, bottom: 28 };
+
+/** 0.001 rather than 0.001000000001: a tick label, not a measurement. */
+function formatDecade(value: number): string {
+  const exponent = Math.round(Math.log10(value));
+  return exponent >= 0 ? String(Math.round(value)) : value.toFixed(-exponent);
+}
+
+/** Short enough that the caption still fits the phone width beside the mode. */
+function formatSlope(slope: number | null): string {
+  return slope === null ? 'pending' : slope.toFixed(2);
+}
+
+export class LightCurveChart {
+  private readonly canvas: HTMLCanvasElement;
+  private readonly context: CanvasRenderingContext2D;
+  private readonly timer: number;
+  /** What was last drawn, so a steady chart costs one string compare. */
+  private lastDrawn = '';
+
+  constructor(
+    private readonly container: HTMLElement,
+    private readonly readView: () => LightCurveView | null,
+  ) {
+    this.canvas = document.createElement('canvas');
+    this.canvas.setAttribute('role', 'img');
+    this.canvas.setAttribute('aria-label', 'Disruption light curve, nothing recorded yet');
+    const context = this.canvas.getContext('2d');
+    if (!context) throw new Error('light curve needs a 2D canvas context');
+    this.context = context;
+    this.container.appendChild(this.canvas);
+    this.timer = window.setInterval(() => this.repaint(), LIGHT_CURVE_TUNING.repaintMs);
+  }
+
+  /** Stop the repaint timer. The page never does; tests and HMR do. */
+  dispose(): void {
+    window.clearInterval(this.timer);
+    this.canvas.remove();
+  }
+
+  private repaint(): void {
+    const view = this.readView();
+    if (!view) {
+      this.container.classList.remove('visible');
+      this.lastDrawn = '';
+      return;
+    }
+    // Sized after the class is set: the container is display:none until then,
+    // so measuring it first would give zero.
+    this.container.classList.add('visible');
+
+    const cssWidth = this.container.clientWidth;
+    const cssHeight = this.container.clientHeight;
+    if (cssWidth < 1 || cssHeight < 1) return;
+
+    const peak = findPeak(view.curve);
+    const signature = [
+      view.curve.count,
+      peak?.index ?? -1,
+      view.showReference,
+      cssWidth,
+      cssHeight,
+    ].join('|');
+    if (signature === this.lastDrawn) return;
+    this.lastDrawn = signature;
+
+    // Capped at 2: a 3x phone would otherwise fill 780x450 device pixels of 2D
+    // work ten times a second on the thread that submits the WebGL frame.
+    const ratio = Math.min(window.devicePixelRatio || 1, 2);
+    const deviceWidth = Math.round(cssWidth * ratio);
+    const deviceHeight = Math.round(cssHeight * ratio);
+    if (this.canvas.width !== deviceWidth || this.canvas.height !== deviceHeight) {
+      this.canvas.width = deviceWidth;
+      this.canvas.height = deviceHeight;
+    }
+    this.context.setTransform(ratio, 0, 0, ratio, 0, 0);
+    this.draw(view, peak, cssWidth, cssHeight);
+  }
+
+  private draw(
+    view: LightCurveView,
+    peak: FlarePeak | null,
+    width: number,
+    height: number,
+  ): void {
+    const ctx = this.context;
+    ctx.clearRect(0, 0, width, height);
+    ctx.fillStyle = COLORS.panel;
+    ctx.strokeStyle = COLORS.border;
+    ctx.lineWidth = 1;
+    ctx.fillRect(0.5, 0.5, width - 1, height - 1);
+    ctx.strokeRect(0.5, 0.5, width - 1, height - 1);
+    ctx.font = FONT;
+    ctx.textBaseline = 'middle';
+
+    if (!peak) {
+      ctx.fillStyle = COLORS.label;
+      ctx.textAlign = 'center';
+      ctx.fillText('waiting for a disruption', width / 2, height / 2);
+      this.canvas.setAttribute('aria-label', 'Disruption light curve, nothing recorded yet');
+      return;
+    }
+
+    const box: PlotBox = {
+      left: MARGIN.left,
+      top: MARGIN.top,
+      width: Math.max(width - MARGIN.left - MARGIN.right, 1),
+      height: Math.max(height - MARGIN.top - MARGIN.bottom, 1),
+    };
+    const axes = axesFor(view.curve, peak);
+    this.drawGrid(axes, box);
+    if (view.showReference) this.drawReference(axes, box, peak);
+    this.drawCurve(view.curve, axes, box);
+
+    const slope = fitDecaySlope(view.curve, peak);
+    this.drawCaption(view.curve, box, slope);
+    const decay =
+      slope === null
+        ? 'decay not yet fitted'
+        : `fitted log-log decay slope ${slope.toFixed(2)} against a fallback law of ${FALLBACK_INDEX.toFixed(2)}`;
+    this.canvas.setAttribute(
+      'aria-label',
+      `Disruption light curve, ${view.curve.count} samples, peak feeding boost ${peak.boost.toFixed(2)}, ${decay}`,
+    );
+  }
+
+  private drawGrid(axes: LogAxes, box: PlotBox): void {
+    const ctx = this.context;
+    ctx.strokeStyle = COLORS.grid;
+    ctx.fillStyle = COLORS.label;
+    ctx.beginPath();
+    ctx.rect(box.left + 0.5, box.top + 0.5, box.width, box.height);
+    ctx.stroke();
+
+    ctx.textAlign = 'right';
+    for (const tick of decadeTicks(axes.boostMin, axes.boostMax)) {
+      const { y } = projectPoint(axes, box, axes.tMin, tick);
+      ctx.beginPath();
+      ctx.moveTo(box.left, Math.round(y) + 0.5);
+      ctx.lineTo(box.left + box.width, Math.round(y) + 0.5);
+      ctx.stroke();
+      ctx.fillText(formatDecade(tick), box.left - 4, y);
+    }
+
+    ctx.textAlign = 'center';
+    for (const tick of decadeTicks(axes.tMin, axes.tMax)) {
+      const { x } = projectPoint(axes, box, tick, axes.boostMax);
+      ctx.beginPath();
+      ctx.moveTo(Math.round(x) + 0.5, box.top);
+      ctx.lineTo(Math.round(x) + 0.5, box.top + box.height);
+      ctx.stroke();
+      // Nudged off the ends so a wide label ("1000") stays on the canvas: the
+      // last decade tick usually lands on the right edge of the box.
+      const labelX = Math.min(Math.max(x, box.left + 14), box.left + box.width - 14);
+      ctx.fillText(formatDecade(tick), labelX, box.top + box.height + 8);
+    }
+
+    ctx.fillText('t (disruption s)', box.left + box.width / 2, box.top + box.height + 20);
+    // The brightness axis is named inside the box: naming it on the left would
+    // cost another 12px of a chart that is 260px wide on a phone.
+    ctx.textAlign = 'left';
+    ctx.fillText('disc boost', box.left + 4, box.top + 8);
+  }
+
+  /**
+   * One straight segment from the peak to wherever the law crosses the floor
+   * of the brightness axis. Anchored at the peak, never fitted, so if the
+   * recorded curve disagrees with the law the gap is on screen.
+   */
+  private drawReference(axes: LogAxes, box: PlotBox, peak: FlarePeak): void {
+    const end = Math.min(referenceEndTime(peak, axes.boostMin), axes.tMax);
+    if (!(end > peak.time)) return;
+
+    const from = projectPoint(axes, box, peak.time, peak.boost);
+    const to = projectPoint(axes, box, end, referenceBoost(peak, end));
+    const ctx = this.context;
+    ctx.save();
+    ctx.strokeStyle = COLORS.reference;
+    ctx.setLineDash([4, 3]);
+    ctx.beginPath();
+    ctx.moveTo(from.x, from.y);
+    ctx.lineTo(to.x, to.y);
+    ctx.stroke();
+    ctx.restore();
+  }
+
+  private drawCurve(curve: FlareCurve, axes: LogAxes, box: PlotBox): void {
+    const ctx = this.context;
+    ctx.save();
+    ctx.beginPath();
+    ctx.rect(box.left, box.top, box.width, box.height);
+    ctx.clip();
+    ctx.strokeStyle = COLORS.curve;
+    ctx.lineWidth = 1.5;
+    ctx.lineJoin = 'round';
+    ctx.beginPath();
+    for (let i = 0; i < curve.count; i++) {
+      const point = projectPoint(axes, box, curve.time[i]!, curve.boost[i]!);
+      if (i === 0) ctx.moveTo(point.x, point.y);
+      else ctx.lineTo(point.x, point.y);
+    }
+    ctx.stroke();
+    ctx.restore();
+  }
+
+  /**
+   * Both numbers, side by side, because they disagree and the chart must not
+   * hide that. The compression shown is the one recorded at disruption: it sets
+   * the width of the feeding kernel relative to this time axis, and it is the
+   * single strongest influence on the fitted slope. Moving the slider mid-flare
+   * changes that and the caption cannot show it.
+   */
+  private drawCaption(curve: FlareCurve, box: PlotBox, slope: number | null): void {
+    const ctx = this.context;
+    const recorded = curve.mode ? `${curve.mode} x${curve.timeCompression.toFixed(0)}` : 'idle';
+    ctx.fillStyle = COLORS.label;
+    ctx.textAlign = 'left';
+    ctx.fillText(recorded, box.left, box.top - 9);
+    ctx.textAlign = 'right';
+    ctx.fillText(
+      `fit ${formatSlope(slope)} · law ${FALLBACK_INDEX.toFixed(2)}`,
+      box.left + box.width,
+      box.top - 9,
+    );
+  }
+}
diff --git a/src/ui/panel.ts b/src/ui/panel.ts
index f303a87..57acc30 100644
--- a/src/ui/panel.ts
+++ b/src/ui/panel.ts
@@ -210,6 +210,20 @@ export function buildPanel(
   );
   disc.close();
 
+  // Straight after the disc, because what it plots is that disc being fed.
+  // Neither control needs an onChange: the chart reads settings on its own
+  // repaint tick.
+  const lightCurve = gui.addFolder('Light curve');
+  explain(
+    lightCurve.add(settings, 'lightCurveEnabled').name('Show'),
+    'Plots how hard the disruption is feeding the disc against time since the star came apart. Both axes are logarithmic, so a power law is a straight line. It is a readout rather than part of the picture, which is why it ships off.',
+  );
+  explain(
+    lightCurve.add(settings, 'lightCurveFallbackReference').name('Reference law (t^-5/3)'),
+    'Draws the classic fallback law through the peak of the recorded curve: bound debris returns at a rate proportional to t^(-5/3), which is how real tidal disruption flares are identified. It is anchored at the peak and never fitted, because this simulation does not reproduce the law and the gap is the interesting part. Its debris is dragged into the disc on a fixed timescale instead of returning on its own orbits, and the feeding glow has a decay time of its own, so the recorded curve falls off several times faster and its slope moves with the Disruption speed slider. See part 11 of docs/THEORY.md.',
+  );
+  lightCurve.close();
+
   const jet = gui.addFolder('Relativistic jet');
   explain(
     jet.add(settings, 'jetEnabled').name('Show'),

From c86b1171995e78f6da6d6abd6372828fa8c30702 Mon Sep 17 00:00:00 2001
From: Ashish Nagar <ashishnagar31@gmail.com>
Date: Fri, 31 Jul 2026 15:56:01 -0400
Subject: [PATCH 2/4] Add an infalling beacon that freezes at the horizon

Every other object in this app falls all the way in. That hides the one
thing about a black hole that nothing else demonstrates: the horizon is a
statement about clocks, not a surface. A probe released from rest reddens,
dims by nine decades and stalls just outside the shadow for us, while on
its own clock it crosses in a finite 28 r_s/c and notices nothing. Both
readings are shown side by side, because either one alone is a lie.

The probe is the only moving object here on exact Schwarzschild motion
rather than Paczynski-Wiita. PW has no coordinate-time divergence at all
and its matter crosses r_s in finite time, so reusing sim/gravity.ts would
have made the headline effect impossible to show. The integrated state is
the horizon gap rather than the radius, because an exponential decay stored
as a difference of two order-one numbers stops being physics and starts
being rounding at 1e-16.

Two things the plan for this did not survive contact with:

The coordinate-time ODE has a square-root fixed point at the release
radius, where dr/dt is exactly zero, so a midpoint scheme on the radius
alone parks the probe at r0 forever. The local speed is advanced alongside
it, which leaves zero at a finite rate and reproduces the analytic
short-time law exactly on the first step.

The redshift is stated as sqrt(1 - r_s/r) times the recession Doppler and a
test holds it to that, but it cannot be evaluated that way: the local speed
reaches 1.0 in float64 at a gap of 1e-17 and the Doppler factor then
collapses to zero, taking the last decade of the fade with it. The
algebraically identical f / (E + sqrt(E^2 - f)) is what runs.

The probe is drawn in the overlay pass rather than inside the raymarch, so
it is not truly lensed. It is placed at the apparent image radius instead,
floored at b_crit, which keeps it hugging the photon ring rather than
sinking into the shadow where the horizon mask would swallow it. Honest
about that in beacon.ts and in the new THEORY.md section.

stepWorld's trailing clock arguments became a named SimClocks object rather
than growing a sixth positional number nobody could read at the call site.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 README.md                                 |   3 +-
 docs/THEORY.md                            | 159 +++++++++--
 src/config.ts                             |  44 ++-
 src/main.ts                               |  96 ++++++-
 src/render/beaconPoint.ts                 |  96 +++++++
 src/render/shaders/beacon.frag            |  47 ++++
 src/render/shaders/beacon.vert            |  20 ++
 src/settings.ts                           |   8 +-
 src/sim/__tests__/beacon.test.ts          | 263 ++++++++++++++++++
 src/sim/__tests__/binary.test.ts          |   2 +-
 src/sim/__tests__/disruptionClock.test.ts |   2 +-
 src/sim/__tests__/stream.test.ts          |   2 +-
 src/sim/__tests__/world.test.ts           |  11 +-
 src/sim/beacon.ts                         | 322 ++++++++++++++++++++++
 src/sim/types.ts                          |  36 +++
 src/sim/world.ts                          |  99 ++++++-
 src/ui/panel.ts                           |  31 ++-
 src/ui/placement.ts                       |  40 ++-
 src/ui/presets.ts                         |  26 ++
 19 files changed, 1249 insertions(+), 58 deletions(-)
 create mode 100644 src/render/beaconPoint.ts
 create mode 100644 src/render/shaders/beacon.frag
 create mode 100644 src/render/shaders/beacon.vert
 create mode 100644 src/sim/__tests__/beacon.test.ts
 create mode 100644 src/sim/beacon.ts

diff --git a/README.md b/README.md
index 05181eb..4e7b53e 100644
--- a/README.md
+++ b/README.md
@@ -29,12 +29,13 @@ Everything runs in the browser. No backend, no textures, no libraries beyond Thr
 - **Accretion disc**: Shakura–Sunyaev temperature profile, differential-rotation noise that shears into trailing spirals, relativistic Doppler + gravitational redshift using the bent photon direction (correct even for the lensed secondary image).
 - **Interactive photon trajectories**: click to launch fans of photons; escaped, captured, and near-critical rays are drawn as glowing curves computed by the same integrator the shader uses.
 - **Tidal disruption**: place a planet or star. *Cinematic* mode gives a directable inward spiral with spaghettification and a debris stream that feeds and brightens the disc. *Realistic TDE* mode launches a true zero-energy parabolic plunge, one violent shredding at pericenter, and a physically motivated bound/unbound debris split (roughly half the debris escapes, as in real TDEs).
+- **Infalling beacon**: drop a probe from rest and watch it freeze. It reddens, dims by nine decades and stalls just outside the shadow, because the coordinate time to reach the horizon diverges and the gap decays as e^(-t/rₛ). Exact Schwarzschild radial free fall, not the pseudo-Newtonian potential the debris uses, since that one has no such divergence. The readout shows both clocks: yours running on forever, and the probe's, which crosses in a finite 28 rₛ/c and notices nothing.
 - **Black hole merger**: place a second hole. Its orbit decays by the actual Peters (1964) gravitational-wave equations (the trajectory shape is exact; only wall-clock time is compressed). Both holes lens light. At contact the shadow swells to the merged mass minus the radiated gravitational-wave energy, with a ringdown wobble.
 - **Deep sky**: the background is a procedurally baked HDR cubemap. Five layers of stars on a stellar-temperature colour sequence (the bright ones get diffraction spikes), a warped galactic band with dust lanes that actually extinguish the stars behind them, emission nebulae in hydrogen red and doubly-ionised-oxygen teal, globular clusters that crowd extra stars into their cores, and distant galaxies with dust lanes and spiral arms. All of it is lensed by the same geodesics, so it smears into Einstein arcs near the shadow.
 - **Feeding outflow**: when a disruption dumps matter on the disc it goes super-Eddington and drives a broad, ragged wind out of the poles. Wide and un-collimated, unlike the jet, it appears and fades with the feeding itself.
 - **Relativistic jet**: optional twin polar beams with braided filaments, integrated *inside* the raymarch so the jet bends with the light near the hole. The brightness difference between the two cones is the real Doppler boost, δ³.
 - **Curvature grid** (`G`): Flamm's paraboloid, the exact Schwarzschild embedding diagram, drawn as a wireframe funnel. During an inspiral the binary's quadrupole gravitational wave ripples outward across it: two crests per orbit, wound into a trailing spiral, growing as the pair tightens.
-- **Presets**: one-click scenes. A star being devoured, slow spaghettification, a binary merger with waves, bare curved spacetime, a jetted quasar, and a clean wallpaper frame.
+- **Presets**: one-click scenes. A star being devoured, slow spaghettification, a binary merger with waves, bare curved spacetime, a jetted quasar, a probe frozen at the horizon, and a clean wallpaper frame.
 - **Camera flights**: plunge into the horizon, fly past, or circle the hole.
 - **Cinematic mode** (`H`): fades the panel and readout for a wallpaper-clean frame.
 - **Procedural audio**: a Perseus-cluster-style deep drone, matter-rush noise when the disc is feeding, a gravitational-wave chirp that tracks the real orbital frequency, and a merger thump + ringdown tone whose pitch falls with the merged mass.
diff --git a/docs/THEORY.md b/docs/THEORY.md
index aa35bcd..2f1a0c0 100644
--- a/docs/THEORY.md
+++ b/docs/THEORY.md
@@ -26,13 +26,14 @@ the summary, jump to [the table at the end](#every-equation-and-where-it-lives).
 7. [The last stable orbit](#7-the-last-stable-orbit)
 8. [Why the disc glows, and how hot](#8-why-the-disc-glows-and-how-hot)
 9. [Why one side of the disc is brighter](#9-why-one-side-of-the-disc-is-brighter)
-10. [Tides, and why they tear stars apart](#10-tides-and-why-they-tear-stars-apart)
-11. [Why the debris becomes a stream](#11-why-the-debris-becomes-a-stream)
-12. [Gravitational waves and the chirp](#12-gravitational-waves-and-the-chirp)
-13. [The funnel: what curved space actually means](#13-the-funnel-what-curved-space-actually-means)
-14. [Jets, beaming, and the outflow](#14-jets-beaming-and-the-outflow)
-15. [What we cheat on](#15-what-we-cheat-on)
-16. [Every equation and where it lives](#every-equation-and-where-it-lives)
+10. [What a distant observer sees fall in](#10-what-a-distant-observer-sees-fall-in)
+11. [Tides, and why they tear stars apart](#11-tides-and-why-they-tear-stars-apart)
+12. [Why the debris becomes a stream](#12-why-the-debris-becomes-a-stream)
+13. [Gravitational waves and the chirp](#13-gravitational-waves-and-the-chirp)
+14. [The funnel: what curved space actually means](#14-the-funnel-what-curved-space-actually-means)
+15. [Jets, beaming, and the outflow](#15-jets-beaming-and-the-outflow)
+16. [What we cheat on](#16-what-we-cheat-on)
+17. [Every equation and where it lives](#every-equation-and-where-it-lives)
 
 ---
 
@@ -374,7 +375,123 @@ Two details this app gets right that are easy to get wrong:
 
 ---
 
-## 10. Tides, and why they tear stars apart
+## 10. What a distant observer sees fall in
+
+Drop something into a black hole and watch it go. It does not vanish. It slows,
+it reddens, it dims, and then it stops, hanging just outside the shadow, fading
+until there is nothing left to see. It never crosses.
+
+That is true. It is also only true for **you**. The thing you dropped crossed
+the horizon a short while later by its own watch and felt nothing in
+particular. Both statements are correct, and this part works out each of them
+from the same starting line, because the gap between them is the clearest
+thing a black hole does to time.
+
+Take the simplest possible case: a probe released **from rest** at radius
+$r_0$, falling straight in, no sideways motion at all.
+
+**One conserved number.** Anything in free fall carries an energy per unit mass
+that never changes along its path. For a probe let go from rest at $r_0$ it is
+just the metric's clock factor at the radius it was released from:
+
+$$E = \sqrt{1 - \frac{r_s}{r_0}}$$
+
+$E = 1$ for a fall that started infinitely far away, and it is smaller the
+closer in you let go. Everything below is written in terms of $E$ and the same
+factor evaluated at the probe's current radius,
+
+$$f \equiv 1 - \frac{r_s}{r}$$
+
+**How fast it is going.** Put an observer at radius $r$ hovering on a rocket,
+holding station, and let the probe fly past. The speed that observer measures
+is
+
+$$v = \frac{\sqrt{E^2 - f}}{E}$$
+
+At $r = r_0$ this is zero, which is the release condition. As $r \to r_s$,
+$f \to 0$ and $v \to 1$: the probe passes a hovering observer *at the speed of
+light*. That is the horizon's real definition. It is not a wall and there is
+nothing there to hit; it is the surface where hovering stops being possible,
+because holding station would take a rocket faster than light.
+
+**Why it reddens.** Two effects stack, and you have met both. The light has to
+climb out of the well, which costs it energy: that is the $\sqrt{f}$
+gravitational factor from Part 9. And the source is running away from you at
+speed $v$, which is the ordinary Doppler shift of recession. Multiply them:
+
+$$g = \underbrace{\sqrt{f}}_{\text{climbing out}} \times \underbrace{\frac{\sqrt{1 - v^2}}{1 + v}}_{\text{running away}} = \frac{f}{E + \sqrt{E^2 - f}}$$
+
+The two expressions are the same number; substitute $v$ into the left one and
+the square roots cancel. The right-hand form is worth keeping because it makes
+the endgame obvious. Near the horizon $f \to 0$ while $\sqrt{E^2 - f} \to E$,
+so the denominator settles at $2E$ and
+
+$$g \to \frac{r - r_s}{2\,E\,r_s}$$
+
+**the redshift is proportional to the gap.** Brightness goes as $g^3$ (Part 9
+again), so every factor of ten the probe closes on the horizon costs it a
+factor of a thousand in brightness. Between release at $7\,r_s$ and a gap of
+$10^{-3}\,r_s$ it fades by nine decades. This is why nobody has ever
+photographed something falling in: you have a few seconds of it, and then it is
+gone, whatever your exposure.
+
+**Why it stalls.** Coordinate time $t$ is the time on your clock, far away.
+Dividing the probe's radial motion by the rate its clock runs relative to yours
+gives
+
+$$\frac{dr}{dt} = -f\,v = -\frac{f\sqrt{E^2 - f}}{E}$$
+
+Both factors of $f$ matter here and they do different jobs, but near the
+horizon the second one has already saturated ($v \to 1$) while the first is
+still collapsing. Write the gap as $\varepsilon = r - r_s$, note that
+$f = \varepsilon/(r_s + \varepsilon) \to \varepsilon/r_s$, and you get
+
+$$\frac{d\varepsilon}{dt} \to -\frac{\varepsilon}{r_s} \quad\Longrightarrow\quad \varepsilon(t) \propto e^{-t/r_s}$$
+
+An exponential decay never reaches zero. The gap halves every $0.69\,r_s/c$ of
+your time, forever: the probe is always still outside, and the coordinate time
+to cross the horizon is infinite. That is the freeze, and notice that nothing
+was imposed to get it. It fell out of one line of algebra.
+
+**On the probe's own clock.** Now ask the probe. Its own elapsed time obeys
+$d\tau = dr/\sqrt{E^2 - f}$, which integrates to a cycloid, the same curve a
+point on a rolling wheel traces:
+
+$$\tau = \frac{1}{2}\sqrt{\frac{r_0^3}{r_s}}\,\left(\eta + \sin\eta\right), \qquad \cos\eta = \frac{2r}{r_0} - 1$$
+
+At the horizon $\eta$ is a perfectly ordinary angle and $\tau$ is a perfectly
+ordinary number. From a release at $7\,r_s$ the crossing happens at
+$\tau = 28.4\,r_s/c$, and for a hole of a million suns that is about half a
+minute. The probe sails through, measures no jolt, sees no wall, and has some
+time left before the tides get serious.
+
+So: infinite on your clock, half a minute on its. Neither is an illusion and
+neither is the "real" answer. They are answers to two different questions.
+
+> **In the code.** `src/sim/beacon.ts`, which carries all of the above as pure
+> functions, and is the one moving thing in this app on exact Schwarzschild
+> motion rather than the Paczyński-Wiita stand-in everything else uses. That is
+> not fussiness: PW has no coordinate-time divergence at all, and PW matter
+> crosses $r_s$ in finite time, so reusing it here would have made the effect
+> impossible to show. The state it integrates is the gap $r - r_s$ rather than
+> $r$, because an exponential decay stored as a difference of two order-one
+> numbers stops being physics and starts being rounding at $10^{-16}$.
+
+> **Honest note: where the image sits.** A probe that close to the hole is not
+> seen where it is. Light leaving it is bent so hard that its image piles up on
+> the photon ring, and the app draws it at the apparent radius
+> $b = r/\sqrt{1 - r_s/r}$, floored at $b_{\text{crit}}$ (Part 6), which is
+> exactly the impact parameter of the ray that leaves sideways and just
+> escapes. That is right for an emitter seen edge-on with the ray at its
+> turning point, and it is applied in every viewing geometry as a first-order
+> stand-in: the true image position needs the deflection integral solved for
+> the observer's own direction. The probe is also drawn at a fixed size on
+> screen, because a real one would be far under a pixel. What the fall changes
+> is its colour and its brightness, and those are computed.
+
+---
+
+## 11. Tides, and why they tear stars apart
 
 <img src="../assets/diagrams/tides.svg" alt="A star near a black hole, with a strong pull arrow on the near side and a weaker one on the far side" width="660">
 
@@ -420,7 +537,7 @@ supermassive case.
 
 ---
 
-## 11. Why the debris becomes a stream
+## 12. Why the debris becomes a stream
 
 <img src="../assets/diagrams/energy-spread.svg" alt="A stretched star splitting into a bound half that falls back and an unbound half that escapes" width="660">
 
@@ -463,7 +580,7 @@ fail without them.
 
 ---
 
-## 12. Gravitational waves and the chirp
+## 13. Gravitational waves and the chirp
 
 <img src="../assets/diagrams/quadrupole-wave.svg" alt="Two orbiting holes with ripples wound into a spiral, two crests per orbit" width="660">
 
@@ -507,7 +624,7 @@ travel outward.
 
 ---
 
-## 13. The funnel: what curved space actually means
+## 14. The funnel: what curved space actually means
 
 <img src="../assets/diagrams/flamm-funnel.svg" alt="A funnel-shaped surface narrowing to a throat, with rings and radial lines" width="660">
 
@@ -555,11 +672,11 @@ bending of *time* at least as much as space, and none of that is in the
 picture. It is an honest visualisation of one true thing, not of everything.
 
 > **In the code:** `embeddingDepth` in `src/render/spacetimeGrid.ts`, with the
-> wave from Part 12 added on top.
+> wave from Part 13 added on top.
 
 ---
 
-## 14. Jets, beaming, and the outflow
+## 15. Jets, beaming, and the outflow
 
 Two very different things come out of the poles, and this app draws both.
 
@@ -593,7 +710,7 @@ away with it.
 
 ---
 
-## 15. What we cheat on
+## 16. What we cheat on
 
 A physics document that only lists what it gets right is advertising. Here is
 the other column.
@@ -605,8 +722,8 @@ the other column.
 | **Matter is pseudo-Newtonian.** | Full geodesic motion for 48,000 particles is too slow. | Paczyński-Wiita gets the ISCO exactly right, which is the part that matters visually. |
 | **The disc is infinitely thin.** | A volumetric disc multiplies the per-pixel cost. | Raymarched volume with real optical depth. |
 | **The jet is drawn, not launched.** | Blandford-Znajek needs spin, which we do not have, plus magnetohydrodynamics. | GRMHD simulation data. The beaming, at least, is computed and not painted. |
-| **Two clocks run fast.** | A disruption takes days, an inspiral from $8\,r_s$ takes about 1600 time units. | Nothing: the trajectories are exact, only the clock is compressed, and the app says so in the interface. |
-| **No light travel-time delay.** | You see the whole disc at one instant rather than each part as it was when its light left. | Track photon arrival times through the march. |
+| **Three clocks run fast.** | A disruption takes days, an inspiral from $8\,r_s$ takes about 1600 time units, and a probe dropped from $7\,r_s$ takes forty seconds to stop being visible. | Nothing: the trajectories are exact, only the clock is compressed, and the app says so in the interface. |
+| **No light travel-time delay.** | You see the whole disc at one instant rather than each part as it was when its light left. The infalling probe is drawn at its current Schwarzschild coordinate position too, with propagation treated as instantaneous: that changes the time constant of the freeze, not the fact of it. | Track photon arrival times through the march. |
 | **The sky is invented.** | It follows real structure (luminosity function, dust extinction, clustering) but it is not a star catalogue. | A real survey texture, at the cost of every image looking identical. |
 
 ---
@@ -628,13 +745,19 @@ the other column.
 | Specific energy | $\varepsilon = v^2/2 - GM/(r-r_s)$ | `sim/orbit.ts`, `sim/debris.ts` |
 | Disc temperature | $T \propto r^{-3/4}(1 - \sqrt{r_{\text{in}}/r})^{1/4}$ | `shaders/geodesic.frag` |
 | Doppler + gravity shift | $g = \sqrt{1 - 3M/r}\,/\,\gamma(1 - \beta\cos\alpha)$ | `shaders/geodesic.frag` |
+| Gravitational redshift | $\sqrt{1 - r_s/r}$ | `sim/beacon.ts` |
+| Radial infall energy | $E = \sqrt{1 - r_s/r_0}$ | `sim/beacon.ts` |
+| Infaller redshift | $g = f/(E + \sqrt{E^2 - f})$ | `sim/beacon.ts` |
+| Coordinate infall rate | $dr/dt = -f\sqrt{E^2 - f}\,/\,E$ | `sim/beacon.ts` |
+| Proper time to the horizon | $\tau = \tfrac{1}{2}\sqrt{r_0^3/r_s}\,(\eta + \sin\eta)$ | `sim/beacon.ts` |
+| Apparent image radius | $b = r/\sqrt{1 - r_s/r}$, floored at $b_{\text{crit}}$ | `sim/beacon.ts` |
 | Tidal radius | $r_T \approx R_\star (M/m_\star)^{1/3}$ | `config.ts` |
 | Tidal energy spread | $\Delta\varepsilon \approx GMR_\star/r_p^2$ | `sim/debris.ts` |
 | Peters inspiral | $da/dt = -\tfrac{64}{5} G^3 m_1m_2(m_1{+}m_2)/c^5a^3$ | `sim/binary.ts` |
 | Radiated mass | $E_{\text{rad}} \approx 0.048 M_{\text{tot}}\,\eta/0.25$ | `sim/binary.ts` |
 | Flamm's paraboloid | $z = 2\sqrt{r_s(r - r_s)}$ | `render/spacetimeGrid.ts` |
 | Relativistic beaming | $\delta = 1/\gamma(1 - \beta\cos\theta)$, $I \propto \delta^3$ | `shaders/geodesic.frag` |
-| Eddington luminosity | $L = 4\pi GMm_pc/\sigma_T$ | Part 14, motivates the outflow |
+| Eddington luminosity | $L = 4\pi GMm_pc/\sigma_T$ | Part 15, motivates the outflow |
 
 ---
 
@@ -647,5 +770,5 @@ the other column.
   paper. The full version of Parts 5 to 9, written by the people who did it
   for the film.
 - **Rees (1988)** on tidal disruption, for Parts 10 and 11.
-- **Peters (1964)** for Part 12, four pages that predicted a sound nobody heard
+- **Peters (1964)** for Part 13, four pages that predicted a sound nobody heard
   for fifty-one years.
diff --git a/src/config.ts b/src/config.ts
index 0d5f726..88c2c1c 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -3,10 +3,12 @@
  * sim-seconds. Physics constants (horizon, ISCO, ...) live in
  * physics/constants.ts; these are the directable knobs layered on top.
  *
- * Two clocks tick in this file. BODY_TUNING and DEBRIS_TUNING run on the
+ * Three clocks tick in this file. BODY_TUNING and DEBRIS_TUNING run on the
  * compressed *disruption clock* (see BODY_TUNING.timeCompression), so a rate
  * of "per second" there is per disruption-second, roughly eight times faster
- * than the wall clock at the shipped default. Everything else (the disc, the
+ * than the wall clock at the shipped default. BINARY_TUNING runs on the
+ * *inspiral clock*, and BEACON_TUNING on the *beacon clock*, which is
+ * deliberately the slowest of the three. Everything else (the disc, the
  * camera, the audio) runs on the plain simulation clock.
  */
 
@@ -184,6 +186,44 @@ export const TDE_TUNING = {
   escapeRadius: 30,
 };
 
+export const BEACON_TUNING = {
+  /**
+   * Release radius floor for a click. Closer in than this and the probe is
+   * already inside the disc when it is let go, so the interesting part of the
+   * fall happens behind the glare.
+   */
+  rMin: 4.0,
+  /**
+   * Tilt of the drop line out of the disc plane, radians (~35 deg). A probe
+   * released inside the plane spends the fall behind the disc's inner glare;
+   * one released near the pole falls down the jet and through the wind cone,
+   * which opens to about 44 deg from the axis. This threads between them.
+   */
+  inclination: 0.61,
+  /**
+   * Drawn radius, r_s units. Art-directed: a real probe is a point and a point
+   * is a fraction of a pixel, so the sprite also carries a screen-space floor
+   * (see render/beaconPoint.ts). It is a legibility choice, not a size.
+   */
+  radius: 0.06,
+  /**
+   * Wall-clock compression of the distant observer's clock for the probe. The
+   * same trick the other two clocks use, and for the same reason: scaling the
+   * clock uniformly speeds up the fall and the exponential stall together, so
+   * the shape of the freeze is untouched. Slower than the disruption clock on
+   * purpose, because here the observer's clock is the quantity on show.
+   */
+  timeCompression: 3,
+  /** Emission scale, matched against the disc's own factor of 16. */
+  emission: 22.0,
+  /**
+   * Gap (r_s units) below which the image counts as frozen. Past this the
+   * probe moves by less than a thousandth of an r_s while its brightness has
+   * already fallen by nine decades, so nothing more is going to happen.
+   */
+  settledGap: 1e-3,
+};
+
 export const GRID_TUNING = {
   /** Wireframe extent, r_s units. The rings crowd toward the throat. */
   innerRadius: 1.6,
diff --git a/src/main.ts b/src/main.ts
index 4464856..a519b40 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -6,8 +6,10 @@
 import * as THREE from 'three';
 import { AudioEngine } from './audio/engine';
 import { AimingController } from './interact/aiming';
+import { BEACON_TUNING } from './config';
 import { DISC_OUTER, R_ISCO } from './physics/constants';
 import type { GravityCenter } from './physics/geodesic';
+import { BeaconPoint, type BeaconState } from './render/beaconPoint';
 import { BlackHolePass, type PlanetState } from './render/blackHolePass';
 import { CameraRig } from './render/cameraRig';
 import { CameraTour } from './render/cameraTour';
@@ -17,10 +19,20 @@ import { RenderPipeline, type AccumMode } from './render/pipeline';
 import { SpacetimeGrid } from './render/spacetimeGrid';
 import { Starfield } from './render/starfield';
 import { defaultSettings } from './settings';
+import { observeBeacon, releasePoint, type BeaconObservables } from './sim/beacon';
 import { displayRs, orbitalOmegaWall } from './sim/binary';
 import { bodyScale } from './sim/body';
 import { nextWaveState, restingWave } from './sim/gravitationalWave';
-import { clearBody, createWorld, placeBinary, placeBody, resetScene, stepWorld } from './sim/world';
+import {
+  clearBeacon,
+  clearBody,
+  createWorld,
+  placeBeacon,
+  placeBinary,
+  placeBody,
+  resetScene,
+  stepWorld,
+} from './sim/world';
 import type { Body } from './sim/types';
 import { CinematicMode, isTypingIntoControl } from './ui/chrome';
 import { touchRenderBudget, usesTouchUi } from './ui/device';
@@ -93,6 +105,9 @@ const audio = new AudioEngine();
 const debrisPoints = new DebrisPoints(world.debris);
 pipeline.overlayScene.add(debrisPoints.points);
 
+const beaconPoint = new BeaconPoint();
+pipeline.overlayScene.add(beaconPoint.points);
+
 const spacetimeGrid = new SpacetimeGrid();
 pipeline.overlayScene.add(spacetimeGrid.lines);
 
@@ -129,7 +144,10 @@ const placement = new PlacementController(
   pipeline.overlayScene,
   rig.controls,
   (kind, pos) => {
+    // `pos` already carries whatever lift the kind asked for, so the beacon
+    // arrives at its release point and not at the click on the plane.
     if (kind === 'bh2') placeBinary(world, pos);
+    else if (kind === 'beacon') placeBeacon(world, pos);
     else placeBody(world, kind, pos, settings.tdeMode);
   },
 );
@@ -194,6 +212,11 @@ function applyPreset(preset: Preset): void {
     presetPos.set(radius * Math.cos(angle), 0, radius * Math.sin(angle));
     placeBinary(world, presetPos);
   }
+  if (preset.beacon) {
+    const { radius, angle } = preset.beacon;
+    presetPos.set(radius * Math.cos(angle), 0, radius * Math.sin(angle));
+    placeBeacon(world, releasePoint(presetPos));
+  }
 
   rig.moveTo(preset.camera);
   photonPaths.setVisible(settings.photonsEnabled);
@@ -213,7 +236,9 @@ const panel = buildPanel(
     placePlanet: () => placement.enter('planet'),
     placeStar: () => placement.enter('star'),
     placeBlackHole: () => placement.enter('bh2'),
+    placeBeacon: () => placement.enter('beacon'),
     clearBody: () => clearBody(world),
+    clearBeacon: () => clearBeacon(world),
     clearPaths: () => photonPaths.clear(),
     onPhotonsToggled: (enabled) => {
       photonPaths.setVisible(enabled);
@@ -325,6 +350,36 @@ function syncPlanet(body: Body | null): void {
   bhPass.setPlanet(planetState);
 }
 
+// --- infalling beacon sync (scratch object, no per-frame allocation) ---
+const beaconState: BeaconState = {
+  pos: new THREE.Vector3(),
+  radius: BEACON_TUNING.radius,
+  redshift: 1,
+  brightness: 1,
+};
+
+/**
+ * What a distant observer measures about the probe right now, recomputed once
+ * per frame and shared by the renderer and the readout. Null when there is no
+ * probe in the scene.
+ */
+let beaconView: BeaconObservables | null = null;
+
+function syncBeacon(view: BeaconObservables | null, viewportHeight: number): void {
+  const beacon = world.beacon;
+  if (!beacon || !view) {
+    beaconPoint.hide();
+    return;
+  }
+  // Drawn at the apparent radius, not the coordinate radius: near the horizon
+  // the image piles up on the photon ring instead of sinking into the shadow.
+  beaconState.pos.copy(beacon.direction).multiplyScalar(view.apparentRadius);
+  beaconState.radius = BEACON_TUNING.radius * beacon.horizonRs;
+  beaconState.redshift = view.redshift;
+  beaconState.brightness = BEACON_TUNING.emission * settings.beaconBrightness;
+  beaconPoint.setBeacon(beaconState, rig.camera, viewportHeight);
+}
+
 // --- auto-degrade on sustained slow frames ---
 const frameTimes: number[] = [];
 let lastDegradeCheck = 0;
@@ -355,6 +410,14 @@ function showTransientNote(text: string): void {
   transientUntil = performance.now() + NOTE_VISIBLE_MS;
 }
 
+/**
+ * Compact number for the readout. The beacon's quantities span thirty decades
+ * on the way down, so a fixed number of decimal places is useless for them.
+ */
+function readable(value: number): string {
+  return value >= 0.01 ? value.toFixed(2) : value.toExponential(1);
+}
+
 function updateHud(now: number, fps: number): void {
   if (cinematic.isActive || now - lastHudUpdate < 250) return;
   lastHudUpdate = now;
@@ -376,6 +439,17 @@ function updateHud(now: number, fps: number): void {
         .toFixed(1)} · mass=${(world.body.mass * 100).toFixed(0)}%`,
     );
   }
+  if (beaconView) {
+    const view = beaconView;
+    lines.push(
+      `beacon (${view.settled ? 'frozen' : 'falling'}): r − rₛ = ${readable(view.horizonGap)}` +
+        ` · redshift ×${readable(view.redshift)} · your clock ${view.coordinateTime.toFixed(0)} rₛ/c`,
+    );
+    lines.push(
+      `  its own clock ${view.probeProperTime.toFixed(1)} of` +
+        ` ${view.probeProperTimeAtHorizon.toFixed(1)} rₛ/c to the horizon`,
+    );
+  }
   if (world.discBoost > 0.01) lines.push(`disc feed +${(world.discBoost * 100).toFixed(0)}%`);
   if (tour.activeKind) lines.push(`camera flight: ${tour.activeKind} · Esc to stop`);
   else if (placement.active) lines.push('click the plane to place · right-click / Esc cancels');
@@ -386,6 +460,8 @@ function updateHud(now: number, fps: number): void {
 }
 
 // --- main loop ---
+/** The three compressed clocks, refilled from the sliders each tick. */
+const clocks = { gw: 0, tde: 0, beacon: 0 };
 let last = performance.now();
 let acc = 0;
 let smoothedFps = 60;
@@ -406,17 +482,15 @@ function frame(now: number): void {
   let steps = 0;
   let mergerNow = false;
   let shredNow = false;
+  clocks.gw = settings.gwTimeCompression;
+  clocks.tde = settings.tdeTimeCompression;
+  clocks.beacon = settings.beaconTimeCompression;
   while (acc >= FIXED_DT && steps < MAX_STEPS_PER_FRAME) {
-    const events = stepWorld(
-      world,
-      FIXED_DT,
-      Math.random,
-      settings.gwTimeCompression,
-      settings.tdeTimeCompression,
-    );
+    const events = stepWorld(world, FIXED_DT, clocks, Math.random);
     mergerNow ||= events.mergerNow;
     shredNow ||= events.shredNow;
     if (events.bodyEscaped) showTransientNote('remnant escaped with the mass it kept');
+    if (events.beaconLost) showTransientNote('the merger moved the horizon, so the beacon was removed');
     // The wave rides the simulation clock, so it freezes when the sim does.
     wave = nextWaveState(
       wave,
@@ -454,6 +528,9 @@ function frame(now: number): void {
   });
   renderer.getDrawingBufferSize(drawSize);
   debrisPoints.update(world.debris, world.debrisBrightness, rig.camera, drawSize.y);
+  // Measured once, then shared by the sprite and the (throttled) readout.
+  beaconView = world.beacon ? observeBeacon(world.beacon) : null;
+  syncBeacon(beaconView, drawSize.y);
 
   audio.update(frameDt, {
     discBoost: world.discBoost,
@@ -476,6 +553,9 @@ function frame(now: number): void {
     idle = rig.update();
   }
 
+  // Only raymarched content counts. The beacon is drawn in the overlay pass,
+  // which is re-rendered every frame even while a converged raymarch is held,
+  // so a falling probe does not have to spoil idle accumulation.
   const bhContentMoving = world.body !== null || world.binary !== null;
   const accumMode = chooseAccumMode(idle, settings.paused, bhContentMoving);
   pipeline.render(world.time, {
diff --git a/src/render/beaconPoint.ts b/src/render/beaconPoint.ts
new file mode 100644
index 0000000..92f7adb
--- /dev/null
+++ b/src/render/beaconPoint.ts
@@ -0,0 +1,96 @@
+/**
+ * GPU rendering of the infalling probe: one additive point sprite in the
+ * overlay pass, occluded by the horizon through the shared mask, exactly the
+ * way debrisPoints.ts draws the debris.
+ *
+ * It is an overlay object rather than a hit test inside the raymarch because
+ * the raymarch pass is not this module's to change. The cost is that the probe
+ * is not truly lensed: it is drawn at the apparent radius sim/beacon.ts
+ * computes for it, which floors the image at the photon ring so it hugs the
+ * shadow rim instead of sinking into it, but the position of that image within
+ * the rim is a first-order stand-in rather than a solved geodesic.
+ */
+import * as THREE from 'three';
+import { maskUniforms } from './horizonMask';
+import beaconVert from './shaders/beacon.vert';
+import beaconFrag from './shaders/beacon.frag';
+
+export interface BeaconState {
+  /** Where the image appears, world space (not the coordinate position). */
+  pos: THREE.Vector3;
+  /** Drawn radius, world units. */
+  radius: number;
+  /** g = received / emitted frequency; drives colour and brightness. */
+  redshift: number;
+  /** Emission scale times the exposure slider. */
+  brightness: number;
+}
+
+/**
+ * Screen-space floor on the sprite, pixels. At its drawn radius of 0.06 r_s
+ * the probe is under two pixels from a normal viewing distance, and a two
+ * pixel dot cannot show a colour ramp at all. The floor is a legibility
+ * choice, so the probe stays a readable point of light at any distance, and it
+ * is why the image never shrinks as it falls: what the fall changes is the
+ * colour and the brightness, which is the honest part.
+ */
+const MIN_SPRITE_PIXELS = 7;
+
+export class BeaconPoint {
+  readonly points: THREE.Points;
+  private readonly geometry: THREE.BufferGeometry;
+  private readonly material: THREE.ShaderMaterial;
+  private readonly position = new Float32Array(3);
+
+  constructor() {
+    this.geometry = new THREE.BufferGeometry();
+    this.geometry.setAttribute(
+      'position',
+      new THREE.BufferAttribute(this.position, 3).setUsage(THREE.DynamicDrawUsage),
+    );
+
+    this.material = new THREE.ShaderMaterial({
+      vertexShader: beaconVert,
+      fragmentShader: beaconFrag,
+      uniforms: {
+        ...maskUniforms,
+        uPixelScale: { value: 1 },
+        uWorldRadius: { value: 0.06 },
+        uMinPixels: { value: MIN_SPRITE_PIXELS },
+        uShift: { value: 1 },
+        uBrightness: { value: 1 },
+      },
+      transparent: true,
+      blending: THREE.AdditiveBlending,
+      depthWrite: false,
+      depthTest: false,
+    });
+
+    this.points = new THREE.Points(this.geometry, this.material);
+    this.points.frustumCulled = false;
+    this.points.visible = false;
+  }
+
+  /** Take the probe off screen; the draw call goes away with it. */
+  hide(): void {
+    this.points.visible = false;
+  }
+
+  setBeacon(
+    beacon: BeaconState,
+    camera: THREE.PerspectiveCamera,
+    viewportHeight: number,
+  ): void {
+    this.points.visible = true;
+    this.position[0] = beacon.pos.x;
+    this.position[1] = beacon.pos.y;
+    this.position[2] = beacon.pos.z;
+    (this.geometry.getAttribute('position') as THREE.BufferAttribute).needsUpdate = true;
+    const u = this.material.uniforms;
+    u.uWorldRadius!.value = beacon.radius;
+    u.uShift!.value = beacon.redshift;
+    u.uBrightness!.value = beacon.brightness;
+    u.uPixelScale!.value =
+      viewportHeight / (2 * Math.tan(THREE.MathUtils.degToRad(camera.fov) / 2));
+  }
+}
diff --git a/src/render/shaders/beacon.frag b/src/render/shaders/beacon.frag
new file mode 100644
index 0000000..553ebea
--- /dev/null
+++ b/src/render/shaders/beacon.frag
@@ -0,0 +1,47 @@
+// The infalling probe's lamp. One number does all the work: uShift is the
+// received/emitted frequency ratio g computed in sim/beacon.ts, and it drives
+// both the colour (by moving the blackbody temperature) and the brightness (by
+// the same power law the disc dims on). Everything else here is art direction,
+// and is labelled as such.
+
+#include ./horizonMask.glsl;
+
+uniform float uShift;      // g = received / emitted frequency
+uniform float uBrightness; // exposure * emission scale
+
+varying vec3 vWorldPos;
+
+// Intrinsic colour temperature of the lamp, in the same arbitrary units the
+// blackbody ramp below takes: blue-white unshifted, white near g = 0.7, orange
+// near 0.33, deep red near 0.15. Art-directed choice of what the probe is;
+// the shift that reddens it is not.
+const float BEACON_TEMP = 1.35;
+
+// The same exponent as BEAM_EXP in render/blackHolePass.ts, so the probe and
+// the disc dim on one law. The honest bolometric value for a moving blackbody
+// is 4; this app uses 3 throughout and docs/THEORY.md says so.
+const float BEACON_BEAM_EXP = 3.0;
+
+// The disc's ramp, kept in step with the copy in geodesic.frag by hand: red
+// through gold to white to blue-white.
+vec3 blackbody(float t) {
+  vec3 c = mix(vec3(0.55, 0.04, 0.0), vec3(1.0, 0.45, 0.12), smoothstep(0.0, 0.45, t));
+  c = mix(c, vec3(1.0, 0.93, 0.82), smoothstep(0.45, 0.95, t));
+  c = mix(c, vec3(0.72, 0.82, 1.0), smoothstep(0.95, 1.7, t));
+  return c;
+}
+
+void main() {
+  float d = length(gl_PointCoord - 0.5) * 2.0;
+  // Tight core plus a dim skirt, so the probe still reads as a light source
+  // rather than a hard dot once it is only a few pixels across.
+  float sprite = (exp(-d * d * 10.0) + 0.18 * exp(-d * d * 1.8)) * smoothstep(1.0, 0.6, d);
+  float a = sprite * horizonVisibility(vWorldPos);
+  if (a < 0.002) discard;
+  // Additive, not opaque. The probe is a lamp, so it belongs in the light it
+  // adds and not in the light it blocks; an opaque version would end the fall
+  // as a dark speck punched through the photon ring, which is what a cold
+  // solid would do but reads as an artifact.
+  vec3 col = blackbody(BEACON_TEMP * uShift) * uBrightness * pow(uShift, BEACON_BEAM_EXP);
+  gl_FragColor = vec4(col * a, a);
+}
diff --git a/src/render/shaders/beacon.vert b/src/render/shaders/beacon.vert
new file mode 100644
index 0000000..0cd9828
--- /dev/null
+++ b/src/render/shaders/beacon.vert
@@ -0,0 +1,20 @@
+// The infalling probe, drawn as a single point sprite in the overlay pass.
+//
+// The world position arriving here is already the position the *image*
+// appears at (sim/beacon.ts apparentImageRadius has floored it at the photon
+// ring), so this stage does no optics: it sizes the sprite on screen and
+// hands the world position to the fragment stage for horizon occlusion.
+
+uniform float uPixelScale;   // pixels per world unit at unit view depth
+uniform float uWorldRadius;  // drawn radius in world units
+uniform float uMinPixels;    // screen-space floor, see beaconPoint.ts
+
+varying vec3 vWorldPos;
+
+void main() {
+  vWorldPos = position;
+  vec4 mv = viewMatrix * vec4(position, 1.0);
+  float projected = uWorldRadius * uPixelScale / max(-mv.z, 0.1);
+  gl_PointSize = clamp(max(projected, uMinPixels), 1.0, 128.0);
+  gl_Position = projectionMatrix * mv;
+}
diff --git a/src/settings.ts b/src/settings.ts
index c24472d..74fc1c9 100644
--- a/src/settings.ts
+++ b/src/settings.ts
@@ -1,6 +1,6 @@
 /** UI-mutable settings: one plain object, read by sim and render each frame. */
 
-import { BINARY_TUNING, BODY_TUNING, GRID_TUNING, SKY_TUNING } from './config';
+import { BEACON_TUNING, BINARY_TUNING, BODY_TUNING, GRID_TUNING, SKY_TUNING } from './config';
 
 export type QualityPreset = 'low' | 'medium' | 'high';
 
@@ -43,6 +43,10 @@ export interface Settings {
   gwTimeCompression: number;
   /** Wall-clock compression of a disruption and its debris (same trick). */
   tdeTimeCompression: number;
+  /** Wall-clock compression of the distant observer's clock for the beacon. */
+  beaconTimeCompression: number;
+  /** Exposure for the infalling probe; its true brightness spans six decades. */
+  beaconBrightness: number;
   soundEnabled: boolean;
   volume: number;
   sky: SkySettings;
@@ -68,6 +72,8 @@ export function defaultSettings(): Settings {
     tdeMode: 'cinematic',
     gwTimeCompression: BINARY_TUNING.timeCompression,
     tdeTimeCompression: BODY_TUNING.timeCompression,
+    beaconTimeCompression: BEACON_TUNING.timeCompression,
+    beaconBrightness: 1.6,
     soundEnabled: false,
     volume: 0.6,
     sky: {
diff --git a/src/sim/__tests__/beacon.test.ts b/src/sim/__tests__/beacon.test.ts
new file mode 100644
index 0000000..8627188
--- /dev/null
+++ b/src/sim/__tests__/beacon.test.ts
@@ -0,0 +1,263 @@
+import { describe, expect, it } from 'vitest';
+import { Vector3 } from 'three';
+import { BEACON_TUNING, PLACEMENT_TUNING } from '../../config';
+import { B_CRIT, R_PHOTON } from '../../physics/constants';
+import {
+  advanceHorizonGap,
+  apparentImageRadius,
+  coordinateInfallRate,
+  gravitationalRedshift,
+  infallEnergy,
+  localInfallSpeed,
+  localSpeedGrowth,
+  observeBeacon,
+  observedRedshift,
+  properTimeAtHorizon,
+  properTimeSinceRelease,
+  recessionDoppler,
+  releasePoint,
+} from '../beacon';
+import { createWorld, placeBeacon, placeBinary, stepWorld } from '../world';
+
+const RS = 1;
+
+/**
+ * The redshift built the way the physics reads rather than the way it is
+ * evaluated: the static gravitational factor times the recession Doppler of
+ * the probe's local speed. `observedRedshift` uses an algebraically identical
+ * closed form that survives near the horizon, and this is what it has to
+ * agree with everywhere the product is still meaningful in float64.
+ */
+function factorisedRedshift(gap: number, r0: number, rs: number): number {
+  return gravitationalRedshift(gap, rs) * recessionDoppler(localInfallSpeed(gap, r0, rs));
+}
+
+/**
+ * Proper time from r up to r0 by direct quadrature of dtau = dr / sqrt(E^2 - f),
+ * substituting u = sqrt(r0 - r) to remove the inverse-square-root endpoint. An
+ * independent check on the cycloid closed form: different variable, plain
+ * Simpson, no shared algebra.
+ */
+function integratedProperTime(r: number, r0: number, rs: number): number {
+  const uMax = Math.sqrt(r0 - r);
+  const steps = 20000;
+  const h = uMax / steps;
+  const integrand = (u: number): number => 2 * Math.sqrt(((r0 - u * u) * r0) / rs);
+  let sum = integrand(0) + integrand(uMax);
+  for (let i = 1; i < steps; i++) {
+    sum += integrand(i * h) * (i % 2 === 1 ? 4 : 2);
+  }
+  return (sum * h) / 3;
+}
+
+describe('beacon redshift', () => {
+  it('reduces to the static gravitational factor at the release radius', () => {
+    for (const r0 of [3, 7, 20]) {
+      const gap = r0 - RS;
+      // Still at rest, so the recession Doppler factor is exactly 1. Exactly:
+      // a probe that has not been released cannot already be moving.
+      expect(localInfallSpeed(gap, r0, RS)).toBe(0);
+      expect(recessionDoppler(0)).toBe(1);
+      expect(observedRedshift(gap, r0, RS)).toBeCloseTo(Math.sqrt(1 - RS / r0), 12);
+      expect(gravitationalRedshift(gap, RS)).toBeCloseTo(Math.sqrt(1 - RS / r0), 12);
+    }
+  });
+
+  it('equals gravitational shift times recession Doppler, decade by decade', () => {
+    for (const r0 of [4, 7, 30]) {
+      for (let exponent = 1; exponent >= -9; exponent--) {
+        const gap = Math.min(Math.pow(10, exponent), r0 - RS);
+        expect(observedRedshift(gap, r0, RS)).toBeCloseTo(factorisedRedshift(gap, r0, RS), 12);
+      }
+    }
+  });
+
+  it('reddens monotonically and stays positive and finite at absurd depth', () => {
+    const r0 = 7;
+    let previous = observedRedshift(r0 - RS, r0, RS);
+    for (let exponent = 0; exponent >= -20; exponent--) {
+      const g = observedRedshift(Math.pow(10, exponent), r0, RS);
+      expect(g).toBeLessThan(previous);
+      expect(g).toBeGreaterThan(0);
+      previous = g;
+    }
+    const deepest = observedRedshift(1e-30, r0, RS);
+    expect(Number.isFinite(deepest)).toBe(true);
+    expect(deepest).toBeGreaterThan(0);
+  });
+
+  it('becomes linear in the gap near the horizon', () => {
+    const r0 = 7;
+    const energy = infallEnergy(r0, RS);
+    expect(observedRedshift(1e-6, r0, RS) / observedRedshift(1e-7, r0, RS)).toBeCloseTo(10, 1);
+    for (const gap of [1e-6, 1e-8]) {
+      const limit = gap / (2 * energy * RS);
+      expect(Math.abs(observedRedshift(gap, r0, RS) / limit - 1)).toBeLessThan(0.01);
+    }
+  });
+});
+
+describe('beacon coordinate motion', () => {
+  it('stalls first-order in the gap, which is what makes the freeze exponential', () => {
+    const r0 = 7;
+    const ratio = coordinateInfallRate(1e-6, r0, RS) / coordinateInfallRate(1e-7, r0, RS);
+    expect(ratio).toBeCloseTo(10, 1);
+    expect(Math.abs(coordinateInfallRate(0, r0, RS))).toBe(0);
+    expect(coordinateInfallRate(1e-3, r0, RS)).toBeLessThan(0);
+  });
+
+  it('leaves the release radius even though the rate there is exactly zero', () => {
+    const r0 = 6;
+    const gap0 = r0 - RS;
+    expect(Math.abs(coordinateInfallRate(gap0, r0, RS))).toBe(0);
+    expect(localSpeedGrowth(gap0, r0, RS)).toBeGreaterThan(0);
+    expect(advanceHorizonGap(gap0, 0.05, r0, RS)).toBeLessThan(gap0);
+  });
+
+  it('the local speed grows everywhere on the way in and dies at the horizon', () => {
+    const r0 = 6;
+    expect(localSpeedGrowth(1e-9, r0, RS)).toBeGreaterThan(0);
+    expect(localSpeedGrowth(1e-9, r0, RS)).toBeLessThan(localSpeedGrowth(1, r0, RS));
+    expect(localSpeedGrowth(0, r0, RS)).toBe(0);
+    expect(localInfallSpeed(1e-12, r0, RS)).toBeGreaterThan(0.999);
+    expect(localInfallSpeed(1e-12, r0, RS)).toBeLessThanOrEqual(1);
+  });
+
+  it('never crosses the horizon, at a sane step or a pathological one', () => {
+    const r0 = 6;
+    for (const dt of [0.05, 5]) {
+      let gap = r0 - RS;
+      for (let step = 0; step < 4000; step++) {
+        const next = advanceHorizonGap(gap, dt, r0, RS);
+        expect(Number.isFinite(next)).toBe(true);
+        expect(next).toBeGreaterThan(0);
+        expect(next).toBeLessThan(gap);
+        gap = next;
+      }
+    }
+  });
+
+  it('reproduces the analytic exp(-t / r_s) tail', () => {
+    const r0 = 6;
+    const dt = 0.05;
+    const start = 1e-3;
+    let gap = start;
+    for (let step = 0; step < 5 / dt; step++) gap = advanceHorizonGap(gap, dt, r0, RS);
+    expect(Math.abs(gap / start / Math.exp(-5) - 1)).toBeLessThan(0.02);
+  });
+});
+
+describe("the probe's own clock", () => {
+  it('matches a direct numerical integral of dtau', () => {
+    for (const [r, r0] of [
+      [5, 9],
+      [1.5, 7],
+      [1.0001, 12],
+    ]) {
+      expect(properTimeSinceRelease(r!, r0!, RS)).toBeCloseTo(
+        integratedProperTime(r!, r0!, RS),
+        6,
+      );
+    }
+  });
+
+  it('reaches the horizon in finite time while our clock diverges', () => {
+    const r0 = 6;
+    const crossing = properTimeAtHorizon(r0, RS);
+    expect(Number.isFinite(crossing)).toBe(true);
+    expect(crossing).toBeGreaterThan(0);
+
+    // Walk the coordinate-time trajectory: our clock runs on and on, the
+    // probe's clock climbs toward the crossing and never passes it. It does
+    // reach it to float64 precision, because dtau/dr is finite at the horizon
+    // while dt/dr is not, and that contrast is the whole point.
+    let gap = r0 - RS;
+    let previousProper = 0;
+    let coordinateTime = 0;
+    let strictlyRisingFor = 0;
+    for (let step = 0; step < 4000; step++) {
+      gap = advanceHorizonGap(gap, 0.05, r0, RS);
+      coordinateTime += 0.05;
+      const proper = properTimeSinceRelease(RS + gap, r0, RS);
+      expect(proper).toBeGreaterThanOrEqual(previousProper);
+      expect(proper).toBeLessThanOrEqual(crossing);
+      if (proper > previousProper) strictlyRisingFor = step;
+      previousProper = proper;
+    }
+    expect(strictlyRisingFor).toBeGreaterThan(100);
+    expect(coordinateTime).toBeGreaterThan(crossing * 5);
+    expect(previousProper / crossing).toBeGreaterThan(0.999);
+  });
+});
+
+describe('where the probe is released and where it is seen', () => {
+  it('keeps the click azimuth and radius, lifted out of the plane', () => {
+    const clicked = new Vector3(6, 0, 8); // radius 10
+    const release = releasePoint(clicked);
+    expect(Math.atan2(release.z, release.x)).toBeCloseTo(Math.atan2(8, 6), 12);
+    expect(release.length()).toBeCloseTo(10, 12);
+    expect(release.y).toBeCloseTo(10 * Math.sin(BEACON_TUNING.inclination), 12);
+  });
+
+  it('lifts a click inside the floor out to it, and clamps a distant one', () => {
+    expect(releasePoint(new Vector3(1, 0, 0)).length()).toBeCloseTo(BEACON_TUNING.rMin, 12);
+    expect(releasePoint(new Vector3(500, 0, 0)).length()).toBeCloseTo(PLACEMENT_TUNING.rMax, 12);
+  });
+
+  it('never places the image inside the shadow', () => {
+    // The operational constraint the whole overlay rendering rests on: the
+    // sprite is drawn at this radius, so if it could fall below b_crit the
+    // horizon mask would swallow the probe exactly when the freeze begins.
+    for (const gap of [5, 1, 0.5, 1e-3, 1e-12, 0]) {
+      expect(apparentImageRadius(RS + gap, RS)).toBeGreaterThanOrEqual(B_CRIT * RS);
+    }
+  });
+
+  it('is continuous at the photon sphere and grows outward from there', () => {
+    expect(apparentImageRadius(R_PHOTON * RS, RS)).toBeCloseTo(B_CRIT * RS, 12);
+    expect(apparentImageRadius(1.51, RS)).toBeGreaterThan(B_CRIT * RS);
+    expect(apparentImageRadius(20, RS)).toBeGreaterThan(20);
+    expect(apparentImageRadius(20, RS)).toBeLessThan(22);
+  });
+});
+
+describe('beacon in the world', () => {
+  it('reports unsettled at release and settled once the gap closes', () => {
+    const world = createWorld(16);
+    placeBeacon(world, releasePoint(new Vector3(7, 0, 0)));
+    expect(observeBeacon(world.beacon!).settled).toBe(false);
+
+    const clocks = { gw: 40, tde: 1, beacon: 8 };
+    for (let tick = 0; tick < 60 * 240; tick++) stepWorld(world, 1 / 60, clocks);
+
+    const view = observeBeacon(world.beacon!);
+    expect(view.horizonGap).toBeLessThan(BEACON_TUNING.settledGap);
+    expect(view.settled).toBe(true);
+    expect(view.redshift).toBeLessThan(1e-3);
+    // Still there, still outside, still falling. It never finishes.
+    expect(world.beacon).not.toBeNull();
+    expect(view.horizonGap).toBeGreaterThan(0);
+    expect(view.probeProperTime).toBeLessThanOrEqual(view.probeProperTimeAtHorizon);
+    // Our clock has run far past the time its own clock says the crossing took.
+    expect(view.coordinateTime).toBeGreaterThan(view.probeProperTimeAtHorizon * 3);
+  });
+
+  it('is dropped when a merger moves the horizon out from under it', () => {
+    const world = createWorld(16);
+    placeBeacon(world, releasePoint(new Vector3(7, 0, 0)));
+    placeBinary(world, new Vector3(9, 0, 0));
+
+    const clocks = { gw: 400, tde: 1, beacon: 3 };
+    let lost = false;
+    for (let tick = 0; tick < 60 * 200 && !lost; tick++) {
+      lost = stepWorld(world, 1 / 60, clocks).beaconLost;
+    }
+    expect(lost).toBe(true);
+    expect(world.beacon).toBeNull();
+  });
+
+  it('refuses a release radius inside the horizon', () => {
+    const world = createWorld(16);
+    expect(() => placeBeacon(world, new Vector3(0.5, 0, 0))).toThrow();
+  });
+});
diff --git a/src/sim/__tests__/binary.test.ts b/src/sim/__tests__/binary.test.ts
index d245fb1..964a989 100644
--- a/src/sim/__tests__/binary.test.ts
+++ b/src/sim/__tests__/binary.test.ts
@@ -77,7 +77,7 @@ describe('binary inspiral (Peters 1964)', () => {
     let mergers = 0;
     let rsFinal = 0;
     for (let i = 0; i < 10_000 && world.binary; i++) {
-      const { mergerNow } = stepWorld(world, DT, rng, COMPRESSION);
+      const { mergerNow } = stepWorld(world, DT, { gw: COMPRESSION, tde: 1, beacon: 1 }, rng);
       if (mergerNow) {
         mergers++;
         rsFinal = world.binary!.rsFinal;
diff --git a/src/sim/__tests__/disruptionClock.test.ts b/src/sim/__tests__/disruptionClock.test.ts
index 8d98d5e..2a947cb 100644
--- a/src/sim/__tests__/disruptionClock.test.ts
+++ b/src/sim/__tests__/disruptionClock.test.ts
@@ -18,7 +18,7 @@ function runFor(ticks: number, compression: number): Vector3 {
     seed = (seed * 1103515245 + 12345) % 2147483648;
     return seed / 2147483648;
   };
-  for (let i = 0; i < ticks; i++) stepWorld(world, DT, rng, 40, compression);
+  for (let i = 0; i < ticks; i++) stepWorld(world, DT, { gw: 40, tde: compression, beacon: 1 }, rng);
   return world.body!.pos.clone();
 }
 
diff --git a/src/sim/__tests__/stream.test.ts b/src/sim/__tests__/stream.test.ts
index 01b30ec..87b6a73 100644
--- a/src/sim/__tests__/stream.test.ts
+++ b/src/sim/__tests__/stream.test.ts
@@ -53,7 +53,7 @@ function disrupt(ticks: number): StreamShape {
   const world = createWorld();
   const rng = mulberry32(7);
   placeBody(world, 'star', new Vector3(14, 0, 0), 'realistic');
-  for (let i = 0; i < ticks; i++) stepWorld(world, DT, rng, 40, COMPRESSION);
+  for (let i = 0; i < ticks; i++) stepWorld(world, DT, { gw: 40, tde: COMPRESSION, beacon: 1 }, rng);
   return shapeOf(world);
 }
 
diff --git a/src/sim/__tests__/world.test.ts b/src/sim/__tests__/world.test.ts
index 12d0c4b..fc7b783 100644
--- a/src/sim/__tests__/world.test.ts
+++ b/src/sim/__tests__/world.test.ts
@@ -6,10 +6,9 @@ import type { BodyPhase } from '../types';
 import { mulberry32 } from './rng';
 
 const DT = 1 / 60;
-// Both clocks stated explicitly: these tests count sim-seconds, so a default
+// Every clock stated explicitly: these tests count sim-seconds, so a default
 // compression would silently multiply every duration they assert.
-const GW_COMPRESSION = 40;
-const TDE_COMPRESSION = 1;
+const CLOCKS = { gw: 40, tde: 1, beacon: 1 };
 
 describe('world end-to-end (tuning harness)', () => {
   it('a placed planet is disrupted through the phases and consumed', () => {
@@ -23,7 +22,7 @@ describe('world end-to-end (tuning harness)', () => {
     const maxTicks = 400 * 60;
     while (world.body && tick < maxTicks) {
       if (!firstSeen.has(world.body.phase)) firstSeen.set(world.body.phase, tick);
-      stepWorld(world, DT, rng, GW_COMPRESSION, TDE_COMPRESSION);
+      stepWorld(world, DT, CLOCKS, rng);
       peakBoost = Math.max(peakBoost, world.discBoost);
       tick++;
     }
@@ -35,7 +34,7 @@ describe('world end-to-end (tuning harness)', () => {
     expect(peakBoost).toBeGreaterThan(0.3);
 
     // Debris drains and the boost decays after consumption.
-    for (let t = 0; t < 40; t += DT) stepWorld(world, DT, rng, GW_COMPRESSION, TDE_COMPRESSION);
+    for (let t = 0; t < 40; t += DT) stepWorld(world, DT, CLOCKS, rng);
     expect(world.debris.alive).toBe(0);
     expect(world.discBoost).toBeLessThan(0.05);
   });
@@ -54,7 +53,7 @@ describe('world end-to-end (tuning harness)', () => {
     let tick = 0;
     const maxTicks = 120 * 60;
     while (world.body && tick < maxTicks) {
-      const { shredNow } = stepWorld(world, DT, rng, GW_COMPRESSION, TDE_COMPRESSION);
+      const { shredNow } = stepWorld(world, DT, CLOCKS, rng);
       if (shredNow && world.body) {
         shredTick = tick;
         shredR = world.body.pos.length();
diff --git a/src/sim/beacon.ts b/src/sim/beacon.ts
new file mode 100644
index 0000000..bf82b2e
--- /dev/null
+++ b/src/sim/beacon.ts
@@ -0,0 +1,322 @@
+/**
+ * The infalling beacon: a probe released from rest on a radial line and left
+ * to fall. Everything in this module is what a **distant observer** measures.
+ *
+ * That distinction is the feature. To us the probe reddens, dims and stalls
+ * just outside the horizon, and it never finishes falling: the coordinate time
+ * to reach r_s diverges logarithmically, so the gap decays exponentially and
+ * the image freezes. That is a statement about our clock and our light, not
+ * about the probe. On its own clock the probe crosses in finite time (about 28
+ * r_s/c from a release at 7 r_s), notices nothing in particular as it does,
+ * and keeps going. `properTimeAtHorizon` is that finite number, and the
+ * readout shows it beside the diverging coordinate time so the two clocks sit
+ * side by side.
+ *
+ * This is the one moving object in the app on exact Schwarzschild motion
+ * rather than the Paczynski-Wiita potential the bodies and debris use. PW is a
+ * Newtonian stand-in that gets the ISCO right and has no coordinate-time
+ * divergence at all: PW matter crosses r_s in finite time. Reusing
+ * `sim/gravity.ts` here would make the one effect this module exists to show
+ * impossible, so the radial geodesic is integrated directly.
+ *
+ * The integrated state is the horizon gap r - r_s, never r. Near the horizon
+ * the gap decays exponentially; a float64 holding r runs out of significant
+ * digits at gap ~ 1e-16 and snaps the probe onto the horizon it never reaches.
+ * With the gap as the variable the freeze stays physics down to 1e-300 rather
+ * than becoming a rounding artifact.
+ *
+ * Geometric units throughout: c = 1, lengths in r_s, coordinate and proper
+ * times in r_s/c.
+ */
+import { Vector3 } from 'three';
+import { BEACON_TUNING } from '../config';
+import { B_CRIT, R_PHOTON } from '../physics/constants';
+import { clampPlacement } from './placement';
+import type { Beacon } from './types';
+
+/**
+ * Ceiling on one integration step, r_s/c. The exponential tail *is* the
+ * feature, and its rate is what a coarse step biases: near the horizon
+ * dgap/dt = -gap/r_s, and an explicit step of size h reproduces that decay
+ * with a relative rate error of order h. At 0.05 the freeze happens within a
+ * couple of percent of the analytic time constant at any compression setting.
+ */
+export const BEACON_MAX_STEP = 0.05;
+
+/**
+ * Ceiling on the substep count, so the fastest clock setting cannot turn one
+ * tick into an unbounded loop. At the panel's maximum compression of 20 a
+ * 1/60 s tick asks for 7 substeps, so this never binds in practice.
+ */
+export const MAX_BEACON_SUBSTEPS = 24;
+
+/**
+ * Hardest a single step is allowed to shrink the gap. The physics forbids the
+ * probe reaching r_s in finite coordinate time, so no step may place it there;
+ * this guard makes that impossible for any dt, however pathological. It is a
+ * numerical floor, not a physical one, and at the shipped step size it never
+ * engages (a step of 0.05 removes about 5% of the gap, not 99.9%).
+ */
+export const GAP_FLOOR_FRACTION = 1e-3;
+
+/**
+ * Conserved energy per unit mass of a probe released from rest at r0:
+ * E = sqrt(1 - r_s/r0). It is 1 for a release from infinity and 0 at the
+ * horizon, and it sets every other quantity here.
+ */
+export function infallEnergy(r0: number, rs: number): number {
+  return Math.sqrt(Math.max(1 - rs / r0, 0));
+}
+
+/**
+ * The metric factor f = 1 - r_s/r, computed from the gap as gap / (r_s + gap).
+ * Algebraically identical, but it never subtracts two nearly equal numbers, so
+ * it keeps full precision all the way down to the horizon.
+ */
+export function metricFactor(gap: number, rs: number): number {
+  return gap / (rs + gap);
+}
+
+/**
+ * The probe's radial speed on its own clock, |dr/dtau| = sqrt(E^2 - f).
+ *
+ * Evaluated as r_s (fallen distance) / (r r0), which is the same number: E^2
+ * and f agree to fifteen digits at the moment of release, so subtracting them
+ * reports a probe already moving at 1e-8 c before it has been let go, and the
+ * error propagates straight into the redshift.
+ */
+export function properInfallSpeed(gap: number, r0: number, rs: number): number {
+  const fallen = r0 - rs - gap;
+  return Math.sqrt(Math.max((rs * fallen) / ((rs + gap) * r0), 0));
+}
+
+/**
+ * Infall speed a *static observer sitting at r* measures, in units of c. Zero
+ * at release, and it tends to 1 at the horizon: locally the probe really does
+ * arrive at light speed, which is why the recession Doppler below eventually
+ * dominates the reddening.
+ */
+export function localInfallSpeed(gap: number, r0: number, rs: number): number {
+  const energy = infallEnergy(r0, rs);
+  if (energy <= 0) return 0;
+  return properInfallSpeed(gap, r0, rs) / energy;
+}
+
+/**
+ * Growth of that local speed per unit coordinate time. Written out separately
+ * because it is finite and positive at the release radius, where the speed
+ * itself is exactly zero: that is what gets the fall started (see
+ * `advanceHorizonGap`).
+ */
+export function localSpeedGrowth(gap: number, r0: number, rs: number): number {
+  const energy = infallEnergy(r0, rs);
+  if (energy <= 0) return 0;
+  const r = rs + gap;
+  return (rs * metricFactor(gap, rs)) / (2 * energy * energy * r * r);
+}
+
+/**
+ * The gravitational part of the redshift, sqrt(1 - r_s/r): what a *static*
+ * emitter at r would show us. This is the textbook factor, and it is the whole
+ * answer only while the probe is still at rest at its release radius.
+ */
+export function gravitationalRedshift(gap: number, rs: number): number {
+  return Math.sqrt(metricFactor(gap, rs));
+}
+
+/**
+ * Relativistic Doppler factor for a source receding at `speed` (units of c)
+ * from the observer it is emitting toward: sqrt(1 - v^2) / (1 + v). The probe
+ * is falling away from us, so this reddens it further on top of gravity.
+ *
+ * This is the reference statement of that half of the reddening rather than
+ * the code path the app runs: `observedRedshift` evaluates an algebraically
+ * identical form that survives near the horizon, and a test holds the two
+ * together.
+ */
+export function recessionDoppler(speed: number): number {
+  const v = Math.min(Math.max(speed, 0), 1);
+  return Math.sqrt(Math.max(1 - v * v, 0)) / (1 + v);
+}
+
+/**
+ * Received / emitted frequency for the falling probe, seen from far away.
+ *
+ * The honest infaller value, not the static one: the probe is both deep in the
+ * well and receding fast, so the two effects multiply, and this is exactly
+ *
+ *     gravitationalRedshift(gap) * recessionDoppler(localInfallSpeed(gap))
+ *
+ * which a test asserts to twelve digits. It is deliberately not *evaluated*
+ * that way. The probe's local speed reaches 1.0 in float64 at a gap of about
+ * 1e-17, at which point sqrt(1 - v^2) is exactly zero and the product collapses
+ * to zero with it, taking the last decade of the fade with it. The algebraically
+ * identical f / (E + sqrt(E^2 - f)) never subtracts near-equal numbers and stays
+ * accurate past a gap of 1e-300, which is where the freeze has to live.
+ *
+ * Near the horizon it is linear in the gap, g -> gap / (2 E r_s), which is why
+ * the probe fades so much faster than it slows: brightness goes as g^3.
+ */
+export function observedRedshift(gap: number, r0: number, rs: number): number {
+  const energy = infallEnergy(r0, rs);
+  if (energy <= 0) return 0;
+  return metricFactor(gap, rs) / (energy + properInfallSpeed(gap, r0, rs));
+}
+
+/**
+ * dr/dt in Schwarzschild coordinate time (negative, r_s per r_s/c):
+ * -f * v_local. Near the horizon f -> gap / r_s and v_local -> 1, so
+ * dgap/dt -> -gap / r_s and the gap decays as exp(-t / r_s). That exponential
+ * is the freeze, and it falls out of the geodesic rather than being imposed.
+ */
+export function coordinateInfallRate(gap: number, r0: number, rs: number): number {
+  return -metricFactor(gap, rs) * localInfallSpeed(gap, r0, rs);
+}
+
+/**
+ * One midpoint step of the coordinate-time fall.
+ *
+ * The local speed is advanced to the midpoint alongside the radius, rather
+ * than being re-derived from the midpoint radius, and that is not a
+ * refinement: at the release radius the rate is exactly zero and the ODE is
+ * square-root singular there (the drop grows as t^2, so dr/dt goes as
+ * sqrt(drop)). A scheme that only ever samples dr/dt therefore parks the probe
+ * at r0 forever. The speed leaves zero at a finite rate, and stepping it too
+ * reproduces the analytic short-time law drop = E^2 r_s t^2 / (4 r0^2)
+ * exactly on the first step.
+ */
+export function advanceHorizonGap(gap: number, dt: number, r0: number, rs: number): number {
+  const energy = infallEnergy(r0, rs);
+  const floor = gap * GAP_FLOOR_FRACTION;
+  if (energy <= 0) return gap;
+
+  const rate = coordinateInfallRate(gap, r0, rs);
+  const gapMid = Math.max(gap + 0.5 * dt * rate, floor);
+  const speedMid = localInfallSpeed(gap, r0, rs) + 0.5 * dt * localSpeedGrowth(gap, r0, rs);
+  const midRate = -metricFactor(gapMid, rs) * Math.min(speedMid, 1);
+  return Math.max(gap + dt * midRate, floor);
+}
+
+/**
+ * The probe's own elapsed time since release, by the exact cycloid solution
+ *
+ *     tau = (1/2) sqrt(r0^3 / r_s) (eta + sin eta),   cos eta = 2r/r0 - 1
+ *
+ * Closed form on purpose: this is the honesty counterweight to the freeze, so
+ * it is evaluated fresh from the current radius rather than accumulated, and
+ * cannot drift away from the coordinate-time integration beside it.
+ *
+ * dtau/dr is finite at the horizon (it tends to -1/E), so once the gap is
+ * below about 1e-16 the answer equals `properTimeAtHorizon` to every digit a
+ * float64 has. The readout then shows the probe's clock pinned at the crossing
+ * value while ours keeps counting, which is the correct reading of it: on its
+ * own clock the crossing is over, to a precision no display has.
+ */
+export function properTimeSinceRelease(r: number, r0: number, rs: number): number {
+  const eta = Math.acos(Math.min(Math.max((2 * r) / r0 - 1, -1), 1));
+  return 0.5 * Math.sqrt((r0 * r0 * r0) / rs) * (eta + Math.sin(eta));
+}
+
+/**
+ * The probe's own time at the horizon crossing. Finite, always: it crosses,
+ * we simply never see it happen.
+ */
+export function properTimeAtHorizon(r0: number, rs: number): number {
+  return properTimeSinceRelease(rs, r0, rs);
+}
+
+/**
+ * Apparent radius of the probe's image, in impact-parameter units, for a
+ * distant observer.
+ *
+ * A photon leaving radius r perpendicular to the radial direction escapes with
+ * impact parameter b = r / sqrt(1 - r_s/r), and that expression bottoms out at
+ * exactly b_crit = 3 sqrt(3) M at the photon sphere. Inside the photon sphere
+ * the tangential ray is captured and the escaping cone closes onto the radial
+ * direction, so no image can appear inside the shadow: it piles up on the
+ * photon ring instead, which is why a probe near the horizon is seen hugging
+ * the rim rather than sinking through it.
+ *
+ * Honest note: this is exact for the ray at its turning point, and the app
+ * applies it in every viewing geometry as a first-order stand-in. The true
+ * image position needs the deflection integral solved for the observer's
+ * actual direction, which the raymarch pass does for the disc and the star but
+ * which the overlay pass this probe is drawn in cannot.
+ */
+export function apparentImageRadius(r: number, rs: number): number {
+  if (r <= R_PHOTON * rs) return B_CRIT * rs;
+  return r / Math.sqrt(1 - rs / r);
+}
+
+/**
+ * Where a click on the disc plane releases the probe: same azimuth, same
+ * radius, lifted out of the plane by `BEACON_TUNING.inclination`.
+ *
+ * The lift is why the drop is watchable. Released inside the disc plane the
+ * probe spends the whole fall behind the inner glare, and released near the
+ * pole it falls down the jet and through the wind cone.
+ */
+export function releasePoint(clicked: Vector3): Vector3 {
+  const flat = clampPlacement(clicked, BEACON_TUNING.rMin);
+  const radius = flat.length();
+  const incl = BEACON_TUNING.inclination;
+  return new Vector3(
+    flat.x * Math.cos(incl),
+    radius * Math.sin(incl),
+    flat.z * Math.cos(incl),
+  );
+}
+
+/** Everything a distant observer can say about the probe right now. */
+export interface BeaconObservables {
+  /** r - r_s, r_s units. It approaches zero and never reaches it. */
+  horizonGap: number;
+  /** Received / emitted frequency. Drives both the colour and the brightness. */
+  redshift: number;
+  /** Radius the image is drawn at, floored at the photon ring. */
+  apparentRadius: number;
+  /** Our clock since release, r_s/c. Diverges. */
+  coordinateTime: number;
+  /** The probe's clock since release, r_s/c. */
+  probeProperTime: number;
+  /** The probe's clock at the crossing, r_s/c. Finite. */
+  probeProperTimeAtHorizon: number;
+  /** The image has stopped changing perceptibly: the freeze has set in. */
+  settled: boolean;
+}
+
+export function observeBeacon(beacon: Beacon): BeaconObservables {
+  const { horizonGap, r0, horizonRs } = beacon;
+  const r = horizonRs + horizonGap;
+  return {
+    horizonGap,
+    redshift: observedRedshift(horizonGap, r0, horizonRs),
+    apparentRadius: apparentImageRadius(r, horizonRs),
+    coordinateTime: beacon.coordinateTime,
+    probeProperTime: properTimeSinceRelease(r, r0, horizonRs),
+    probeProperTimeAtHorizon: properTimeAtHorizon(r0, horizonRs),
+    settled: horizonGap < BEACON_TUNING.settledGap * horizonRs,
+  };
+}
+
+/**
+ * Advance the probe by `dt` of the distant observer's time.
+ *
+ * There is no result to return, and that is the point: nothing ever happens to
+ * this object. It is never swallowed, never consumed, never removed. Only
+ * `clearBeacon` takes it out of the scene.
+ *
+ * `rs` is not a parameter. The whole solution is anchored to the r_s the probe
+ * was released against, and letting a caller step it against a different one
+ * would silently produce a trajectory that is not a geodesic of any spacetime.
+ * world.ts drops the beacon instead when a merger moves the horizon.
+ */
+export function stepBeacon(beacon: Beacon, dt: number): void {
+  const substeps = Math.min(Math.max(1, Math.ceil(dt / BEACON_MAX_STEP)), MAX_BEACON_SUBSTEPS);
+  const subDt = dt / substeps;
+  for (let step = 0; step < substeps; step++) {
+    beacon.horizonGap = advanceHorizonGap(beacon.horizonGap, subDt, beacon.r0, beacon.horizonRs);
+  }
+  beacon.coordinateTime += dt;
+  beacon.pos.copy(beacon.direction).multiplyScalar(beacon.horizonRs + beacon.horizonGap);
+}
diff --git a/src/sim/types.ts b/src/sim/types.ts
index 999a0f4..9ad1b4d 100644
--- a/src/sim/types.ts
+++ b/src/sim/types.ts
@@ -60,6 +60,37 @@ export interface BinaryState {
   rsFinal: number;
 }
 
+/**
+ * A probe released from rest on a radial line and falling in (see beacon.ts).
+ * State lives here, behaviour lives in beacon.ts, the way Body/body.ts and
+ * BinaryState/binary.ts are split.
+ */
+export interface Beacon {
+  /**
+   * Unit vector from the hole to the release point. Radial free fall never
+   * leaves this ray, so one direction covers the whole trajectory.
+   */
+  readonly direction: Vector3;
+  /**
+   * The integrated state is r - r_s, not r. Near the horizon the gap decays
+   * exponentially, and a float64 holding r would exhaust its significant
+   * digits at gap ~ 1e-16 and snap the probe onto the horizon it never
+   * reaches.
+   */
+  horizonGap: number;
+  /** Release radius, where it was let go at rest. */
+  readonly r0: number;
+  /**
+   * The primary r_s this solution was built against. A merger moves the
+   * horizon, which invalidates the fall entirely (see stepWorld).
+   */
+  readonly horizonRs: number;
+  /** Distant-observer time since release, r_s/c. Diverges as it falls. */
+  coordinateTime: number;
+  /** True Schwarzschild coordinate position, derived each tick. */
+  pos: Vector3;
+}
+
 /**
  * Structure-of-arrays particle pool, preallocated at capacity. The render
  * layer wraps these exact arrays in BufferAttributes (zero copy); the first
@@ -85,6 +116,11 @@ export interface World {
   body: Body | null;
   /** Secondary hole on a GW inspiral, or null when there is none. */
   binary: BinaryState | null;
+  /**
+   * The infalling probe, or null. Independent of `body`: a star being torn
+   * apart and a probe freezing at the horizon can share the scene.
+   */
+  beacon: Beacon | null;
   /** Primary Schwarzschild radius; 1 initially, grows after a merger. */
   primaryRs: number;
   debris: DebrisPool;
diff --git a/src/sim/world.ts b/src/sim/world.ts
index 582e26c..e0dda87 100644
--- a/src/sim/world.ts
+++ b/src/sim/world.ts
@@ -5,8 +5,16 @@
  * feeding, all pure CPU math.
  */
 import { Vector3 } from 'three';
-import { BINARY_TUNING, BODY_TUNING, DEBRIS_TUNING, DISC_TUNING, TDE_TUNING } from '../config';
+import {
+  BEACON_TUNING,
+  BINARY_TUNING,
+  BODY_TUNING,
+  DEBRIS_TUNING,
+  DISC_TUNING,
+  TDE_TUNING,
+} from '../config';
 import type { TdeMode } from '../settings';
+import { stepBeacon } from './beacon';
 import { createBinary, stepBinary, stepRingdown } from './binary';
 import { stepBody } from './body';
 import { createPool, spawnFromBody, updatePool, type Rng } from './debris';
@@ -23,13 +31,36 @@ export interface WorldEvents {
   shredNow: boolean;
   /** A realistic-mode remnant escaped and was removed this tick. */
   bodyEscaped: boolean;
+  /** A merger moved the horizon out from under the beacon, so it was removed. */
+  beaconLost: boolean;
 }
 
+/**
+ * The three compressed clocks, named rather than positional. Three trailing
+ * numbers on `stepWorld` would have read as `stepWorld(world, dt, rng, 40, 1, 3)`
+ * at the call site, which says nothing about which clock is which.
+ */
+export interface SimClocks {
+  /** Wall-clock compression of the binary inspiral. */
+  readonly gw: number;
+  /** Wall-clock compression of a disruption and its debris. */
+  readonly tde: number;
+  /** Wall-clock compression of the distant observer's clock for the beacon. */
+  readonly beacon: number;
+}
+
+export const DEFAULT_CLOCKS: SimClocks = Object.freeze({
+  gw: BINARY_TUNING.timeCompression,
+  tde: BODY_TUNING.timeCompression,
+  beacon: BEACON_TUNING.timeCompression,
+});
+
 export function createWorld(maxParticles: number = DEBRIS_TUNING.maxParticles): World {
   return {
     time: 0,
     body: null,
     binary: null,
+    beacon: null,
     primaryRs: 1,
     debris: createPool(maxParticles),
     discBoost: 0,
@@ -116,6 +147,36 @@ export function clearBody(world: World): void {
   world.body = null;
 }
 
+/**
+ * Release (or re-release) the probe from rest at `release`, which is already
+ * the lifted release point (`beacon.releasePoint` puts it there). The fall is
+ * a closed-form Schwarzschild solution anchored to the primary r_s at this
+ * moment, so that radius is snapshotted with it.
+ */
+export function placeBeacon(world: World, release: Vector3): void {
+  const rs = world.primaryRs;
+  const r0 = release.length();
+  if (r0 <= rs) {
+    throw new Error(`placeBeacon needs a release radius (${r0}) outside r_s (${rs})`);
+  }
+  world.beacon = {
+    direction: release.clone().multiplyScalar(1 / r0),
+    horizonGap: r0 - rs,
+    r0,
+    horizonRs: rs,
+    coordinateTime: 0,
+    pos: release.clone(),
+  };
+}
+
+/**
+ * Take the probe out of the scene. Nothing else ever will: it is never
+ * swallowed and never expires, because never finishing the fall is the point.
+ */
+export function clearBeacon(world: World): void {
+  world.beacon = null;
+}
+
 /**
  * Empty the scene: no body, no secondary, no debris, no leftover feeding.
  * A ringdown in progress is settled first, so the primary keeps the mass it
@@ -125,6 +186,7 @@ export function resetScene(world: World): void {
   if (world.binary?.phase === 'ringdown') world.primaryRs = world.binary.rsFinal;
   world.body = null;
   world.binary = null;
+  world.beacon = null;
   world.debris.alive = 0;
   world.spawnAcc = 0;
   world.discBoost = 0;
@@ -160,15 +222,18 @@ const MAX_BODY_STEP = 0.1;
 const MAX_BODY_SUBSTEPS = 6;
 
 /**
- * One tick. Two clocks run inside it:
+ * One tick. Three clocks run inside it:
  *
- * - `gwCompression` for the binary inspiral. Exact: `stepBinary` advances
+ * - `clocks.gw` for the binary inspiral. Exact: `stepBinary` advances
  *   closed-form Peters and Kepler quantities, so only the clock changes.
- * - `tdeCompression` for the body and its debris. A circular orbit at 12 r_s
+ * - `clocks.tde` for the body and its debris. A circular orbit at 12 r_s
  *   takes ~370 time units, so at 1:1 a disruption unfolds over ten minutes and
  *   the debris never completes a turn, so the stream reads as a scattering of
  *   dots instead of the wound spiral it is. Substepped to `MAX_BODY_STEP` so
  *   the compressed trajectory matches the uncompressed one.
+ * - `clocks.beacon` for the infalling probe, and never the disruption clock,
+ *   however tempting sharing one would be: the beacon's clock *is* the distant
+ *   observer's clock, which is the quantity the whole feature is showing.
  *
  * The disc keeps the uncompressed clock: it is a background, and shearing it
  * twenty times faster would turn it into a pinwheel.
@@ -176,15 +241,19 @@ const MAX_BODY_SUBSTEPS = 6;
 export function stepWorld(
   world: World,
   dt: number,
+  clocks: SimClocks = DEFAULT_CLOCKS,
   rng: Rng = Math.random,
-  gwCompression: number = BINARY_TUNING.timeCompression,
-  tdeCompression: number = BODY_TUNING.timeCompression,
 ): WorldEvents {
-  const events: WorldEvents = { mergerNow: false, shredNow: false, bodyEscaped: false };
+  const events: WorldEvents = {
+    mergerNow: false,
+    shredNow: false,
+    bodyEscaped: false,
+    beaconLost: false,
+  };
 
   const binary = world.binary;
   if (binary?.phase === 'inspiral') {
-    events.mergerNow = stepBinary(binary, world.primaryRs, dt, gwCompression).mergedNow;
+    events.mergerNow = stepBinary(binary, world.primaryRs, dt, clocks.gw).mergedNow;
   } else if (binary?.phase === 'ringdown' && stepRingdown(binary, dt)) {
     world.primaryRs = binary.rsFinal;
     world.binary = null;
@@ -198,7 +267,7 @@ export function stepWorld(
         : null,
   };
 
-  const bodyDt = dt * tdeCompression;
+  const bodyDt = dt * clocks.tde;
   const substeps = Math.min(Math.max(1, Math.ceil(bodyDt / MAX_BODY_STEP)), MAX_BODY_SUBSTEPS);
   const subDt = bodyDt / substeps;
   let absorbed = 0;
@@ -232,6 +301,18 @@ export function stepWorld(
     absorbed += updatePool(world.debris, subDt, world.debrisHeatFloor, env).absorbed;
   }
 
+  const beacon = world.beacon;
+  if (beacon && beacon.horizonRs !== world.primaryRs) {
+    // A merger moved the horizon. The probe's whole trajectory is a closed-form
+    // solution anchored to the r_s it was released against, and there is no
+    // honest way to re-anchor a fall already in progress to a bigger hole, so
+    // it is removed and the readout says why.
+    world.beacon = null;
+    events.beaconLost = true;
+  } else if (beacon) {
+    stepBeacon(beacon, dt * clocks.beacon);
+  }
+
   if (absorbed > 0) {
     world.discBoost = creditFeed(world.discBoost, absorbed * world.feedPerParticle);
   }
diff --git a/src/ui/panel.ts b/src/ui/panel.ts
index f303a87..8fca7a6 100644
--- a/src/ui/panel.ts
+++ b/src/ui/panel.ts
@@ -19,7 +19,9 @@ export interface PanelActions {
   placePlanet(): void;
   placeStar(): void;
   placeBlackHole(): void;
+  placeBeacon(): void;
   clearBody(): void;
+  clearBeacon(): void;
   clearPaths(): void;
   onPhotonsToggled(enabled: boolean): void;
   onQualityChange(quality: QualityPreset): void;
@@ -116,10 +118,18 @@ export function buildPanel(
     scene.add(actions, 'placeBlackHole').name('Second black hole'),
     'Arms placement, then click the disc plane. Its orbit decays by gravitational waves until the pair merges; both holes bend light.',
   );
+  explain(
+    scene.add(actions, 'placeBeacon').name('Beacon (freezes at the horizon)'),
+    'Arms placement, then click the disc plane. A probe is released from rest above that point and falls straight in. You watch it redden, dim and stall just outside the shadow. It never finishes falling, for you. On its own clock it crosses in seconds, and the readout shows both clocks side by side.',
+  );
   explain(
     scene.add(actions, 'clearBody').name('Remove body'),
     'Removes the body immediately. Debris already shed keeps draining into the disc.',
   );
+  explain(
+    scene.add(actions, 'clearBeacon').name('Remove beacon'),
+    'Takes the probe out of the scene. Otherwise it stays forever: never finishing the fall is the whole point.',
+  );
   explain(
     scene
       .add(settings, 'tdeMode', {
@@ -147,6 +157,10 @@ export function buildPanel(
     playback.add(settings, 'tdeTimeCompression', 1, 60, 1).name('Disruption speed'),
     'Wall-clock compression of a disruption and its debris. Same trick as the inspiral clock: the orbits are exact, the clock is fast, at 1:1 the debris would take ten minutes to complete one lap around the hole.',
   );
+  explain(
+    playback.add(settings, 'beaconTimeCompression', 1, 20, 1).name('Beacon fall speed'),
+    "Wall-clock compression of the distant observer's clock for the probe. Same trick as the inspiral and disruption clocks: scaling that clock uniformly speeds up the fall and the stall together, so the shape of the freeze is untouched. At 1:1 a drop from 7 rₛ takes about forty seconds to fade out.",
+  );
   addResetButton(
     playback,
     () => {
@@ -154,8 +168,9 @@ export function buildPanel(
       settings.timeScale = shipped.timeScale;
       settings.gwTimeCompression = shipped.gwTimeCompression;
       settings.tdeTimeCompression = shipped.tdeTimeCompression;
+      settings.beaconTimeCompression = shipped.beaconTimeCompression;
     },
-    'Back to running, speed ×1, and the default inspiral and disruption clocks.',
+    'Back to running, speed ×1, and the default inspiral, disruption and beacon clocks.',
   );
 
   const camera = gui.addFolder('Camera');
@@ -229,6 +244,20 @@ export function buildPanel(
   );
   jet.close();
 
+  const beacon = gui.addFolder('Infalling beacon');
+  explain(
+    beacon.add(settings, 'beaconBrightness', 0.2, 20, 0.1).name('Brightness'),
+    'Exposure for the probe. Its real brightness falls as the cube of the redshift, nine decades between release and the point where it stops moving, so no single exposure can show the whole fall. Turn this up to follow it further in.',
+  );
+  addResetButton(
+    beacon,
+    () => {
+      settings.beaconBrightness = shipped.beaconBrightness;
+    },
+    'Default beacon exposure.',
+  );
+  beacon.close();
+
   // Sky sliders re-bake a cubemap, so they fire on release, not on drag.
   const sky = gui.addFolder('Deep sky');
   explain(
diff --git a/src/ui/placement.ts b/src/ui/placement.ts
index a6a9e51..dfe0b8a 100644
--- a/src/ui/placement.ts
+++ b/src/ui/placement.ts
@@ -1,28 +1,48 @@
 /**
- * Click-to-place a planet, star, or secondary black hole: a translucent
- * ghost follows the cursor on the disc plane (clamped to the allowed ring),
- * click confirms, Esc or right-click cancels. Orbit controls are suspended
- * while placing. What happens on confirm is the caller's business (placeBody
- * vs placeBinary), delivered through the onPlace callback.
+ * Click-to-place a planet, star, secondary black hole, or infalling beacon: a
+ * translucent ghost follows the cursor on the disc plane (clamped to the
+ * allowed ring), click confirms, Esc or right-click cancels. Orbit controls
+ * are suspended while placing. What happens on confirm is the caller's
+ * business (placeBody vs placeBinary vs placeBeacon), delivered through the
+ * onPlace callback.
  */
 import * as THREE from 'three';
 import type { OrbitControls } from 'three/addons/controls/OrbitControls.js';
-import { BINARY_TUNING, BODY_TUNING, PLACEMENT_TUNING } from '../config';
+import { BEACON_TUNING, BINARY_TUNING, BODY_TUNING, PLACEMENT_TUNING } from '../config';
+import { releasePoint } from '../sim/beacon';
 import { clampPlacement } from '../sim/placement';
 
-/** What can be placed: the two disruptable bodies, or the secondary hole. */
-export type PlaceKind = 'planet' | 'star' | 'bh2';
+/**
+ * What can be placed: the two disruptable bodies, the secondary hole, or the
+ * probe that falls in and freezes.
+ */
+export type PlaceKind = 'planet' | 'star' | 'bh2' | 'beacon';
 
 interface KindLook {
   color: number;
   radius: number;
   rMin: number;
+  /**
+   * Where this kind actually appears, given a point on the disc plane. The
+   * beacon is released off the plane, so its ghost has to sit where the probe
+   * will be, and the geometry that decides that stays in sim/beacon.ts rather
+   * than leaking into this controller.
+   */
+  spawnPoint?: (flat: THREE.Vector3) => THREE.Vector3;
 }
 
 const KIND_LOOKS: Record<PlaceKind, KindLook> = {
   planet: { color: 0xb08a63, radius: BODY_TUNING.planetRadius, rMin: PLACEMENT_TUNING.rMin },
   star: { color: 0xffd9a0, radius: BODY_TUNING.starRadius, rMin: PLACEMENT_TUNING.rMin },
   bh2: { color: 0x5577aa, radius: BINARY_TUNING.massRatio, rMin: PLACEMENT_TUNING.bh2RMin },
+  beacon: {
+    color: 0x9fd8ff,
+    // Drawn much larger than the probe itself: the ghost is a target marker,
+    // and a 0.06 r_s ball is invisible to aim with.
+    radius: 0.35,
+    rMin: BEACON_TUNING.rMin,
+    spawnPoint: releasePoint,
+  },
 };
 
 function makeRing(radius: number, opacity: number): THREE.Mesh {
@@ -106,7 +126,9 @@ export class PlacementController {
     );
     this.raycaster.setFromCamera(ndc, this.camera);
     if (!this.raycaster.ray.intersectPlane(this.plane, this.hitPoint)) return false;
-    this.ghost.position.copy(clampPlacement(this.hitPoint, KIND_LOOKS[this.kind].rMin));
+    const look = KIND_LOOKS[this.kind];
+    const flat = clampPlacement(this.hitPoint, look.rMin);
+    this.ghost.position.copy(look.spawnPoint ? look.spawnPoint(flat) : flat);
     return true;
   }
 
diff --git a/src/ui/presets.ts b/src/ui/presets.ts
index d48de70..4860f88 100644
--- a/src/ui/presets.ts
+++ b/src/ui/presets.ts
@@ -37,6 +37,8 @@ export interface Preset {
       | 'timeScale'
       | 'gwTimeCompression'
       | 'tdeTimeCompression'
+      | 'beaconTimeCompression'
+      | 'beaconBrightness'
       | 'discEnabled'
       | 'discBrightness'
       | 'jetEnabled'
@@ -50,6 +52,9 @@ export interface Preset {
   > & { sky?: Partial<SkySettings> };
   body: ({ kind: BodyKind } & Placement) | null;
   binary: Placement | null;
+  /** Where to release the infalling probe. Its lift out of the plane is
+   *  sim/beacon.ts's business, so only the plane position is given here. */
+  beacon: Placement | null;
   camera: CameraPose;
   /** Start a camera flight once the scene is set. */
   tour?: TourKind;
@@ -67,6 +72,7 @@ export const PRESETS: readonly Preset[] = [
     look: { tdeMode: 'realistic', discEnabled: true, discBrightness: 1.0, jetEnabled: false, gridEnabled: false, timeScale: 1, bloomStrength: 1.1 },
     body: { kind: 'star', radius: 14, angle: 2.5 },
     binary: null,
+    beacon: null,
     camera: { distance: 27, elevation: 0.25, azimuth: 1.4 },
     cinematic: false,
   },
@@ -78,6 +84,7 @@ export const PRESETS: readonly Preset[] = [
     look: { tdeMode: 'cinematic', discEnabled: true, discBrightness: 0.8, jetEnabled: false, gridEnabled: false, timeScale: 1.4, bloomStrength: 1.0 },
     body: { kind: 'planet', radius: 11, angle: 0.4 },
     binary: null,
+    beacon: null,
     camera: { distance: 22, elevation: 0.30, azimuth: 1.9 },
     cinematic: false,
   },
@@ -89,6 +96,7 @@ export const PRESETS: readonly Preset[] = [
     look: { discEnabled: true, discBrightness: 0.55, jetEnabled: false, gridEnabled: true, gridOpacity: 0.5, gwTimeCompression: 40, timeScale: 1, bloomStrength: 1.0 },
     body: null,
     binary: { radius: 13, angle: 0.0 },
+    beacon: null,
     camera: { distance: 30, elevation: 0.5, azimuth: 0.9 },
     cinematic: false,
   },
@@ -100,6 +108,7 @@ export const PRESETS: readonly Preset[] = [
     look: { discEnabled: false, jetEnabled: false, gridEnabled: true, gridOpacity: 0.6, bloomStrength: 0.8 },
     body: null,
     binary: null,
+    beacon: null,
     camera: { distance: 34, elevation: 0.62, azimuth: 0.4 },
     cinematic: false,
   },
@@ -111,9 +120,25 @@ export const PRESETS: readonly Preset[] = [
     look: { discEnabled: true, discBrightness: 1.3, jetEnabled: true, jetStrength: 1.3, gridEnabled: false, bloomStrength: 1.2 },
     body: null,
     binary: null,
+    beacon: null,
     camera: { distance: 26, elevation: 0.12, azimuth: 2.2 },
     cinematic: false,
   },
+  {
+    id: 'frozen',
+    name: 'A probe frozen at the horizon',
+    description:
+      'A beacon dropped from rest. It reddens, dims and stalls just outside the shadow instead of crossing. That is what you see; on its own clock it crossed seconds later and felt nothing.',
+    // Disc dimmed and outflow off: the probe ends up on the shadow rim, where
+    // the inner disc and the photon ring are the brightest things in frame,
+    // and by then it is nine decades fainter than it started.
+    look: { discEnabled: true, discBrightness: 0.5, jetEnabled: false, windEnabled: false, gridEnabled: false, timeScale: 1, beaconTimeCompression: 3, beaconBrightness: 3.5, bloomStrength: 1.3 },
+    body: null,
+    binary: null,
+    beacon: { radius: 7, angle: 0.9 },
+    camera: { distance: 16, elevation: 0.22, azimuth: 1.1 },
+    cinematic: false,
+  },
   {
     id: 'wallpaper',
     name: 'Wallpaper (hides the UI)',
@@ -122,6 +147,7 @@ export const PRESETS: readonly Preset[] = [
     look: { discEnabled: true, discBrightness: 1.0, jetEnabled: false, gridEnabled: false, bloomStrength: 1.25, sky: { nebulaIntensity: 1.2, deepSkyIntensity: 1.2 } },
     body: null,
     binary: null,
+    beacon: null,
     camera: { distance: 19, elevation: 0.16, azimuth: 1.2 },
     cinematic: true,
   },

From 62ed14e553a0c356a1b9f438755713b874fb8e75 Mon Sep 17 00:00:00 2001
From: Ashish Nagar <ashishnagar31@gmail.com>
Date: Fri, 31 Jul 2026 16:13:47 -0400
Subject: [PATCH 3/4] Add Kerr spin, camera aberration, and image-order tinting

Spin is the largest realism gap this app had: real holes turn, and every
consequence of that is visible. Rather than bolt a gravitomagnetic term onto
the existing deflection, the shader and the CPU integrator now solve the exact
Kerr metric in Cartesian Kerr-Schild form as a Hamiltonian system on (x, p).
Kerr-Schild is the coordinate system that survives the horizon and its
Cartesian layout matches the march the app already had, so the disc-crossing
test, the body intersection and the uniforms are untouched.

Everything the brief asks to follow from the spin does follow from it: the
outer horizon, the frame dragging that makes the shadow lopsided, the prograde
ISCO moving in so the disc's inner edge moves with it, and the photon sphere
splitting into prograde and retrograde radii. Nothing is faked. The closed
forms live in physics/kerr.ts and are pinned against the shipped Schwarzschild
constants at a = 0, against the known extremal limits at a/M = 1, and against
the integrator's own turning points, which is what stops the two from drifting.

Spin 0 keeps the shipped image bit for bit. The a = 0 expressions are branched
rather than unified because the Kerr forms are analytically identical there and
not identical in floating point, and the old frame is a promise. That branch
carries a comment saying exactly this, and a test asserts spin 0 equals the
no-spin call.

Camera flights now aberrate. The boost is applied once per pixel to the initial
ray direction, so the shadow, the ring, the disc and the sky move together;
aberrating only the sky sample would slide the star field while the shadow
stayed put. The speed is not the derivative of the camera path, because the
flights run on a compressed clock that is superluminal in these units. Each
move publishes the physical speed of the trajectory it stands for instead: the
circular-orbit speed for the orbit, free fall from infinity for the pass and
the plunge. Both are already derived in THEORY.md. At rest the transformation
is the identity by construction rather than by a threshold.

Image-order tinting is a diagnostic overlay, off by default, that classifies
the disc by accumulated winding angle rather than by counting plane crossings:
a straight unlensed ray from a camera above the plane crosses the plane once,
so a crossing counter would call it a first-order image.

Two corrections to what was planned. The plan quoted b_crit, the ISCO and the
photon radius at a/M = 0.998 from a rougher evaluation; the tooltip and the
docs now carry the values the shipped closed forms actually produce, asserted
by a test so they cannot go stale. The plan also asserted a ZAMO speed of 0.5
at the 0.998 ISCO; 0.5 is the extremal limit and the value at 0.998 is 0.565,
so the test takes the limit instead.

Debris now reads its absorb and kill radii from the environment rather than
multiplying art constants by r_s. That is a correctness fix, not polish: at
high spin the old kill radius of 1.05 r_s sits outside a disc that reaches
0.62 r_s, so debris would vanish before it could be credited to the feed.

Kerr is a one-hole solution, so a second hole forces the spin to 0 in three
places that have to agree: the shader marches one center, the CPU integrator
throws, and the slider disables itself with a note. THEORY.md owns the
consequence, that a merger currently leaves a non-spinning remnant.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 README.md                                   |  25 +-
 docs/THEORY.md                              | 225 +++++++++++-
 src/config.ts                               |   5 +-
 src/interact/aiming.ts                      |  16 +-
 src/main.ts                                 | 108 +++++-
 src/physics/__tests__/geodesic.test.ts      | 351 ++++++++++++++++++-
 src/physics/__tests__/imageOrder.test.ts    |  55 +++
 src/physics/__tests__/kerr.test.ts          | 234 +++++++++++++
 src/physics/__tests__/relativity.test.ts    | 130 +++++++
 src/physics/constants.ts                    |  44 ++-
 src/physics/geodesic.ts                     | 370 +++++++++++++++++++-
 src/physics/imageOrder.ts                   |  59 ++++
 src/physics/kerr.ts                         | 168 +++++++++
 src/physics/relativity.ts                   |  86 +++++
 src/render/__tests__/tourKinematics.test.ts |  93 +++++
 src/render/blackHolePass.ts                 |  51 ++-
 src/render/cameraTour.ts                    |  91 ++++-
 src/render/photonPaths.ts                   |  31 +-
 src/render/shaders/geodesic.frag            | 243 +++++++++++--
 src/render/shaders/kerr.glsl                | 123 +++++++
 src/render/tourKinematics.ts                |  34 ++
 src/settings.ts                             |  23 ++
 src/sim/__tests__/debris.test.ts            |  52 ++-
 src/sim/debris.ts                           |  16 +-
 src/sim/gravity.ts                          |  16 +-
 src/sim/types.ts                            |   7 +
 src/sim/world.ts                            |  28 ++
 src/ui/panel.ts                             |  58 ++-
 src/ui/presets.ts                           |  14 +
 29 files changed, 2634 insertions(+), 122 deletions(-)
 create mode 100644 src/physics/__tests__/imageOrder.test.ts
 create mode 100644 src/physics/__tests__/kerr.test.ts
 create mode 100644 src/physics/__tests__/relativity.test.ts
 create mode 100644 src/physics/imageOrder.ts
 create mode 100644 src/physics/kerr.ts
 create mode 100644 src/physics/relativity.ts
 create mode 100644 src/render/__tests__/tourKinematics.test.ts
 create mode 100644 src/render/shaders/kerr.glsl
 create mode 100644 src/render/tourKinematics.ts

diff --git a/README.md b/README.md
index 05181eb..45e31dc 100644
--- a/README.md
+++ b/README.md
@@ -4,14 +4,14 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178c6?logo=typescript&logoColor=white)](tsconfig.json)
 [![Three.js](https://img.shields.io/badge/Three.js-r185-000000?logo=three.js&logoColor=white)](https://threejs.org)
 [![Vite](https://img.shields.io/badge/Vite-8-646cff?logo=vite&logoColor=white)](https://vite.dev)
-[![Tests](https://img.shields.io/badge/tests-51%20passing-brightgreen)](src/sim/__tests__)
+[![Tests](https://img.shields.io/badge/tests-100%20passing-brightgreen)](src/sim/__tests__)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 ### [Open it in your browser](https://algometrix.github.io/blackhole-sim/)
 
 No install, no account. It needs WebGL2, which every current desktop browser has.
 
-An interactive black hole visualizer that ray-traces **real Schwarzschild photon geodesics on the GPU**, per pixel, every frame. It renders the event horizon shadow, the photon ring, a Doppler-beamed accretion disc bent over and under the hole (the *Interstellar* look), and a gravitationally lensed starfield. You can launch photons and watch their true paths, drop a planet or star and watch it be tidally shredded, and place a second black hole to watch a gravitational-wave inspiral end in a merger, complete with a LIGO-style audio chirp.
+An interactive black hole visualizer that ray-traces **real photon geodesics on the GPU**, per pixel, every frame, in Schwarzschild or in the exact Kerr metric of a spinning hole. It renders the event horizon shadow, the photon ring, a Doppler-beamed accretion disc bent over and under the hole (the *Interstellar* look), and a gravitationally lensed starfield. You can launch photons and watch their true paths, drop a planet or star and watch it be tidally shredded, and place a second black hole to watch a gravitational-wave inspiral end in a merger, complete with a LIGO-style audio chirp.
 
 Everything runs in the browser. No backend, no textures, no libraries beyond Three.js: the stars, disc, physics, and sound are all procedural.
 
@@ -27,7 +27,10 @@ Everything runs in the browser. No backend, no textures, no libraries beyond Thr
 
 - **Real GR light bending**: each pixel integrates the Schwarzschild null-geodesic equation with RK4 and adaptive stepping. The shadow, photon ring, Einstein-ring star smearing, and the disc's secondary images emerge from the math, not from textures.
 - **Accretion disc**: Shakura–Sunyaev temperature profile, differential-rotation noise that shears into trailing spirals, relativistic Doppler + gravitational redshift using the bent photon direction (correct even for the lensed secondary image).
+- **Spin (Kerr)**: turn the hole up to the Thorne limit, $a/M = 0.998$, and the exact Kerr metric is ray traced in Cartesian Kerr-Schild form. Everything follows from the one number: the horizon shrinks to $0.53\,r_s$, frame dragging pulls the approaching edge of the shadow in to $1.06\,r_s$ while the receding edge swings out to $3.50\,r_s$ (the D shape), the photon sphere splits into prograde and retrograde radii, and the disc's inner edge follows the last stable orbit in from $3\,r_s$ to $0.62\,r_s$. Spin 0 reproduces the Schwarzschild image exactly.
 - **Interactive photon trajectories**: click to launch fans of photons; escaped, captured, and near-critical rays are drawn as glowing curves computed by the same integrator the shader uses.
+- **Image order overlay**: colour the disc by how many half turns the light made before it reached you, a diagnostic that separates the direct image, the first lensed image and the photon ring.
+- **Relativistic camera**: during a scripted flight the star field aberrates toward the direction of travel and the sky ahead blueshifts and brightens while the sky behind reddens, computed from the physical speed of the trajectory the flight stands for. Exactly off when the camera is at rest.
 - **Tidal disruption**: place a planet or star. *Cinematic* mode gives a directable inward spiral with spaghettification and a debris stream that feeds and brightens the disc. *Realistic TDE* mode launches a true zero-energy parabolic plunge, one violent shredding at pericenter, and a physically motivated bound/unbound debris split (roughly half the debris escapes, as in real TDEs).
 - **Black hole merger**: place a second hole. Its orbit decays by the actual Peters (1964) gravitational-wave equations (the trajectory shape is exact; only wall-clock time is compressed). Both holes lens light. At contact the shadow swells to the merged mass minus the radiated gravitational-wave energy, with a ringdown wobble.
 - **Deep sky**: the background is a procedurally baked HDR cubemap. Five layers of stars on a stellar-temperature colour sequence (the bright ones get diffraction spikes), a warped galactic band with dust lanes that actually extinguish the stars behind them, emission nebulae in hydrogen red and doubly-ionised-oxygen teal, globular clusters that crowd extra stars into their cores, and distant galaxies with dust lanes and spiral arms. All of it is lensed by the same geodesics, so it smears into Einstein arcs near the shadow.
@@ -120,7 +123,7 @@ You need two things: **Node.js** (version 20 or newer) and this repository. That
 ### Other commands
 
 ```bash
-npm test           # run the 51-test physics/simulation suite
+npm test           # run the 100-test physics/simulation suite
 npm run typecheck  # strict TypeScript check
 npm run build      # production build into dist/
 npm run preview    # serve the production build
@@ -138,8 +141,11 @@ npm run preview    # serve the production build
 | Choose disruption physics | **Place → Disruption mode**: cinematic spiral vs realistic one-pass TDE |
 | Place a second black hole | **Place → Place black hole** → click; watch the inspiral chirp in the HUD |
 | Speed up / slow the inspiral | **Simulation → GW time ×** |
+| Spin the hole | **Black hole → Spin (a/M)**; the readout reports the horizon, ISCO and both photon-ring radii as you drag |
 | Launch photons | **Light paths → Enabled**, then click anywhere; rays per launch and spread are sliders |
+| See which lensed image is which | **Light rays → Tint image orders** (diagnostic; off by default) |
 | Camera flights | **Camera** folder: fly in (plunge), fly past, circle; `Esc` stops |
+| Relativistic optics on a flight | **Camera → Relativistic view**, with a flight-speed slider next to it |
 | Sound | **Sound → Enabled** (browsers require one click on the page first) |
 | Change the sky | **Deep sky** folder: star density, nebulae, galaxies, or reseed the whole thing |
 | Art-direction knobs | append `?debug=1` to the URL for the hidden tuning folder |
@@ -273,16 +279,20 @@ Every noise lookup is rotated by a fixed non-axis-aligned frame, because value n
 - The full spacetime of two holes requires numerical relativity; this app superposes two Schwarzschild deflections, which is qualitatively right (double shadows, eyebrow images) but not exact in the final strong-field moments. The ringdown "breathing" of the shadow is art-directed shorthand for quasi-normal ringing.
 - The cinematic disruption mode is deliberately directable (drag-driven inspiral, fixed tidal radii): physics-inspired theater, not a simulation. Realistic mode is the honest one.
 - Debris particles are occluded by the horizon and approximately deflected, but not fully ray-traced.
-- No black hole spin (Schwarzschild, not Kerr) and no light travel-time delay.
+- Spin is exact for the light, but not for the matter: debris and bodies stay Paczyński–Wiita (a Schwarzschild pseudo-potential), and only their boundaries (the disc's inner edge, the kill radius) move with the spin. Kerr is a one-hole solution, so placing a second hole forces the spin to 0, which also means a merger leaves a non-spinning remnant where a real equal-mass merger leaves $a/M \approx 0.69$.
+- No light travel-time delay: you see the whole disc at one instant rather than each part as it was when its light left.
+- The camera's relativistic colour shift is a per-channel RGB gain, not a spectral shift, and the overlay pass (debris, drawn rays, curvature grid) is not aberrated, so occlusion near the shadow edge is slightly wrong during a fast flight.
 - The disrupted body is drawn as a teardrop, the tidal silhouette, not a hydrodynamic result, and the feeding outflow is likewise a shape and a colour, driven by the disc's feed rate rather than by radiation transport.
-- The jet is art direction, not magnetohydrodynamics: a Schwarzschild hole has no Blandford–Znajek spin to tap. Its geometry, filaments and plasma speed are chosen; the Doppler beaming between the two cones and the lensing of the beams are computed.
+- The jet is art direction, not magnetohydrodynamics: Blandford–Znajek needs a magnetic field as well as spin, so the jet does not strengthen when you spin the hole up or fade when you spin it down. Its geometry, filaments and plasma speed are chosen; the Doppler beaming between the two cones and the lensing of the beams are computed.
 - The curvature funnel is an embedding diagram of one spatial slice, the standard picture, not a picture of "gravity pulling down". The wave ripple shows the strain pattern, exaggerated far beyond any real $h \sim 10^{-21}$.
 - The deep sky is invented. It follows real structure (a luminosity function skewed to faint stars, hotter stars bluer and brighter, dust that reddens and extinguishes, clusters, galaxies) but it is not a star catalogue.
 
 ## Architecture
 
 ```
-src/physics/   constants + CPU null-geodesic integrator (shared numbers with the shader)
+src/physics/   constants, Kerr closed forms, CPU null-geodesic integrator (Schwarzschild
+               superposition and exact Kerr), observer aberration, image order:
+               all shared, line for line, with the shader
 src/sim/       pure simulation core: PW gravity, tidal phase machine, debris pool,
                Peters binary inspiral, quadrupole wave state, zero WebGL/DOM,
                fully unit-tested (vitest)
@@ -300,6 +310,9 @@ The renderer's key trick: everything that must be *truly* lensed (sky, disc, the
 
 - J.-P. Luminet, *Image of a spherical black hole with thin accretion disk*, A&A 75, 228 (1979), the first computed image of what this app draws.
 - O. James, E. von Tunzelmann, P. Franklin, K. S. Thorne, *Gravitational lensing by spinning black holes in astrophysics, and in the movie Interstellar*, Class. Quantum Grav. 32, 065001 (2015).
+- R. P. Kerr, *Gravitational field of a spinning mass as an example of algebraically special metrics*, Phys. Rev. Lett. 11, 237 (1963), the spinning solution and its Kerr-Schild form.
+- J. M. Bardeen, W. H. Press, S. A. Teukolsky, *Rotating black holes: locally nonrotating frames, energy extraction, and scalar synchrotron radiation*, ApJ 178, 347 (1972), the Kerr ISCO and photon orbits.
+- K. S. Thorne, *Disk-accretion onto a black hole. II*, ApJ 191, 507 (1974), the a/M = 0.998 accretion limit.
 - P. C. Peters, *Gravitational Radiation and the Motion of Two Point Masses*, Phys. Rev. 136, B1224 (1964), the inspiral equations.
 - N. I. Shakura, R. A. Sunyaev, *Black holes in binary systems. Observational appearance*, A&A 24, 337 (1973), the disc temperature profile.
 - B. Paczyński, P. J. Wiita, *Thick accretion disks and supercritical luminosities*, A&A 88, 23 (1980), the pseudo-Newtonian potential.
diff --git a/docs/THEORY.md b/docs/THEORY.md
index aa35bcd..aa4ec99 100644
--- a/docs/THEORY.md
+++ b/docs/THEORY.md
@@ -31,8 +31,10 @@ the summary, jump to [the table at the end](#every-equation-and-where-it-lives).
 12. [Gravitational waves and the chirp](#12-gravitational-waves-and-the-chirp)
 13. [The funnel: what curved space actually means](#13-the-funnel-what-curved-space-actually-means)
 14. [Jets, beaming, and the outflow](#14-jets-beaming-and-the-outflow)
-15. [What we cheat on](#15-what-we-cheat-on)
-16. [Every equation and where it lives](#every-equation-and-where-it-lives)
+15. [Flying fast: what the sky does](#15-flying-fast-what-the-sky-does)
+16. [Spin, and what it drags](#16-spin-and-what-it-drags)
+17. [What we cheat on](#17-what-we-cheat-on)
+18. [Every equation and where it lives](#every-equation-and-where-it-lives)
 
 ---
 
@@ -244,7 +246,35 @@ Just outside that edge sits the **photon ring**, the bright thin circle in
 every image, made of light that looped one or more times before escaping to
 your eye.
 
-> **In the code:** `B_CRIT` and `R_PHOTON` in `src/physics/constants.ts`.
+### Which loop am I looking at?
+
+The ring is not one image, it is a stack of them, and you can label them. Let
+$\Phi$ be the total angle the ray sweeps about the hole on its way to you:
+
+$$\Phi = \int \frac{\lvert \mathbf{x} \times d\mathbf{x} \rvert}{r^2}, \qquad n = \left\lfloor \Phi / \pi \right\rfloor$$
+
+$n = 0$ is the **direct** image, what you would see if light went straight.
+$n = 1$ is light that came round the far side once. $n \ge 2$ is the photon
+ring proper.
+
+Why $\pi$? For a camera sitting at elevation $\varepsilon$ above the disc
+plane, the direct image of the disc spans $\Phi$ from $\varepsilon$ to
+$\pi - \varepsilon$, and the first-order image spans $\pi + \varepsilon$ to
+$2\pi - \varepsilon$. The boundaries at multiples of $\pi$ therefore sit in the
+middle of a gap of width $2\varepsilon$. The classification margin is the
+camera's own elevation, which is why an exactly edge-on view is the one place
+the labels genuinely blur: there the two images of the far edge really do
+merge.
+
+Each successive order is squeezed into a band roughly $e^{-\pi}$ times thinner
+than the last. Measured on this app at its default framing, the $n = 1$ band is
+about 7 pixels wide across a 1920-pixel frame and the $n = 2$ band is about a
+quarter of a pixel. That is not a rendering failure, it is the reason the
+photon ring reads as a hard edge rather than as a set of rings.
+
+> **In the code:** `B_CRIT` and `R_PHOTON` in `src/physics/constants.ts`;
+> `sweptAngle` and `imageOrder` in `src/physics/imageOrder.ts`, mirrored in
+> `shaders/geodesic.frag`, and switched on by Light rays -> Tint image orders.
 
 ---
 
@@ -593,18 +623,186 @@ away with it.
 
 ---
 
-## 15. What we cheat on
+## 15. Flying fast: what the sky does
+
+Everything so far assumed you were sitting still. Take the camera on one of the
+scripted flights and two things happen at once, and they are the same thing
+seen twice.
+
+**Aberration.** Directions are not absolute. A photon arriving from a given
+direction in the static frame arrives from a *different* direction as far as a
+moving observer is concerned, and the difference is not small at any decent
+speed. Take the pixel's look direction $\hat{\ell}$ in the camera's own rest
+frame, and the camera's velocity $\boldsymbol\beta$ (in units of $c$) in the
+static frame. Relativistic velocity addition, applied to the photon's
+propagation direction $-\hat{\ell}$ and negated back into a look direction,
+gives the static-frame direction to march along:
+
+$$\hat{n} = \frac{\hat{\ell}/\gamma - \boldsymbol\beta + \dfrac{\gamma}{\gamma+1}(\hat{\ell}\cdot\boldsymbol\beta)\,\boldsymbol\beta}{1 - \hat{\ell}\cdot\boldsymbol\beta}$$
+
+Read it the way the picture works: every static direction is dragged *backward*
+against the motion, so the whole sky bunches toward where you are going. Run
+fast enough and the stars behind you crowd into a ring and the stars ahead
+spread out into a bowl. This is the headlight effect, and it is exactly the
+reason a relativistic jet looks like one beam and not two.
+
+**Doppler.** The same transformation gives the frequency ratio of the received
+photon:
+
+$$D = \gamma\left(1 + \boldsymbol\beta\cdot\hat{n}\right) = \frac{1}{\gamma\left(1 - \hat{\ell}\cdot\boldsymbol\beta\right)}$$
+
+Looking straight ahead gives $\gamma(1+\beta)$, straight behind $\gamma(1-\beta)$,
+and looking at right angles *in the camera frame* gives exactly $1/\gamma$, the
+pure transverse redshift. Bolometrically the received brightness scales as
+$D^4$; the app uses the same exponent 3 the disc and jet already use, for
+continuity rather than for correctness.
+
+**Why the speed is not the derivative of the camera path.** The flights are
+played back on a compressed clock. They move about $3\,r_s$ per wall-clock
+second, which in units where $c = 1$ is several times light speed, and the
+fly-in's recovery teleport would make it infinite. Differentiating the path
+would therefore be nonsense. What the app uses instead is the physical speed of
+the trajectory each move stands for:
+
+- `circle` uses the circular-orbit speed $\sqrt{M/(r-2M)}$ from Part 9, the
+  same expression the disc's own gas uses. About $0.33c$ at the shipped
+  framing.
+- `flyby` and `flyin` use the free-fall-from-infinity speed $\sqrt{r_s/r}$,
+  which is Part 3's escape speed run backwards. About $0.41c$ at the closest
+  point of a pass, and clamped at $0.95c$ near the end of a plunge.
+
+Both are derived and both are already in this document, which an art-directed
+"tour clock" divisor would not be.
+
+At rest all of this is identically the identity: $\gamma = 1$,
+$\hat{\ell}\cdot\boldsymbol\beta = 0$, $\hat{n} = \hat{\ell}$, $D = 1$. Mouse
+orbiting repositions the camera rather than flying it, so it never sees any of
+this.
+
+> **In the code:** `aberrateLookDirection` in `src/physics/relativity.ts` and
+> `aberratedRay` in `shaders/geodesic.frag`; the speeds in
+> `src/render/cameraTour.ts`.
+
+---
+
+## 16. Spin, and what it drags
+
+Every real black hole spins. Schwarzschild is the special case where it does
+not, and once you let it turn, the picture changes in four visible ways that
+all follow from one number.
+
+That number is the **spin parameter** $a = J/M$, an angular momentum per unit
+mass, which has units of length. It is usually quoted dimensionless as $a/M$,
+running from 0 (still) to 1 (as fast as a black hole can turn at all).
+
+**The metric that survives the horizon.** Kerr's solution is usually written in
+Boyer-Lindquist coordinates, which are elegant and blow up at the horizon:
+exactly where the interesting rays go. This app uses the Cartesian
+**Kerr-Schild** form instead, which is flat space plus a rank-one correction:
+
+$$g_{\mu\nu} = \eta_{\mu\nu} + f\, l_\mu l_\nu, \qquad f = \frac{2Mr^3}{r^4 + a^2z^2}$$
+
+with $l_\mu$ a null vector (null with respect to both $\eta$ and $g$) and $r$
+defined implicitly by
+
+$$\frac{x^2+y^2}{r^2+a^2} + \frac{z^2}{r^2} = 1$$
+
+so surfaces of constant $r$ are squashed spheroids rather than spheres. Nothing
+here is singular at the horizon, and the coordinates are already Cartesian, so
+the raymarcher's plane-crossing test and body intersection do not change at
+all. Setting $a = 0$ gives $r = |\mathbf{x}|$, $f = r_s/r$, and Schwarzschild
+back.
+
+**Ray tracing it.** Rather than deriving Christoffel symbols, the app integrates
+the Hamiltonian. With $g^{\mu\nu} = \eta^{\mu\nu} - f\,l^\mu l^\nu$ and the
+photon's energy normalized so $p_t = -1$:
+
+$$H = \tfrac{1}{2}\left(\mathbf{p}\cdot\mathbf{p} - 1 - f\kappa^2\right), \qquad \kappa = 1 + \mathbf{k}\cdot\mathbf{p}$$
+
+$$\frac{d\mathbf{x}}{d\lambda} = \frac{\partial H}{\partial \mathbf{p}} = \mathbf{p} - f\kappa\,\mathbf{k}, \qquad \frac{d\mathbf{p}}{d\lambda} = -\frac{\partial H}{\partial \mathbf{x}} = \tfrac{1}{2}\kappa^2 \nabla f + f\kappa\,(\mathbf{p}\cdot\nabla\mathbf{k})$$
+
+$H$ is zero for a null ray and stays zero, and the angular momentum about the
+spin axis stays put too. Both are watched by the tests, which is how a wrong
+term in $\nabla f$ or $\nabla\mathbf{k}$ gets caught instead of quietly drawing
+a slightly wrong picture.
+
+**Consequence 1: the horizon shrinks.** Solving $\Delta = r^2 - 2Mr + a^2 = 0$:
+
+$$r_\pm = M \pm \sqrt{M^2 - a^2}$$
+
+At $a = 0$ the outer root is $2M = r_s$, the familiar horizon. At $a/M = 0.998$
+it is $0.53\,r_s$: a maximally spinning hole is half the size of a still one of
+the same mass.
+
+**Consequence 2: the shadow goes lopsided.** The photon sphere splits in two.
+Light going around the way the hole turns (prograde) can hold on closer in;
+light going the other way is pushed out:
+
+$$r_{\text{ph}} = 2M\left[1 + \cos\left(\tfrac{2}{3}\arccos\left(\mp a/M\right)\right)\right]$$
+
+with the upper sign prograde. At $a/M = 0.998$ that is $0.54\,r_s$ prograde and
+$2.00\,r_s$ retrograde, against $1.5\,r_s$ for both at zero spin. Evaluating the
+critical impact parameter at each,
+
+$$b_{\text{crit}} = a \pm \frac{2 r_{\text{ph}}\sqrt{\Delta(r_{\text{ph}})}}{r_{\text{ph}} - M}$$
+
+gives $+1.06\,r_s$ on the approaching side and $-3.50\,r_s$ on the receding one.
+Those are the two edges of the shadow, and they are no longer the same distance
+from the centre. That is the flat side of the famous D shape: it is not the
+disc doing it, it is the spacetime.
+
+**Consequence 3: the disc's inner edge follows.** The last stable circular orbit
+moves in as well (Bardeen, Press and Teukolsky 1972):
+
+$$r_{\text{ISCO}} = M\left[3 + Z_2 \mp \sqrt{(3-Z_1)(3+Z_1+2Z_2)}\right]$$
+
+$$Z_1 = 1 + \sqrt[3]{1-(a/M)^2}\left(\sqrt[3]{1+a/M} + \sqrt[3]{1-a/M}\right), \qquad Z_2 = \sqrt{3(a/M)^2 + Z_1^2}$$
+
+From $6M = 3\,r_s$ at zero spin down to $M = 0.5\,r_s$ at the extreme, and
+$0.62\,r_s$ at the shipped limit. The disc is allowed to reach further in, where
+it is hotter and moving faster, which is why a spinning hole's inner disc is so
+much brighter. The retrograde branch goes the other way, out to $9M$.
+
+**Consequence 4: frame dragging.** Near a spinning hole, "standing still" is not
+an option: the geometry itself rotates, and even a ray fired straight at the
+centre with zero angular momentum acquires an azimuth as it falls. The disc
+feels it too, and its orbital speed and redshift pick up the spin:
+
+$$\Omega = \frac{\sqrt{M}}{r^{3/2} + a\sqrt{M}}, \qquad \frac{1}{u^t} = \frac{r^{3/4}\sqrt{r^{3/2} - 3M\sqrt{r} + 2a\sqrt{M}}}{r^{3/2} + a\sqrt{M}}$$
+
+both of which collapse to Part 8's and Part 9's Schwarzschild expressions when
+$a$ is zero.
+
+**Why the slider stops at 0.998.** This is the **Thorne limit**, and it is
+physics rather than a fudge. A hole fed by a thin disc swallows photons from
+the inner disc that carry, on average, negative angular momentum, and they spin
+it back down as fast as the accreting gas spins it up. Accretion therefore
+saturates just short of extremal. Conveniently it is also where the closed forms
+above stay well conditioned: at $a/M = 1$ exactly, $r_{\text{ph}} - M$ goes to
+zero in the prograde $b_{\text{crit}}$.
+
+> **In the code:** `src/physics/kerr.ts` for the closed forms, the Kerr block of
+> `src/physics/geodesic.ts` and `shaders/kerr.glsl` for the integrator.
+
+---
+
+## 17. What we cheat on
 
 A physics document that only lists what it gets right is advertising. Here is
 the other column.
 
 | Cheat | Why | What would fix it |
 |---|---|---|
-| **No spin.** Schwarzschild, not Kerr. | Kerr geodesics are a rewrite of the core integrator. | Real holes spin, which drags space around with them, skews the shadow, and moves the ISCO in to $1.24\,r_s$. |
 | **Two holes are superposed, not solved.** | The real two-body problem in GR needs supercomputers. | Numerical relativity. Our double shadows and eyebrow images are qualitatively right, quantitatively not. |
-| **Matter is pseudo-Newtonian.** | Full geodesic motion for 48,000 particles is too slow. | Paczyński-Wiita gets the ISCO exactly right, which is the part that matters visually. |
+| **A second hole forces the spin to 0.** | Kerr is a one-hole solution and superposing two of them is not one. | It also means a merger leaves a non-spinning remnant, which is wrong: an equal-mass merger leaves $a/M \approx 0.69$. |
+| **Matter is Paczyński-Wiita even when the hole spins.** | Full Kerr geodesic motion for 48,000 particles is too slow. | Only the *boundaries* move with the spin: the disc's inner edge and the kill radius come from the Kerr closed forms, the forces do not. |
+| **The disc's emission angle is a coordinate direction.** | A local orthonormal tetrad at every crossing costs another frame basis per hit. | It is the approximation the app always had; at $a/M = 0.998$ the inner disc sits at $0.62\,r_s$ where it is worse. Keeping it is what makes $a = 0$ continuous. |
+| **The curvature grid is Flamm's Schwarzschild embedding.** | There is no equally clean embedding diagram for Kerr. | The funnel does not change shape when you spin the hole up, though everything else does. |
+| **The jet is drawn, not launched.** | Blandford-Znajek needs magnetohydrodynamics as well as spin. | So the jet does not fade as the spin drops, which is exactly what a real Blandford-Znajek jet would do. The beaming, at least, is computed and not painted. |
+| **Image order is measured about the primary.** | With a secondary in the scene the ray no longer stays in one plane. | The overlay stays qualitatively useful there and no more than that. |
+| **The camera's colour shift is an RGB gain.** | There are no spectra in this renderer, only three channels. | Real Doppler moves light in and out of the visible band and changes which stars are seen at all. Exactly neutral at rest. |
+| **The overlay pass is not aberrated.** | Debris, rays and the grid are drawn by ordinary projection in pass 2. | During a fast flight the raymarched shadow has moved and that geometry has not, so occlusion near the shadow edge is slightly wrong. |
 | **The disc is infinitely thin.** | A volumetric disc multiplies the per-pixel cost. | Raymarched volume with real optical depth. |
-| **The jet is drawn, not launched.** | Blandford-Znajek needs spin, which we do not have, plus magnetohydrodynamics. | GRMHD simulation data. The beaming, at least, is computed and not painted. |
 | **Two clocks run fast.** | A disruption takes days, an inspiral from $8\,r_s$ takes about 1600 time units. | Nothing: the trajectories are exact, only the clock is compressed, and the app says so in the interface. |
 | **No light travel-time delay.** | You see the whole disc at one instant rather than each part as it was when its light left. | Track photon arrival times through the march. |
 | **The sky is invented.** | It follows real structure (luminosity function, dust extinction, clustering) but it is not a star catalogue. | A real survey texture, at the cost of every image looking identical. |
@@ -623,6 +821,15 @@ the other column.
 | Photon sphere | $r = 1.5\,r_s$ | `physics/constants.ts` |
 | Shadow radius | $b_{\text{crit}} = 3\sqrt{3}M \approx 2.6\,r_s$ | `physics/constants.ts` |
 | ISCO | $r = 3\,r_s$ | `physics/constants.ts` |
+| Image order | $n = \lfloor \Phi/\pi \rfloor$, $\Phi = \int \lvert \mathbf{x}\times d\mathbf{x}\rvert / r^2$ | `physics/imageOrder.ts`, `shaders/geodesic.frag` |
+| Aberration | $\hat{n} = (\hat{\ell}/\gamma - \boldsymbol\beta + \tfrac{\gamma}{\gamma+1}(\hat{\ell}\cdot\boldsymbol\beta)\boldsymbol\beta)/(1-\hat{\ell}\cdot\boldsymbol\beta)$ | `physics/relativity.ts`, `shaders/geodesic.frag` |
+| Observer Doppler | $D = \gamma(1 + \boldsymbol\beta\cdot\hat{n})$ | `physics/relativity.ts`, `shaders/geodesic.frag` |
+| Kerr-Schild metric | $g_{\mu\nu} = \eta_{\mu\nu} + f\,l_\mu l_\nu$, $f = 2Mr^3/(r^4+a^2z^2)$ | `shaders/kerr.glsl`, `physics/geodesic.ts` |
+| Kerr ray tracing | $\dot{\mathbf{x}} = \mathbf{p} - f\kappa\mathbf{k}$, $\dot{\mathbf{p}} = \tfrac12\kappa^2\nabla f + f\kappa(\mathbf{p}\cdot\nabla\mathbf{k})$ | `shaders/kerr.glsl`, `physics/geodesic.ts` |
+| Kerr horizon | $r_\pm = M \pm \sqrt{M^2 - a^2}$ | `physics/kerr.ts` |
+| Kerr photon orbits | $r_{\text{ph}} = 2M[1 + \cos(\tfrac23\arccos(\mp a/M))]$ | `physics/kerr.ts` |
+| Kerr ISCO | $r = M[3 + Z_2 \mp \sqrt{(3-Z_1)(3+Z_1+2Z_2)}]$ | `physics/kerr.ts` |
+| Kerr disc kinematics | $\Omega = \sqrt{M}/(r^{3/2}+a\sqrt{M})$ | `physics/kerr.ts`, `shaders/kerr.glsl` |
 | Paczyński-Wiita potential | $\Phi = -GM/(r - r_s)$ | `sim/gravity.ts` |
 | PW circular speed | $v = \sqrt{GMr}/(r - r_s)$ | `sim/gravity.ts` |
 | Specific energy | $\varepsilon = v^2/2 - GM/(r-r_s)$ | `sim/orbit.ts`, `sim/debris.ts` |
@@ -649,3 +856,7 @@ the other column.
 - **Rees (1988)** on tidal disruption, for Parts 10 and 11.
 - **Peters (1964)** for Part 12, four pages that predicted a sound nobody heard
   for fifty-one years.
+- **Bardeen, Press and Teukolsky (1972)**, *Rotating black holes*, for Part 16.
+  The ISCO and photon-orbit formulas this app evaluates are theirs.
+- **Thorne (1974)** for the 0.998 limit: why a hole fed by a disc cannot quite
+  reach extremal.
diff --git a/src/config.ts b/src/config.ts
index 0d5f726..ea5457a 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -81,8 +81,6 @@ export const DEBRIS_TUNING = {
   /** Disc-plane settling spring (s^-2) and damping (s^-1). */
   planeSpring: 0.5,
   planeDamping: 1.0,
-  /** Radius where particles start being absorbed into the disc (ISCO). */
-  absorbRadius: 3.0,
   /**
    * How circular a particle's orbit must be before the disc takes it: inside
    * the ISCO its speed-squared must fall below this multiple of the local
@@ -92,7 +90,8 @@ export const DEBRIS_TUNING = {
   circularizedSpeedFactor: 1.3,
   /** Seconds over which an absorbed particle fades out. */
   absorbFadeTime: 1.5,
-  /** Hard-kill radius just outside the horizon. */
+  /** Hard-kill radius as a multiple of the outer horizon, which shrinks as
+   *  the hole spins up, so this must not be written in r_s. */
   killRadius: 1.05,
   /**
    * Hard-kill age in disruption-clock seconds. An orbit at 8 r_s takes ~200 of
diff --git a/src/interact/aiming.ts b/src/interact/aiming.ts
index fd4ccc9..b04202b 100644
--- a/src/interact/aiming.ts
+++ b/src/interact/aiming.ts
@@ -8,12 +8,22 @@ import type { GeodesicResult } from '../physics/geodesic';
 import type { PhotonPathManager } from '../render/photonPaths';
 import type { Settings } from '../settings';
 
-function summarize(results: GeodesicResult[]): string {
+/**
+ * Around a spinning hole the two edges of the shadow sit at different impact
+ * parameters, so an unsigned b no longer tells you which one a ray is near.
+ * The sense is reported alongside it.
+ */
+function summarize(results: GeodesicResult[], spin: number): string {
   const captured = results.filter((r) => r.fate === 'captured').length;
   const bs = results.map((r) => r.b);
   const bMin = Math.min(...bs).toFixed(2);
   const bMax = Math.max(...bs).toFixed(2);
-  const range = results.length === 1 ? `b=${bMin}` : `b∈[${bMin}, ${bMax}]`;
+  let range = results.length === 1 ? `b=${bMin}` : `b∈[${bMin}, ${bMax}]`;
+  if (spin > 0 && results.length === 1) {
+    const ray = results[0]!;
+    const sense = ray.axialAngularMomentum >= 0 ? 'prograde' : 'retrograde';
+    range = `b=${ray.axialAngularMomentum >= 0 ? '+' : '-'}${bMin} (${sense})`;
+  }
   return `${results.length} ray${results.length > 1 ? 's' : ''}: ${captured} captured · ${
     results.length - captured
   } escaped · ${range}`;
@@ -55,7 +65,7 @@ export class AimingController {
       Math.round(this.settings.photonCount),
       this.settings.photonSpreadDeg,
     );
-    this.onInfo(summarize(results));
+    this.onInfo(summarize(results, this.settings.spin));
   }
 
   private readonly onClick = (event: MouseEvent): void => {
diff --git a/src/main.ts b/src/main.ts
index 4464856..ce50d9a 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -6,13 +6,19 @@
 import * as THREE from 'three';
 import { AudioEngine } from './audio/engine';
 import { AimingController } from './interact/aiming';
-import { DISC_OUTER, R_ISCO } from './physics/constants';
+import { DISC_OUTER } from './physics/constants';
 import type { GravityCenter } from './physics/geodesic';
+import {
+  circularPhotonOrbitRadius,
+  horizonRadius,
+  innermostStableCircularOrbit,
+} from './physics/kerr';
+import { lorentzGamma } from './physics/relativity';
 import { BlackHolePass, type PlanetState } from './render/blackHolePass';
 import { CameraRig } from './render/cameraRig';
 import { CameraTour } from './render/cameraTour';
 import { DebrisPoints } from './render/debrisPoints';
-import { PhotonPathManager } from './render/photonPaths';
+import { PhotonPathManager, type LensingState } from './render/photonPaths';
 import { RenderPipeline, type AccumMode } from './render/pipeline';
 import { SpacetimeGrid } from './render/spacetimeGrid';
 import { Starfield } from './render/starfield';
@@ -20,7 +26,15 @@ import { defaultSettings } from './settings';
 import { displayRs, orbitalOmegaWall } from './sim/binary';
 import { bodyScale } from './sim/body';
 import { nextWaveState, restingWave } from './sim/gravitationalWave';
-import { clearBody, createWorld, placeBinary, placeBody, resetScene, stepWorld } from './sim/world';
+import {
+  clearBody,
+  createWorld,
+  placeBinary,
+  placeBody,
+  resetScene,
+  setPrimarySpin,
+  stepWorld,
+} from './sim/world';
 import type { Body } from './sim/types';
 import { CinematicMode, isTypingIntoControl } from './ui/chrome';
 import { touchRenderBudget, usesTouchUi } from './ui/device';
@@ -101,17 +115,17 @@ function currentRs(): number {
   return displayRs(world.binary, world.primaryRs);
 }
 
-/** Lensing centers for CPU photon paths, mirroring the shader's state. */
-function gravityCenters(): readonly GravityCenter[] {
+/** The spacetime CPU photon paths integrate in, mirroring the shader's state. */
+function lensingState(): LensingState {
   const centers: GravityCenter[] = [{ x: 0, y: 0, z: 0, rs: currentRs() }];
   const binary = world.binary;
   if (binary?.phase === 'inspiral') {
     centers.push({ x: binary.pos.x, y: binary.pos.y, z: binary.pos.z, rs: binary.rs2 });
   }
-  return centers;
+  return { centers, spin: world.spin };
 }
 
-const photonPaths = new PhotonPathManager(gravityCenters);
+const photonPaths = new PhotonPathManager(lensingState);
 photonPaths.setVisible(settings.photonsEnabled);
 pipeline.overlayScene.add(photonPaths.group);
 
@@ -197,6 +211,9 @@ function applyPreset(preset: Preset): void {
 
   rig.moveTo(preset.camera);
   photonPaths.setVisible(settings.photonsEnabled);
+  // A preset can change the spacetime itself, so a converged still frame from
+  // the previous scene is no longer a picture of anything.
+  pipeline.resetAccumulation();
   panel.refreshDisplays();
   if (preset.cinematic) cinematic.hide();
   else cinematic.show();
@@ -325,6 +342,41 @@ function syncPlanet(body: Body | null): void {
   bhPass.setPlanet(planetState);
 }
 
+// --- spin, and the accumulation it invalidates ---
+//
+// Changing the spin changes the spacetime, so a converged progressive frame is
+// a picture of a different universe and has to be thrown away, exactly as a
+// sky re-bake does. The same goes for the image-order overlay: in 'progressive'
+// mode the raymarch is skipped once converged, so a paused user toggling it
+// would otherwise see nothing happen at all.
+let appliedSpin = 0;
+let appliedImageOrderTint = 0;
+let spinWasAvailable = true;
+
+function syncSpin(): void {
+  const available = world.binary === null;
+  if (available !== spinWasAvailable) {
+    spinWasAvailable = available;
+    panel.setSpinAvailable(available);
+    if (!available && settings.spin > 0) {
+      showTransientNote('spin is modelled for a single hole, so it was set to 0');
+    }
+  }
+  const spin = setPrimarySpin(world, settings.spin);
+  if (spin !== appliedSpin) {
+    appliedSpin = spin;
+    pipeline.resetAccumulation();
+  }
+}
+
+function syncImageOrderTint(): void {
+  const tint = settings.imageOrderTintEnabled ? settings.imageOrderTintStrength : 0;
+  bhPass.setImageOrderTint(tint);
+  if (tint === appliedImageOrderTint) return;
+  appliedImageOrderTint = tint;
+  pipeline.resetAccumulation();
+}
+
 // --- auto-degrade on sustained slow frames ---
 const frameTimes: number[] = [];
 let lastDegradeCheck = 0;
@@ -359,6 +411,16 @@ function updateHud(now: number, fps: number): void {
   if (cinematic.isActive || now - lastHudUpdate < 250) return;
   lastHudUpdate = now;
   const lines = [`${fps.toFixed(0)} fps · ${settings.quality}`];
+  if (world.spin > 0) {
+    // Derived radii belong in the readout, which is where this app already
+    // puts live numbers, rather than in the panel next to the slider.
+    lines.push(
+      `spin a/M ${world.spin.toFixed(2)} · horizon ${horizonRadius(world.spin).toFixed(2)} rₛ · ` +
+        `ISCO ${innermostStableCircularOrbit(world.spin, 'prograde').toFixed(2)} rₛ · ` +
+        `photon ring ${circularPhotonOrbitRadius(world.spin, 'prograde').toFixed(2)} / ` +
+        `${circularPhotonOrbitRadius(world.spin, 'retrograde').toFixed(2)} rₛ (prograde / retrograde)`,
+    );
+  }
   const binary = world.binary;
   if (binary?.phase === 'inspiral') {
     const orbitsPerSec = orbitalOmegaWall(binary, world.primaryRs, settings.gwTimeCompression) /
@@ -377,15 +439,27 @@ function updateHud(now: number, fps: number): void {
     );
   }
   if (world.discBoost > 0.01) lines.push(`disc feed +${(world.discBoost * 100).toFixed(0)}%`);
-  if (tour.activeKind) lines.push(`camera flight: ${tour.activeKind} · Esc to stop`);
-  else if (placement.active) lines.push('click the plane to place · right-click / Esc cancels');
-  else if (settings.photonsEnabled) lines.push('click to launch photons');
+  if (tour.activeKind) {
+    const speed = cameraBeta.length();
+    const motion =
+      speed > 0.005 ? ` · ${speed.toFixed(2)} c · γ ${lorentzGamma(speed).toFixed(2)}` : '';
+    lines.push(`camera flight: ${tour.activeKind}${motion} · Esc to stop`);
+  } else if (placement.active) {
+    lines.push('click the plane to place · right-click / Esc cancels');
+  } else if (settings.photonsEnabled) {
+    lines.push('click to launch photons');
+  }
+  if (settings.imageOrderTintEnabled) {
+    lines.push('image order: blue direct · amber one half turn · magenta photon ring');
+  }
   if (aimInfo) lines.push(aimInfo);
   if (now < transientUntil) lines.push(transientNote);
   hud.textContent = lines.join('\n');
 }
 
 // --- main loop ---
+/** Scratch for the camera velocity pushed to the shader; never allocated per frame. */
+const cameraBeta = new THREE.Vector3();
 let last = performance.now();
 let acc = 0;
 let smoothedFps = 60;
@@ -435,7 +509,8 @@ function frame(now: number): void {
 
   const rs = currentRs();
   syncPlanet(world.body);
-  bhPass.setPrimaryRs(rs);
+  syncSpin();
+  bhPass.setPrimary({ rs, spin: world.spin });
   bhPass.setSecondary(
     world.binary?.phase === 'inspiral' ? { pos: world.binary.pos, rs: world.binary.rs2 } : null,
   );
@@ -443,12 +518,13 @@ function frame(now: number): void {
   // The outflow exists only while the hole is being force-fed, so it rises
   // with the feeding boost and dies with it, no separate control needed.
   bhPass.setWindStrength(settings.windEnabled ? world.discBoost * settings.windStrength : 0);
+  syncImageOrderTint();
   spacetimeGrid.setVisible(settings.gridEnabled);
   spacetimeGrid.setOpacity(settings.gridOpacity);
   spacetimeGrid.setPrimaryRs(rs);
   spacetimeGrid.setWave(wave);
   bhPass.setDisc({
-    inner: R_ISCO * rs,
+    inner: innermostStableCircularOrbit(world.spin, 'prograde') * rs,
     outer: DISC_OUTER * rs,
     brightness: settings.discEnabled ? settings.discBrightness * (1 + world.discBoost) : 0,
   });
@@ -476,6 +552,14 @@ function frame(now: number): void {
     idle = rig.update();
   }
 
+  // Relativistic optics of the moving camera. Mouse orbiting repositions the
+  // camera rather than flying it, so the tour's beta is the zero vector there
+  // and the whole effect is off by construction, not by a threshold.
+  cameraBeta
+    .copy(tour.beta)
+    .multiplyScalar(settings.cameraBoostEnabled ? settings.cameraBoostStrength : 0);
+  bhPass.setCameraBeta(cameraBeta);
+
   const bhContentMoving = world.body !== null || world.binary !== null;
   const accumMode = chooseAccumMode(idle, settings.paused, bhContentMoving);
   pipeline.render(world.time, {
diff --git a/src/physics/__tests__/geodesic.test.ts b/src/physics/__tests__/geodesic.test.ts
index de1236c..8b5bb77 100644
--- a/src/physics/__tests__/geodesic.test.ts
+++ b/src/physics/__tests__/geodesic.test.ts
@@ -1,6 +1,22 @@
 import { describe, expect, it } from 'vitest';
-import { B_CRIT } from '../constants';
-import { approxDeflection, integrateNullGeodesic } from '../geodesic';
+import { A_STAR_MAX, B_CRIT, DT_MAX, DT_MIN, M, R_CAPTURE, SPIN_AXIS, STEP_K } from '../constants';
+import {
+  approxDeflection,
+  integrateNullGeodesic,
+  kerrDerivatives,
+  kerrHamiltonian,
+  kerrNullMomentum,
+  type Vec3,
+} from '../geodesic';
+import { imageOrder } from '../imageOrder';
+import {
+  circularPhotonOrbitRadius,
+  criticalImpactParameter,
+  horizonRadius,
+  kerrSchildRadius,
+  spinFrame,
+} from '../kerr';
+import { mulberry32 } from '../../sim/__tests__/rng';
 
 describe('null geodesic integrator', () => {
   it('captures rays with b < b_crit and passes rays with b > b_crit', () => {
@@ -30,4 +46,335 @@ describe('null geodesic integrator', () => {
     expect(bend).toBeGreaterThan(approxDeflection(b) * 0.9);
     expect(bend).toBeLessThan(approxDeflection(b) * 1.1);
   });
+
+  it('winds further around the hole the closer the ray passes', () => {
+    const windingFor = (b: number): number =>
+      integrateNullGeodesic({ x: -30, y: b, z: 0 }, { x: 1, y: 0, z: 0 }, { maxSteps: 8000 })
+        .windingAngle;
+
+    const wide = windingFor(20);
+    const near = windingFor(2.62); // just outside b_crit = 2.598
+    expect(wide).toBeLessThan(Math.PI);
+    expect(imageOrder(wide)).toBe(0);
+    expect(near).toBeGreaterThan(2 * Math.PI);
+    expect(imageOrder(near)).toBe(2);
+    expect(windingFor(2.62)).toBeGreaterThan(windingFor(3));
+    expect(windingFor(3)).toBeGreaterThan(windingFor(10));
+    expect(windingFor(10)).toBeGreaterThan(windingFor(20));
+  });
+
+  it('never unwinds: a shorter integration reports no more winding', () => {
+    const full = integrateNullGeodesic(
+      { x: -30, y: 2.62, z: 0 },
+      { x: 1, y: 0, z: 0 },
+      { maxSteps: 8000 },
+    );
+    const truncated = integrateNullGeodesic(
+      { x: -30, y: 2.62, z: 0 },
+      { x: 1, y: 0, z: 0 },
+      { maxSteps: 200 },
+    );
+    expect(truncated.windingAngle).toBeLessThanOrEqual(full.windingAngle);
+    expect(truncated.windingAngle).toBeGreaterThan(0);
+  });
+});
+
+// --- Kerr ---------------------------------------------------------------
+
+const SPIN_TEST_MASS = M; // r_s = 1 throughout these tests
+
+/** Signed axial angular momentum of a state about SPIN_AXIS. */
+function axialL(x: Vec3, p: Vec3): number {
+  return (
+    (x.y * p.z - x.z * p.y) * SPIN_AXIS.x +
+    (x.z * p.x - x.x * p.z) * SPIN_AXIS.y +
+    (x.x * p.y - x.y * p.x) * SPIN_AXIS.z
+  );
+}
+
+/** One RK4 step over the exported equations of motion. */
+function kerrStep(x: Vec3, p: Vec3, dt: number, a: number): { x: Vec3; p: Vec3 } {
+  const add = (u: Vec3, v: Vec3, s: number): Vec3 => ({
+    x: u.x + s * v.x,
+    y: u.y + s * v.y,
+    z: u.z + s * v.z,
+  });
+  const d1 = kerrDerivatives(x, p, a, SPIN_TEST_MASS);
+  const d2 = kerrDerivatives(add(x, d1.dx, dt / 2), add(p, d1.dp, dt / 2), a, SPIN_TEST_MASS);
+  const d3 = kerrDerivatives(add(x, d2.dx, dt / 2), add(p, d2.dp, dt / 2), a, SPIN_TEST_MASS);
+  const d4 = kerrDerivatives(add(x, d3.dx, dt), add(p, d3.dp, dt), a, SPIN_TEST_MASS);
+  const combine = (u: Vec3, k1: Vec3, k2: Vec3, k3: Vec3, k4: Vec3): Vec3 => ({
+    x: u.x + (dt / 6) * (k1.x + 2 * k2.x + 2 * k3.x + k4.x),
+    y: u.y + (dt / 6) * (k1.y + 2 * k2.y + 2 * k3.y + k4.y),
+    z: u.z + (dt / 6) * (k1.z + 2 * k2.z + 2 * k3.z + k4.z),
+  });
+  return {
+    x: combine(x, d1.dx, d2.dx, d3.dx, d4.dx),
+    p: combine(p, d1.dp, d2.dp, d3.dp, d4.dp),
+  };
+}
+
+describe('Kerr null launch', () => {
+  const rng = mulberry32(97);
+
+  it('produces an exactly null momentum for any camera, direction and spin', () => {
+    for (let i = 0; i < 200; i++) {
+      const spin = rng() * A_STAR_MAX;
+      const a = spin * M;
+      const radius = 2 * horizonRadius(spin) + rng() * 30;
+      const theta = Math.acos(2 * rng() - 1);
+      const phi = rng() * 2 * Math.PI;
+      const x: Vec3 = {
+        x: radius * Math.sin(theta) * Math.cos(phi),
+        y: radius * Math.cos(theta),
+        z: radius * Math.sin(theta) * Math.sin(phi),
+      };
+      const raw = { x: rng() * 2 - 1, y: rng() * 2 - 1, z: rng() * 2 - 1 };
+      const len = Math.hypot(raw.x, raw.y, raw.z);
+      const dir: Vec3 = { x: raw.x / len, y: raw.y / len, z: raw.z / len };
+      const p = kerrNullMomentum(x, dir, a, SPIN_TEST_MASS);
+      expect(Math.abs(kerrHamiltonian(x, p, a, SPIN_TEST_MASS))).toBeLessThan(1e-12);
+    }
+  });
+
+  it('leaves the direction untouched when the hole does not spin and is far away', () => {
+    const dir: Vec3 = { x: 0.6, y: 0, z: 0.8 };
+    const p = kerrNullMomentum({ x: -4000, y: 0, z: 0 }, dir, 0, SPIN_TEST_MASS);
+    expect(p.x).toBeCloseTo(dir.x, 3);
+    expect(p.y).toBeCloseTo(dir.y, 3);
+    expect(p.z).toBeCloseTo(dir.z, 3);
+  });
+});
+
+/**
+ * Worst drift of the two constants of motion along one approach, integrated
+ * with the shipped step rule scaled by `stepScale`.
+ */
+function conservationDrift(
+  spin: number,
+  offset: number,
+  stepScale: number,
+): { hamiltonian: number; axialMomentum: number } {
+  const a = spin * M;
+  const rPlus = horizonRadius(spin);
+  const start: Vec3 = { x: -25, y: 0, z: offset };
+  let x = start;
+  let p = kerrNullMomentum(start, { x: 1, y: 0, z: 0 }, a, SPIN_TEST_MASS);
+  const launchMomentum = axialL(x, p);
+  let hamiltonian = 0;
+  let axialMomentum = 0;
+  for (let step = 0; step < 4000; step++) {
+    const spun = spinFrame(x);
+    const r = kerrSchildRadius(spun.x, spun.y, spun.z, a);
+    if (r < 1.05 * rPlus) break;
+    hamiltonian = Math.max(hamiltonian, Math.abs(kerrHamiltonian(x, p, a, SPIN_TEST_MASS)));
+    axialMomentum = Math.max(axialMomentum, Math.abs(axialL(x, p) - launchMomentum));
+    const dt = Math.min(Math.max(STEP_K * (r - 0.9 * rPlus), DT_MIN), DT_MAX) * stepScale;
+    const next = kerrStep(x, p, dt, a);
+    x = next.x;
+    p = next.p;
+  }
+  return { hamiltonian, axialMomentum };
+}
+
+describe('Kerr equations of motion', () => {
+  it('conserves both constants of motion on rays that pass the hole', () => {
+    // Both quantities are of order 1 here, so this is five clean digits held
+    // over the whole approach, for the rays that actually make a picture.
+    for (const spin of [0.2, 0.6, 0.9, A_STAR_MAX]) {
+      for (const offset of [-4, 4]) {
+        const drift = conservationDrift(spin, offset, 1);
+        expect(drift.hamiltonian).toBeLessThan(1e-5);
+        expect(drift.axialMomentum).toBeLessThan(1e-5);
+      }
+    }
+  });
+
+  it('stays bounded even on rays that plunge into a near-extremal horizon', () => {
+    // Worst case in the whole app: DT_MIN = 0.02 is coarse against a horizon
+    // that has shrunk to 0.53, so a plunging ray takes a handful of steps
+    // through the steepest part of the metric. It ends up inside the shadow
+    // either way, which is why the shipped step floor is left alone.
+    for (const spin of [0.9, A_STAR_MAX]) {
+      for (const offset of [-1.5, 1.5]) {
+        const drift = conservationDrift(spin, offset, 1);
+        expect(drift.hamiltonian).toBeLessThan(5e-3);
+        expect(drift.axialMomentum).toBeLessThan(5e-3);
+      }
+    }
+  });
+
+  it('leaves only fourth-order truncation error behind', () => {
+    // Halving the step has to cut the drift by a large factor. A wrong term in
+    // the derivatives would leave a floor that refuses to shrink, which is
+    // what separates "the equations are right" from "the tolerance was kind".
+    for (const spin of [0.6, 0.9, A_STAR_MAX]) {
+      for (const offset of [-4, -1.5, 1.5, 4]) {
+        const coarse = conservationDrift(spin, offset, 1);
+        const fine = conservationDrift(spin, offset, 0.5);
+        expect(fine.hamiltonian).toBeLessThan(coarse.hamiltonian / 8);
+        expect(fine.axialMomentum).toBeLessThan(coarse.axialMomentum / 8);
+      }
+    }
+  });
+});
+
+describe('Kerr integrator', () => {
+  it('agrees with the Schwarzschild integrator as the spin goes to zero', () => {
+    const finalDirection = (result: ReturnType<typeof integrateNullGeodesic>): number => {
+      const n = result.points.length;
+      return Math.atan2(result.points[n - 2]! - result.points[n - 5]!, result.points[n - 3]! - result.points[n - 6]!);
+    };
+    const opts = { maxSteps: 12000, escapeR: 200 };
+    const schwarzschild = integrateNullGeodesic({ x: -200, y: 20, z: 0 }, { x: 1, y: 0, z: 0 }, opts);
+    const kerr = integrateNullGeodesic(
+      { x: -200, y: 20, z: 0 },
+      { x: 1, y: 0, z: 0 },
+      { ...opts, spin: 1e-6 },
+    );
+    expect(kerr.fate).toBe('escaped');
+    expect(Math.abs(finalDirection(kerr) - finalDirection(schwarzschild))).toBeLessThan(1e-3);
+
+    for (const b of [2.4, 2.8]) {
+      const a = integrateNullGeodesic({ x: -30, y: b, z: 0 }, { x: 1, y: 0, z: 0 });
+      const k = integrateNullGeodesic({ x: -30, y: b, z: 0 }, { x: 1, y: 0, z: 0 }, { spin: 1e-6 });
+      expect(k.fate).toBe(a.fate);
+    }
+  });
+
+  it('splits capture from escape at the prograde and retrograde critical impact parameters', () => {
+    const spin = 0.9;
+    // L_z = (x cross p) . (0, -1, 0), so from (-200, 0, offset) travelling +x
+    // a negative offset is the prograde side.
+    const fateAt = (offset: number) =>
+      integrateNullGeodesic(
+        { x: -200, y: 0, z: offset },
+        { x: 1, y: 0, z: 0 },
+        { maxSteps: 30000, escapeR: 200, spin },
+      );
+
+    const prograde = criticalImpactParameter(spin, 'prograde');
+    const retrograde = Math.abs(criticalImpactParameter(spin, 'retrograde'));
+    expect(prograde).toBeLessThan(retrograde); // the shadow is lopsided
+
+    expect(fateAt(-0.98 * prograde).fate).toBe('captured');
+    expect(fateAt(-1.02 * prograde).fate).toBe('escaped');
+    expect(fateAt(0.98 * retrograde).fate).toBe('captured');
+    expect(fateAt(1.02 * retrograde).fate).toBe('escaped');
+
+    // The sign convention the caller uses to pick a sense.
+    expect(fateAt(-1.02 * prograde).axialAngularMomentum).toBeGreaterThan(0);
+    expect(fateAt(1.02 * retrograde).axialAngularMomentum).toBeLessThan(0);
+  });
+
+  it('turns near-critical rays around at the photon orbit of their own sense', () => {
+    // The Kerr-Schild radius is the Boyer-Lindquist radius, so the turning
+    // point of a ray aimed just outside b_crit has to land on the closed-form
+    // photon orbit. This is the one test that ties kerr.ts and the integrator
+    // together: they are derived independently and must agree.
+    for (const spin of [1e-9, 0.5, 0.9]) {
+      for (const sense of ['prograde', 'retrograde'] as const) {
+        const b = criticalImpactParameter(spin, sense);
+        const result = integrateNullGeodesic(
+          { x: -200, y: 0, z: -Math.sign(b) * Math.abs(b) * 1.0005 },
+          { x: 1, y: 0, z: 0 },
+          { maxSteps: 60000, escapeR: 200, recordEvery: 1, spin },
+        );
+        expect(result.fate).toBe('escaped');
+
+        let closest = Infinity;
+        for (let i = 0; i < result.points.length; i += 3) {
+          const spun = spinFrame({
+            x: result.points[i]!,
+            y: result.points[i + 1]!,
+            z: result.points[i + 2]!,
+          });
+          closest = Math.min(closest, kerrSchildRadius(spun.x, spun.y, spun.z, spin * M));
+        }
+        const photon = circularPhotonOrbitRadius(spin, sense);
+        expect(closest).toBeGreaterThanOrEqual(photon);
+        expect(closest).toBeLessThan(photon * 1.04);
+      }
+    }
+  });
+
+  it('drags a ray with no angular momentum around the hole, and only when it spins', () => {
+    // Measured in the Kerr-Schild azimuth the app actually draws in, which
+    // absorbs part of the Boyer-Lindquist winding, so the interesting claim is
+    // the sign and the ordering, not the size of the angle.
+    const sweptAzimuth = (spin: number): number => {
+      const result = integrateNullGeodesic(
+        { x: -30, y: 0, z: 0 },
+        { x: 1, y: 0, z: 0 },
+        { maxSteps: 4000, recordEvery: 1, spin },
+      );
+      expect(result.axialAngularMomentum).toBeCloseTo(0, 12);
+      let total = 0;
+      let previous = Number.NaN;
+      for (let i = 0; i < result.points.length; i += 3) {
+        const spun = spinFrame({
+          x: result.points[i]!,
+          y: result.points[i + 1]!,
+          z: result.points[i + 2]!,
+        });
+        const azimuth = Math.atan2(spun.y, spun.x);
+        if (Number.isFinite(previous)) {
+          let step = azimuth - previous;
+          if (step > Math.PI) step -= 2 * Math.PI;
+          if (step < -Math.PI) step += 2 * Math.PI;
+          // Dragging never runs backwards, so any negative step is an error.
+          expect(step).toBeGreaterThan(-1e-12);
+          total += step;
+        }
+        previous = azimuth;
+      }
+      return total;
+    };
+
+    // Zero spin takes the Schwarzschild path, where a radial ray stays radial.
+    expect(sweptAzimuth(0)).toBe(0);
+    let previousDrag = 0;
+    for (const spin of [0.3, 0.5, 0.7, 0.9, A_STAR_MAX]) {
+      const drag = sweptAzimuth(spin);
+      expect(drag).toBeGreaterThan(previousDrag);
+      previousDrag = drag;
+    }
+  });
+
+  it('stops at the shrunken horizon rather than at 1 r_s', () => {
+    for (const spin of [0.5, 0.9, A_STAR_MAX]) {
+      const result = integrateNullGeodesic(
+        { x: -30, y: 0, z: 0 },
+        { x: 1, y: 0, z: 0 },
+        { maxSteps: 4000, spin },
+      );
+      expect(result.fate).toBe('captured');
+      const n = result.points.length;
+      const spun = spinFrame({
+        x: result.points[n - 3]!,
+        y: result.points[n - 2]!,
+        z: result.points[n - 1]!,
+      });
+      const radius = kerrSchildRadius(spun.x, spun.y, spun.z, spin * M);
+      const expected = R_CAPTURE * horizonRadius(spin);
+      expect(radius).toBeLessThanOrEqual(expected);
+      expect(radius).toBeGreaterThan(0.8 * expected);
+      if (spin > 0.5) expect(radius).toBeLessThan(R_CAPTURE);
+    }
+  });
+
+  it('refuses to spin a superposed pair, and spin 0 is the untouched old path', () => {
+    const centers = [
+      { x: 0, y: 0, z: 0, rs: 1 },
+      { x: 6, y: 0, z: 0, rs: 0.3 },
+    ];
+    expect(() =>
+      integrateNullGeodesic({ x: -30, y: 3, z: 0 }, { x: 1, y: 0, z: 0 }, { centers, spin: 0.5 }),
+    ).toThrow(/superposed/);
+
+    const withZero = integrateNullGeodesic({ x: -30, y: 2.8, z: 0 }, { x: 1, y: 0, z: 0 }, { spin: 0 });
+    const without = integrateNullGeodesic({ x: -30, y: 2.8, z: 0 }, { x: 1, y: 0, z: 0 });
+    expect(Array.from(withZero.points)).toEqual(Array.from(without.points));
+    expect(withZero.fate).toBe(without.fate);
+  });
 });
diff --git a/src/physics/__tests__/imageOrder.test.ts b/src/physics/__tests__/imageOrder.test.ts
new file mode 100644
index 0000000..5a95aba
--- /dev/null
+++ b/src/physics/__tests__/imageOrder.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { IMAGE_ORDER_MAX, imageOrder, sweptAngle } from '../imageOrder';
+
+const X_AXIS = { x: 1, y: 0, z: 0 };
+
+describe('sweptAngle', () => {
+  it('stays within the small-angle budget the march clamp guarantees', () => {
+    // The step clamp bounds the per-step angle near 0.11 rad; 0.13 leaves
+    // headroom, and the error there is still under a third of a milliradian.
+    for (let i = 0; i <= 130; i++) {
+      const theta = i / 1000;
+      const to = { x: Math.cos(theta), y: Math.sin(theta), z: 0 };
+      expect(Math.abs(sweptAngle(X_AXIS, to) - theta)).toBeLessThan(3.7e-4);
+    }
+    expect(Math.abs(sweptAngle(X_AXIS, { x: Math.cos(0.11), y: Math.sin(0.11), z: 0 }) - 0.11))
+      .toBeLessThan(2.3e-4);
+  });
+
+  it('ignores the length of either argument', () => {
+    const from = { x: 3, y: -1, z: 2 };
+    const to = { x: 1, y: 4, z: -2 };
+    const base = sweptAngle(from, to);
+    expect(base).toBeGreaterThan(0);
+    for (const scale of [0.01, 7, 1000]) {
+      expect(sweptAngle({ x: from.x * scale, y: from.y * scale, z: from.z * scale }, to)).toBeCloseTo(base, 12);
+      expect(sweptAngle(from, { x: to.x * scale, y: to.y * scale, z: to.z * scale })).toBeCloseTo(base, 12);
+    }
+  });
+
+  it('is zero for parallel vectors and symmetric in its arguments', () => {
+    expect(sweptAngle(X_AXIS, { x: 5, y: 0, z: 0 })).toBe(0);
+    const from = { x: 2, y: 1, z: -3 };
+    const to = { x: -1, y: 5, z: 0.5 };
+    expect(sweptAngle(from, to)).toBeCloseTo(sweptAngle(to, from), 15);
+  });
+
+  it('returns zero rather than a division by zero at the center', () => {
+    expect(sweptAngle({ x: 0, y: 0, z: 0 }, X_AXIS)).toBe(0);
+  });
+});
+
+describe('imageOrder', () => {
+  it('partitions the winding angle at multiples of pi', () => {
+    expect(imageOrder(0)).toBe(0);
+    expect(imageOrder(Math.PI * 0.999)).toBe(0);
+    expect(imageOrder(Math.PI)).toBe(1); // a boundary belongs to the higher order
+    expect(imageOrder(Math.PI * 1.999)).toBe(1);
+    expect(imageOrder(2 * Math.PI)).toBe(2);
+    expect(imageOrder(2.5 * Math.PI)).toBe(2);
+  });
+
+  it('saturates at the highest order the shader has a colour for', () => {
+    expect(imageOrder(10 * Math.PI)).toBe(IMAGE_ORDER_MAX);
+  });
+});
diff --git a/src/physics/__tests__/kerr.test.ts b/src/physics/__tests__/kerr.test.ts
new file mode 100644
index 0000000..fa7e2c4
--- /dev/null
+++ b/src/physics/__tests__/kerr.test.ts
@@ -0,0 +1,234 @@
+import { describe, expect, it } from 'vitest';
+import { A_STAR_MAX, B_CRIT, M, R_ISCO, R_PHOTON, R_S } from '../constants';
+import {
+  circularOrbitKinematics,
+  circularPhotonOrbitRadius,
+  criticalImpactParameter,
+  horizonRadius,
+  innerHorizonRadius,
+  innermostStableCircularOrbit,
+  kerrSchildRadius,
+  spinFrame,
+  worldFrame,
+  type OrbitSense,
+} from '../kerr';
+import { mulberry32 } from '../../sim/__tests__/rng';
+
+const SENSES: readonly OrbitSense[] = ['prograde', 'retrograde'];
+
+/** 200 spins spanning the allowed range, endpoints included. */
+function spinSweep(): number[] {
+  return Array.from({ length: 200 }, (_, i) => (A_STAR_MAX * i) / 199);
+}
+
+describe('Kerr closed forms', () => {
+  it('reduces to the Schwarzschild constants at zero spin', () => {
+    expect(horizonRadius(0)).toBeCloseTo(R_S, 12);
+    for (const sense of SENSES) {
+      expect(circularPhotonOrbitRadius(0, sense)).toBeCloseTo(R_PHOTON, 12);
+      expect(innermostStableCircularOrbit(0, sense)).toBeCloseTo(R_ISCO, 12);
+      expect(Math.abs(criticalImpactParameter(0, sense))).toBeCloseTo(B_CRIT, 12);
+    }
+  });
+
+  it('hits the known extremal limits at a/M = 1', () => {
+    expect(horizonRadius(1)).toBeCloseTo(M, 9);
+    expect(innerHorizonRadius(1)).toBeCloseTo(M, 9);
+    expect(innermostStableCircularOrbit(1, 'prograde')).toBeCloseTo(M, 9);
+    expect(innermostStableCircularOrbit(1, 'retrograde')).toBeCloseTo(9 * M, 9);
+    expect(circularPhotonOrbitRadius(1, 'prograde')).toBeCloseTo(M, 9);
+    expect(circularPhotonOrbitRadius(1, 'retrograde')).toBeCloseTo(4 * M, 9);
+    expect(criticalImpactParameter(1, 'retrograde')).toBeCloseTo(-7 * M, 9);
+  });
+
+  it('keeps the radii ordered for every allowed spin', () => {
+    for (const spin of spinSweep()) {
+      const rMinus = innerHorizonRadius(spin);
+      const rPlus = horizonRadius(spin);
+      const photon = circularPhotonOrbitRadius(spin, 'prograde');
+      const isco = innermostStableCircularOrbit(spin, 'prograde');
+      expect(rMinus).toBeLessThanOrEqual(rPlus);
+      expect(rPlus).toBeLessThanOrEqual(photon);
+      expect(photon).toBeLessThanOrEqual(isco);
+      expect(photon).toBeLessThanOrEqual(R_PHOTON);
+      expect(circularPhotonOrbitRadius(spin, 'retrograde')).toBeGreaterThanOrEqual(R_PHOTON);
+    }
+  });
+
+  it('moves every prograde quantity inward and every retrograde one outward', () => {
+    const sweep = spinSweep();
+    for (let i = 1; i < sweep.length; i++) {
+      const lo = sweep[i - 1]!;
+      const hi = sweep[i]!;
+      expect(horizonRadius(hi)).toBeLessThan(horizonRadius(lo));
+      expect(innermostStableCircularOrbit(hi, 'prograde')).toBeLessThan(
+        innermostStableCircularOrbit(lo, 'prograde'),
+      );
+      expect(circularPhotonOrbitRadius(hi, 'prograde')).toBeLessThan(
+        circularPhotonOrbitRadius(lo, 'prograde'),
+      );
+      expect(Math.abs(criticalImpactParameter(hi, 'prograde'))).toBeLessThan(
+        Math.abs(criticalImpactParameter(lo, 'prograde')),
+      );
+      expect(innermostStableCircularOrbit(hi, 'retrograde')).toBeGreaterThan(
+        innermostStableCircularOrbit(lo, 'retrograde'),
+      );
+      expect(circularPhotonOrbitRadius(hi, 'retrograde')).toBeGreaterThan(
+        circularPhotonOrbitRadius(lo, 'retrograde'),
+      );
+      expect(Math.abs(criticalImpactParameter(hi, 'retrograde'))).toBeGreaterThan(
+        Math.abs(criticalImpactParameter(lo, 'retrograde')),
+      );
+    }
+  });
+
+  it('reports the values quoted in the spin tooltip and the readout', () => {
+    // These are what the panel tooltip and docs/THEORY.md tell the user, so
+    // the numbers cannot go stale without a test failing.
+    expect(horizonRadius(A_STAR_MAX)).toBeCloseTo(0.53161, 4);
+    expect(innermostStableCircularOrbit(A_STAR_MAX, 'prograde')).toBeCloseTo(0.61849, 4);
+    expect(criticalImpactParameter(A_STAR_MAX, 'prograde')).toBeCloseTo(1.05544, 4);
+    expect(criticalImpactParameter(A_STAR_MAX, 'retrograde')).toBeCloseTo(-3.49833, 4);
+  });
+});
+
+describe('Kerr-Schild radius', () => {
+  const rng = mulberry32(11);
+  const randomPoint = (scale: number): [number, number, number] => [
+    (rng() * 2 - 1) * scale,
+    (rng() * 2 - 1) * scale,
+    (rng() * 2 - 1) * scale,
+  ];
+
+  it('is the ordinary radius when the hole does not spin', () => {
+    for (let i = 0; i < 50; i++) {
+      const [x, y, z] = randomPoint(20);
+      expect(kerrSchildRadius(x, y, z, 0)).toBeCloseTo(Math.hypot(x, y, z), 12);
+    }
+  });
+
+  it('returns r+ exactly on the horizon spheroid', () => {
+    for (const spin of [0.2, 0.6, 0.9, A_STAR_MAX]) {
+      const a = spin * M;
+      const rPlus = horizonRadius(spin);
+      for (let i = 0; i < 20; i++) {
+        const theta = rng() * Math.PI;
+        const phi = rng() * 2 * Math.PI;
+        const rho = Math.sqrt(rPlus * rPlus + a * a) * Math.sin(theta);
+        const x = rho * Math.cos(phi);
+        const y = rho * Math.sin(phi);
+        const z = rPlus * Math.cos(theta);
+        expect(kerrSchildRadius(x, y, z, a)).toBeCloseTo(rPlus, 10);
+      }
+    }
+  });
+
+  it('is invariant under rotation about the spin axis', () => {
+    const a = 0.9 * M;
+    for (let i = 0; i < 30; i++) {
+      const [x, y, z] = randomPoint(8);
+      const angle = rng() * 2 * Math.PI;
+      const c = Math.cos(angle);
+      const s = Math.sin(angle);
+      expect(kerrSchildRadius(x * c - y * s, x * s + y * c, z, a)).toBeCloseTo(
+        kerrSchildRadius(x, y, z, a),
+        12,
+      );
+    }
+  });
+
+  it('approaches |x| from below, with the deficit falling off as a^2/|x|', () => {
+    const a = 0.9 * M;
+    // Off-axis so the a^2 z^2 term does not vanish.
+    const deficitAt = (scale: number): number => {
+      const x = scale * 0.6;
+      const z = scale * 0.8;
+      return Math.hypot(x, 0, z) - kerrSchildRadius(x, 0, z, a);
+    };
+    const near = deficitAt(20);
+    const far = deficitAt(200);
+    expect(near).toBeGreaterThan(0);
+    expect(far).toBeGreaterThan(0);
+    expect(far).toBeLessThan(near);
+    // Ten times further out, ten times smaller.
+    expect(near / far).toBeCloseTo(10, 0);
+  });
+});
+
+describe('spin frame', () => {
+  const rng = mulberry32(23);
+  const randomVec = () => ({ x: rng() * 2 - 1, y: rng() * 2 - 1, z: rng() * 2 - 1 });
+  const cross = (u: { x: number; y: number; z: number }, v: { x: number; y: number; z: number }) => ({
+    x: u.y * v.z - u.z * v.y,
+    y: u.z * v.x - u.x * v.z,
+    z: u.x * v.y - u.y * v.x,
+  });
+
+  it('round trips world -> spin -> world', () => {
+    for (let i = 0; i < 40; i++) {
+      const w = randomVec();
+      const back = worldFrame(spinFrame(w));
+      expect(back.x).toBeCloseTo(w.x, 15);
+      expect(back.y).toBeCloseTo(w.y, 15);
+      expect(back.z).toBeCloseTo(w.z, 15);
+    }
+  });
+
+  it('is right handed, so cross products survive the change of frame', () => {
+    for (let i = 0; i < 40; i++) {
+      const u = randomVec();
+      const v = randomVec();
+      const mapped = spinFrame(cross(u, v));
+      const crossed = cross(spinFrame(u), spinFrame(v));
+      expect(mapped.x).toBeCloseTo(crossed.x, 15);
+      expect(mapped.y).toBeCloseTo(crossed.y, 15);
+      expect(mapped.z).toBeCloseTo(crossed.z, 15);
+    }
+  });
+
+  it('maps the disc gas at world (r, 0, 0) to +Y, so positive spin is prograde', () => {
+    // The disc orbits along phiHat = (-z, 0, x); at (r, 0, 0) that is +z.
+    const gas = spinFrame({ x: 0, y: 0, z: 1 });
+    expect(gas).toEqual({ x: 0, y: 1, z: -0 });
+    const position = spinFrame({ x: 5, y: 0, z: 0 });
+    expect(position).toEqual({ x: 5, y: 0, z: -0 });
+  });
+});
+
+describe('circular orbit kinematics', () => {
+  it('reproduces the Schwarzschild disc expressions at zero spin', () => {
+    for (let r = 3; r <= 40; r += 0.25) {
+      const k = circularOrbitKinematics(r, 0);
+      expect(k.omega).toBeCloseTo(Math.sqrt(M / (r * r * r)), 12);
+      expect(k.speedVsZamo).toBeCloseTo(Math.sqrt(M / (r - 2 * M)), 12);
+      expect(k.redshift).toBeCloseTo(Math.sqrt(1 - (3 * M) / r), 12);
+    }
+  });
+
+  it('stays physical from the ISCO outward at every spin', () => {
+    for (const spin of [0, 0.3, 0.6, 0.9, A_STAR_MAX]) {
+      const a = spin * M;
+      const isco = innermostStableCircularOrbit(spin, 'prograde');
+      let previousRedshift = 0;
+      for (let r = isco; r <= 30; r += 0.1) {
+        const k = circularOrbitKinematics(r, a);
+        expect(k.speedVsZamo).toBeGreaterThan(0);
+        expect(k.speedVsZamo).toBeLessThan(1);
+        expect(k.redshift).toBeGreaterThan(0);
+        expect(k.redshift).toBeLessThanOrEqual(1);
+        // Light from further out climbs out of a shallower well.
+        expect(k.redshift).toBeGreaterThan(previousRedshift);
+        previousRedshift = k.redshift;
+      }
+    }
+  });
+
+  it('approaches the extremal ISCO speed of c/2', () => {
+    // The classic extremal value, and an independent check on the Delta and
+    // u^t algebra. It is a limit: at the shipped 0.998 clamp the speed is
+    // still 0.565, and only near a/M = 1 does it settle on 0.5.
+    const spin = 1 - 1e-8;
+    const isco = innermostStableCircularOrbit(spin, 'prograde');
+    expect(circularOrbitKinematics(isco, spin * M).speedVsZamo).toBeCloseTo(0.5, 2);
+  });
+});
diff --git a/src/physics/__tests__/relativity.test.ts b/src/physics/__tests__/relativity.test.ts
new file mode 100644
index 0000000..5cc32de
--- /dev/null
+++ b/src/physics/__tests__/relativity.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+import type { Vec3 } from '../geodesic';
+import {
+  MAX_OBSERVER_BETA,
+  aberrateLookDirection,
+  circularOrbitBeta,
+  freeFallBeta,
+  lorentzGamma,
+} from '../relativity';
+
+const AT_REST: Vec3 = { x: 0, y: 0, z: 0 };
+
+/** A spread of unit look directions, none of them axis aligned by accident. */
+function lookGrid(): Vec3[] {
+  const out: Vec3[] = [];
+  for (let i = 0; i < 8; i++) {
+    for (let j = 1; j < 8; j++) {
+      const phi = (i / 8) * 2 * Math.PI;
+      const theta = (j / 8) * Math.PI;
+      out.push({
+        x: Math.sin(theta) * Math.cos(phi),
+        y: Math.cos(theta),
+        z: Math.sin(theta) * Math.sin(phi),
+      });
+    }
+  }
+  return out;
+}
+
+const scaled = (v: Vec3, s: number): Vec3 => ({ x: v.x * s, y: v.y * s, z: v.z * s });
+const dot = (u: Vec3, v: Vec3): number => u.x * v.x + u.y * v.y + u.z * v.z;
+
+describe('aberration', () => {
+  it('is exactly the identity for an observer at rest', () => {
+    for (const look of lookGrid()) {
+      const ray = aberrateLookDirection(look, AT_REST);
+      expect(ray.dir.x).toBe(look.x);
+      expect(ray.dir.y).toBe(look.y);
+      expect(ray.dir.z).toBe(look.z);
+      expect(ray.doppler).toBe(1);
+    }
+  });
+
+  it('keeps the direction a unit vector at every speed', () => {
+    const axis: Vec3 = { x: 0.6, y: 0.48, z: 0.64 };
+    for (const speed of [0.1, 0.5, 0.95]) {
+      const beta = scaled(axis, speed);
+      for (const look of lookGrid()) {
+        const { dir } = aberrateLookDirection(look, beta);
+        expect(Math.abs(Math.hypot(dir.x, dir.y, dir.z) - 1)).toBeLessThan(1e-12);
+      }
+    }
+  });
+
+  it('undoes itself when the boost is reversed', () => {
+    const beta: Vec3 = { x: 0.3, y: -0.42, z: 0.15 };
+    const reverse = scaled(beta, -1);
+    for (const look of lookGrid()) {
+      const forward = aberrateLookDirection(look, beta);
+      const back = aberrateLookDirection(forward.dir, reverse);
+      expect(back.dir.x).toBeCloseTo(look.x, 12);
+      expect(back.dir.y).toBeCloseTo(look.y, 12);
+      expect(back.dir.z).toBeCloseTo(look.z, 12);
+      expect(forward.doppler * back.doppler).toBeCloseTo(1, 12);
+    }
+  });
+
+  it('drags every static direction backward, which is the headlight effect', () => {
+    const forward: Vec3 = { x: 1, y: 0, z: 0 };
+    const beta = scaled(forward, 0.7);
+    for (const look of lookGrid()) {
+      // Straight ahead and straight behind are fixed points, asserted below.
+      if (Math.abs(dot(look, forward)) > 1 - 1e-9) continue;
+      const { dir } = aberrateLookDirection(look, beta);
+      expect(dot(dir, forward)).toBeLessThan(dot(look, forward));
+    }
+    // The two fixed points of the map: straight ahead and straight behind.
+    for (const look of [forward, scaled(forward, -1)]) {
+      const { dir } = aberrateLookDirection(look, beta);
+      expect(dot(dir, forward)).toBeCloseTo(dot(look, forward), 12);
+    }
+  });
+
+  it('gives the textbook Doppler factors along, against and across the motion', () => {
+    const speed = 0.6;
+    const gamma = lorentzGamma(speed);
+    const beta: Vec3 = { x: 0, y: 0, z: speed };
+    expect(aberrateLookDirection({ x: 0, y: 0, z: 1 }, beta).doppler).toBeCloseTo(
+      gamma * (1 + speed),
+      12,
+    );
+    expect(aberrateLookDirection({ x: 0, y: 0, z: -1 }, beta).doppler).toBeCloseTo(
+      gamma * (1 - speed),
+      12,
+    );
+    // Perpendicular in the camera frame: pure transverse redshift, the case
+    // that separates this form from the static-frame one.
+    expect(aberrateLookDirection({ x: 1, y: 0, z: 0 }, beta).doppler).toBeCloseTo(1 / gamma, 12);
+  });
+});
+
+describe('trajectory speeds', () => {
+  it('gives the ISCO circular speed of c/2 and falls off outward', () => {
+    expect(circularOrbitBeta(3, 1)).toBeCloseTo(0.5, 12);
+    let previous = 1;
+    for (let r = 3; r <= 40; r += 0.25) {
+      const beta = circularOrbitBeta(r, 1);
+      expect(beta).toBeLessThan(previous);
+      previous = beta;
+    }
+    for (let r = 1.0; r <= 1.3; r += 0.05) {
+      expect(circularOrbitBeta(r, 1)).toBeLessThanOrEqual(MAX_OBSERVER_BETA);
+    }
+  });
+
+  it('gives the free-fall speed sqrt(rs/r) outside the horizon and clamps inside', () => {
+    for (let r = 1.2; r <= 40; r += 0.4) {
+      expect(freeFallBeta(r, 1)).toBeCloseTo(Math.sqrt(1 / r), 12);
+    }
+    let previous = 1;
+    for (let r = 1.2; r <= 40; r += 0.4) {
+      const beta = freeFallBeta(r, 1);
+      expect(beta).toBeLessThan(previous);
+      previous = beta;
+    }
+    expect(freeFallBeta(1, 1)).toBe(MAX_OBSERVER_BETA);
+    expect(freeFallBeta(0.4, 1)).toBe(MAX_OBSERVER_BETA);
+    expect(lorentzGamma(freeFallBeta(0, 1))).toBeLessThan(4);
+  });
+});
diff --git a/src/physics/constants.ts b/src/physics/constants.ts
index 9567f68..f08589e 100644
--- a/src/physics/constants.ts
+++ b/src/physics/constants.ts
@@ -1,41 +1,66 @@
 /**
- * Physics constants for a Schwarzschild black hole in geometric units.
+ * Physics constants for a Kerr black hole in geometric units, whose zero-spin
+ * case is Schwarzschild.
  *
  * c = G = 1 and the length unit is the Schwarzschild radius, r_s = 1,
  * so the mass is M = 1/2. The black hole sits at the world origin and the
  * accretion disc lies in the equatorial plane y = 0. Every other module
  * (CPU integrator, GLSL shaders, simulation) reads its numbers from here,
  * which is what keeps the shader image and the CPU photon paths consistent.
+ *
+ * The four radii below (R_S, R_PHOTON, R_ISCO, B_CRIT) are the a = 0
+ * specialisations of the closed forms in physics/kerr.ts. A test pins them
+ * against each other, so the two files cannot drift apart.
  */
 
-/** Schwarzschild radius (the event horizon). */
+/** Schwarzschild radius (the event horizon at zero spin). */
 export const R_S = 1.0;
 
 /** Black hole mass: r_s = 2M with r_s = 1. */
 export const M = 0.5;
 
-/** Photon sphere radius, 3M. */
+/** Photon sphere radius at zero spin, 3M. */
 export const R_PHOTON = 1.5;
 
-/** Innermost stable circular orbit, 6M = 3 r_s. Inner edge of the disc. */
+/** Innermost stable circular orbit at zero spin, 6M = 3 r_s. */
 export const R_ISCO = 3.0;
 
 /** Outer edge of the accretion disc. */
 export const DISC_OUTER = 9.0;
 
 /**
- * Critical impact parameter b_crit = 3*sqrt(3)*M. Rays aimed with b below
- * this are captured; it is also the apparent radius of the shadow.
+ * Critical impact parameter b_crit = 3*sqrt(3)*M at zero spin. Rays aimed
+ * with b below this are captured; it is also the apparent shadow radius.
  */
 export const B_CRIT = (3 * Math.sqrt(3)) / 2;
 
+/**
+ * Largest dimensionless spin a/M the app allows, the Thorne limit. A hole fed
+ * by a thin disc cannot be spun past roughly this: the photons it captures
+ * from the inner disc carry negative angular momentum on average and spin it
+ * back down, so accretion saturates near 0.998 rather than at 1. It doubles as
+ * the value that keeps the near-extremal closed forms well conditioned, since
+ * (r_photon - M) in the critical impact parameter goes to zero at a/M = 1.
+ */
+export const A_STAR_MAX = 0.998;
+
+/**
+ * Unit vector along the hole's angular momentum for a positive spin, in world
+ * coordinates. Derived, not chosen: the disc orbits along
+ * phiHat = (-z, 0, x) (see `discEmission` in shaders/geodesic.frag and
+ * `initialVelocity` in sim/placement.ts), so at world (r, 0, 0) the gas moves
+ * along +z and its angular momentum r x v points along -y. A positive spin is
+ * prograde with the disc, so it points the same way.
+ */
+export const SPIN_AXIS = { x: 0, y: -1, z: 0 } as const;
+
 /** Radius beyond which an outward-moving ray is considered escaped. */
 export const R_ESCAPE = 40.0;
 
-/** Capture radius, slightly outside the horizon to avoid stiffness at r -> 1. */
+/** Capture radius, as a multiple of the horizon radius. */
 export const R_CAPTURE = 1.02;
 
-/** Adaptive step size: dt = clamp(STEP_K * (r - 0.9), DT_MIN, DT_MAX). */
+/** Adaptive step size: dt = clamp(STEP_K * (r - 0.9 * r_horizon), DT_MIN, DT_MAX). */
 export const STEP_K = 0.15;
 export const DT_MIN = 0.02;
 export const DT_MAX = 0.35;
@@ -43,6 +68,9 @@ export const DT_MAX = 0.35;
 /**
  * GLSL `#define` map mirroring the constants above, merged into the defines
  * of every shader that integrates geodesics or draws the disc.
+ *
+ * Spin is deliberately absent: it changes per frame and travels as a uniform,
+ * so moving the slider never recompiles a program.
  */
 export function glslDefineMap(): Record<string, string> {
   return {
diff --git a/src/physics/geodesic.ts b/src/physics/geodesic.ts
index 4d43335..15f45d8 100644
--- a/src/physics/geodesic.ts
+++ b/src/physics/geodesic.ts
@@ -1,7 +1,10 @@
 /**
- * CPU integrator for Schwarzschild null geodesics.
+ * CPU integrator for null geodesics. Two paths live here, and the shader
+ * mirrors both line for line so the drawn photon paths land exactly on the
+ * features the raymarcher renders (photon ring, shadow edge).
  *
- * Uses the 3D vector form of the photon equation of motion (r_s = 1 units):
+ * SCHWARZSCHILD (the default, and the only path when `spin` is 0 or absent).
+ * The 3D vector form of the photon equation of motion (r_s = 1 units):
  *
  *     x'' = -1.5 * r_s * h^2 * x / r^5,   h = |x × x'|
  *
@@ -10,11 +13,37 @@
  * With a second black hole present, the deflections of the two centers are
  * superposed (each with its own h about that center), the standard
  * approximation, exact for one hole and qualitatively right for two.
- * The same equations, RK4 scheme, and step-size formula run in the fragment
- * shader, so paths drawn from these results land exactly on the features the
- * shader renders (photon ring, shadow edge).
+ *
+ * KERR (`spin` > 0, one center only). The exact Kerr metric in Cartesian
+ * Kerr-Schild form, integrated as a Hamiltonian system on (x, p_i) with
+ * p_t = -1:
+ *
+ *     g^{mu nu} = eta^{mu nu} - f l^mu l^nu,   l^0 = -1, l^i = k_i
+ *     H = 0.5 (p.p - 1 - f kappa^2),           kappa = 1 + k.p
+ *     dx/dlambda =  dH/dp = p - f kappa k
+ *     dp/dlambda = -dH/dx = 0.5 kappa^2 grad(f) + f kappa (p . grad k)
+ *
+ * Kerr-Schild is the coordinate system that survives the horizon (no
+ * coordinate singularity at r+), and its Cartesian layout matches the
+ * existing march, so the disc-crossing test and the body intersection are
+ * unchanged. The spatial derivatives are analytic, so one derivative
+ * evaluation costs one field evaluation.
+ *
+ * The two paths are deliberately not unified. The Kerr expressions are
+ * analytically identical to the Schwarzschild ones at a = 0 but not identical
+ * in floating point, and `spin: 0` has to reproduce the shipped image exactly.
  */
-import { DT_MAX, DT_MIN, R_CAPTURE, R_ESCAPE, STEP_K } from './constants';
+import {
+  DT_MAX,
+  DT_MIN,
+  M,
+  R_CAPTURE,
+  R_ESCAPE,
+  SPIN_AXIS,
+  STEP_K,
+} from './constants';
+import { sweptAngle } from './imageOrder';
+import { horizonRadius } from './kerr';
 
 export interface Vec3 {
   x: number;
@@ -38,6 +67,18 @@ export interface GeodesicResult {
   fate: GeodesicFate;
   /** Impact parameter |x0 × dir| about the primary (first center). */
   b: number;
+  /**
+   * Signed axial angular momentum L_z about SPIN_AXIS at launch. Positive is
+   * prograde with the hole's spin and with the disc, which is what picks the
+   * prograde or retrograde critical impact parameter for this ray.
+   */
+  axialAngularMomentum: number;
+  /**
+   * Total angle swept about the primary along the path. Feed it to
+   * `imageOrder` in physics/imageOrder.ts to say which lensed image of the
+   * disc this ray belongs to.
+   */
+  windingAngle: number;
 }
 
 export interface GeodesicOptions {
@@ -47,6 +88,11 @@ export interface GeodesicOptions {
   recordEvery?: number;
   /** Lensing centers; defaults to a unit black hole at the origin. */
   centers?: readonly GravityCenter[];
+  /**
+   * Dimensionless Kerr spin a/M, prograde with the disc. 0 (the default)
+   * selects the Schwarzschild path verbatim. Defined for a single center only.
+   */
+  spin?: number;
 }
 
 const DEFAULT_CENTERS: readonly GravityCenter[] = [{ x: 0, y: 0, z: 0, rs: 1 }];
@@ -142,10 +188,226 @@ function stepSize(s: State, centers: readonly GravityCenter[]): number {
   return Math.min(Math.max(STEP_K * margin, DT_MIN), DT_MAX);
 }
 
+// --- Kerr-Schild field and Hamiltonian ---------------------------------
+//
+// Everything from here to `integrateKerr` is written in the spin frame, a
+// right-handed frame whose +Z is the hole's angular momentum; `spinFrame` and
+// `worldFrame` in kerr.ts convert. The frame conversion is a swizzle, so the
+// march itself stays in world coordinates and the disc, jet and body geometry
+// are untouched.
+
+/** Kerr-Schild scalars at a point in the spin frame. */
+interface KerrField {
+  /** Kerr-Schild radius: |x| when a = 0, an oblate spheroid otherwise. */
+  radius: number;
+  /** f = 2 M r^3 / (r^4 + a^2 Z^2), the whole mass dependence of the metric. */
+  f: number;
+  /** The principal null direction, a unit vector by construction. */
+  kx: number;
+  ky: number;
+  kz: number;
+}
+
+const field: KerrField = { radius: 0, f: 0, kx: 0, ky: 0, kz: 0 };
+
+function kerrFieldInto(out: KerrField, X: number, Y: number, Z: number, a: number, mass: number): void {
+  const term = X * X + Y * Y + Z * Z - a * a;
+  const radius = Math.sqrt(Math.max(0.5 * (term + Math.sqrt(term * term + 4 * a * a * Z * Z)), 1e-12));
+  const r2 = radius * radius;
+  const w = r2 + a * a;
+  const sigma = r2 * r2 + a * a * Z * Z;
+  out.radius = radius;
+  out.f = (2 * mass * r2 * radius) / sigma;
+  out.kx = (radius * X + a * Y) / w;
+  out.ky = (radius * Y - a * X) / w;
+  out.kz = Z / radius;
+}
+
+/**
+ * Hamiltonian derivatives in world coordinates: dx/dlambda into `outDx`,
+ * dp/dlambda into `outDp`. `x` is measured from the hole's center.
+ */
+function kerrDerivativesInto(
+  outDx: Vec3,
+  outDp: Vec3,
+  x: number,
+  y: number,
+  z: number,
+  px: number,
+  py: number,
+  pz: number,
+  a: number,
+  mass: number,
+): void {
+  // World -> spin frame (see kerr.ts spinFrame); p is rotated like x.
+  const bigX = x;
+  const bigY = z;
+  const bigZ = -y;
+  const bigPx = px;
+  const bigPy = pz;
+  const bigPz = -py;
+
+  kerrFieldInto(field, bigX, bigY, bigZ, a, mass);
+  const r = field.radius;
+  const r2 = r * r;
+  const w = r2 + a * a;
+  const sigma = r2 * r2 + a * a * bigZ * bigZ;
+  const f = field.f;
+  const kappa = 1 + field.kx * bigPx + field.ky * bigPy + field.kz * bigPz;
+
+  // grad r, from differentiating (X^2+Y^2)/(r^2+a^2) + Z^2/r^2 = 1.
+  const d = (r * (bigX * bigX + bigY * bigY)) / (w * w) + (bigZ * bigZ) / (r2 * r);
+  const gradRx = bigX / (w * d);
+  const gradRy = bigY / (w * d);
+  const gradRz = bigZ / (r2 * d);
+
+  // grad f = cRadial * grad r + cAxial * zHat.
+  const cRadial = (2 * mass * r2 * (3 * a * a * bigZ * bigZ - r2 * r2)) / (sigma * sigma);
+  const cAxial = (-4 * mass * a * a * r2 * r * bigZ) / (sigma * sigma);
+
+  // p . d_i k = aRadial * grad r_i + bAxis_i.
+  const aRadial =
+    (bigX * bigPx + bigY * bigPy - 2 * r * (field.kx * bigPx + field.ky * bigPy)) / w -
+    (bigZ * bigPz) / r2;
+  const bAxisX = (r * bigPx - a * bigPy) / w;
+  const bAxisY = (a * bigPx + r * bigPy) / w;
+  const bAxisZ = bigPz / r;
+
+  const halfKappa2 = 0.5 * kappa * kappa;
+  const fKappa = f * kappa;
+  const radialWeight = halfKappa2 * cRadial + fKappa * aRadial;
+
+  const dxX = bigPx - fKappa * field.kx;
+  const dxY = bigPy - fKappa * field.ky;
+  const dxZ = bigPz - fKappa * field.kz;
+  const dpX = radialWeight * gradRx + fKappa * bAxisX;
+  const dpY = radialWeight * gradRy + fKappa * bAxisY;
+  const dpZ = radialWeight * gradRz + halfKappa2 * cAxial + fKappa * bAxisZ;
+
+  // Spin frame -> world (worldFrame).
+  outDx.x = dxX;
+  outDx.y = -dxZ;
+  outDx.z = dxY;
+  outDp.x = dpX;
+  outDp.y = -dpZ;
+  outDp.z = dpY;
+}
+
+/**
+ * The Hamiltonian at a state, which is exactly 0 for a null ray and is the
+ * conserved quantity the integration tests watch. `x` is measured from the
+ * hole's center, in world coordinates.
+ */
+export function kerrHamiltonian(x: Vec3, p: Vec3, a: number, mass: number = M): number {
+  kerrFieldInto(field, x.x, x.z, -x.y, a, mass);
+  const kappa = 1 + field.kx * p.x + field.ky * p.z + field.kz * -p.y;
+  return 0.5 * (p.x * p.x + p.y * p.y + p.z * p.z - 1 - field.f * kappa * kappa);
+}
+
+/**
+ * The null momentum whose spatial covector points along `dir`, so that
+ * H(x, p) = 0 exactly. Solving the quadratic in the scale factor gives
+ *
+ *     s = (f beta + sqrt(1 + f (1 - beta^2))) / (1 - f beta^2),  beta = k.dir
+ *
+ * which is 1 when f is 0, so a distant camera launches p = dir unchanged.
+ * The denominator is positive everywhere outside the horizon, and the camera
+ * rig clamps to 3 r_s.
+ */
+export function kerrNullMomentum(x: Vec3, dir: Vec3, a: number, mass: number = M): Vec3 {
+  kerrFieldInto(field, x.x, x.z, -x.y, a, mass);
+  const beta = field.kx * dir.x + field.ky * dir.z + field.kz * -dir.y;
+  const f = field.f;
+  const scale = (f * beta + Math.sqrt(1 + f * (1 - beta * beta))) / (1 - f * beta * beta);
+  return { x: scale * dir.x, y: scale * dir.y, z: scale * dir.z };
+}
+
+/** dx/dlambda and dp/dlambda at a state, in world coordinates. */
+export interface KerrDerivative {
+  dx: Vec3;
+  dp: Vec3;
+}
+
+/**
+ * The Kerr equations of motion at one state, allocating a fresh result.
+ * The integrator uses the scratch-buffer form; this is the same physics in
+ * the shape a test or a reader wants, and it is what the conservation tests
+ * drive directly.
+ */
+export function kerrDerivatives(x: Vec3, p: Vec3, a: number, mass: number = M): KerrDerivative {
+  const dx: Vec3 = { x: 0, y: 0, z: 0 };
+  const dp: Vec3 = { x: 0, y: 0, z: 0 };
+  kerrDerivativesInto(dx, dp, x.x, x.y, x.z, p.x, p.y, p.z, a, mass);
+  return { dx, dp };
+}
+
+interface KerrState {
+  x: number;
+  y: number;
+  z: number;
+  px: number;
+  py: number;
+  pz: number;
+}
+
+const dx1: Vec3 = { x: 0, y: 0, z: 0 };
+const dp1: Vec3 = { x: 0, y: 0, z: 0 };
+const dx2: Vec3 = { x: 0, y: 0, z: 0 };
+const dp2: Vec3 = { x: 0, y: 0, z: 0 };
+const dx3: Vec3 = { x: 0, y: 0, z: 0 };
+const dp3: Vec3 = { x: 0, y: 0, z: 0 };
+const dx4: Vec3 = { x: 0, y: 0, z: 0 };
+const dp4: Vec3 = { x: 0, y: 0, z: 0 };
+
+function rk4KerrStep(s: KerrState, dt: number, a: number, mass: number): void {
+  const h = dt * 0.5;
+  kerrDerivativesInto(dx1, dp1, s.x, s.y, s.z, s.px, s.py, s.pz, a, mass);
+  kerrDerivativesInto(
+    dx2, dp2,
+    s.x + h * dx1.x, s.y + h * dx1.y, s.z + h * dx1.z,
+    s.px + h * dp1.x, s.py + h * dp1.y, s.pz + h * dp1.z,
+    a, mass,
+  );
+  kerrDerivativesInto(
+    dx3, dp3,
+    s.x + h * dx2.x, s.y + h * dx2.y, s.z + h * dx2.z,
+    s.px + h * dp2.x, s.py + h * dp2.y, s.pz + h * dp2.z,
+    a, mass,
+  );
+  kerrDerivativesInto(
+    dx4, dp4,
+    s.x + dt * dx3.x, s.y + dt * dx3.y, s.z + dt * dx3.z,
+    s.px + dt * dp3.x, s.py + dt * dp3.y, s.pz + dt * dp3.z,
+    a, mass,
+  );
+  const sixth = dt / 6;
+  s.x += sixth * (dx1.x + 2 * dx2.x + 2 * dx3.x + dx4.x);
+  s.y += sixth * (dx1.y + 2 * dx2.y + 2 * dx3.y + dx4.y);
+  s.z += sixth * (dx1.z + 2 * dx2.z + 2 * dx3.z + dx4.z);
+  s.px += sixth * (dp1.x + 2 * dp2.x + 2 * dp3.x + dp4.x);
+  s.py += sixth * (dp1.y + 2 * dp2.y + 2 * dp3.y + dp4.y);
+  s.pz += sixth * (dp1.z + 2 * dp2.z + 2 * dp3.z + dp4.z);
+}
+
+/** Signed angular momentum about the spin axis: (x cross p) . SPIN_AXIS. */
+function axialAngularMomentumOf(x: Vec3, p: Vec3): number {
+  return (
+    (x.y * p.z - x.z * p.y) * SPIN_AXIS.x +
+    (x.z * p.x - x.x * p.z) * SPIN_AXIS.y +
+    (x.x * p.y - x.y * p.x) * SPIN_AXIS.z
+  );
+}
+
+const chordFrom: Vec3 = { x: 0, y: 0, z: 0 };
+const chordTo: Vec3 = { x: 0, y: 0, z: 0 };
+
 /**
  * Integrate a photon launched from `origin` along `dir` until it is captured
  * by a horizon, escapes past `escapeR` moving outward, or runs out of steps
  * (near-critical rays orbiting a photon sphere).
+ *
+ * Pass `spin` to solve the exact Kerr metric instead; it is defined for a
+ * single center only and throws otherwise.
  */
 export function integrateNullGeodesic(
   origin: Vec3,
@@ -156,6 +418,14 @@ export function integrateNullGeodesic(
   const escapeR = opts.escapeR ?? R_ESCAPE;
   const recordEvery = opts.recordEvery ?? 2;
   const centers = opts.centers && opts.centers.length > 0 ? opts.centers : DEFAULT_CENTERS;
+  const spin = opts.spin ?? 0;
+
+  if (spin > 0 && centers.length > 1) {
+    throw new Error('Kerr spin is not defined for superposed centers');
+  }
+  if (spin > 0) {
+    return integrateKerr(origin, dir, spin, centers[0]!, maxSteps, escapeR, recordEvery);
+  }
 
   const dLen = Math.hypot(dir.x, dir.y, dir.z);
   const s: State = {
@@ -171,9 +441,14 @@ export function integrateNullGeodesic(
   const ry = s.py - primary.y;
   const rz = s.pz - primary.z;
   const b = Math.hypot(ry * s.vz - rz * s.vy, rz * s.vx - rx * s.vz, rx * s.vy - ry * s.vx);
+  const axialAngularMomentum = axialAngularMomentumOf(
+    { x: rx, y: ry, z: rz },
+    { x: s.vx, y: s.vy, z: s.vz },
+  );
 
   const pts: number[] = [s.px, s.py, s.pz];
   let fate: GeodesicFate = 'maxsteps';
+  let windingAngle = 0;
 
   for (let i = 0; i < maxSteps; i++) {
     if (captured(s, centers)) {
@@ -187,12 +462,93 @@ export function integrateNullGeodesic(
       break;
     }
 
+    chordFrom.x = s.px - primary.x;
+    chordFrom.y = s.py - primary.y;
+    chordFrom.z = s.pz - primary.z;
     rk4Step(s, stepSize(s, centers), centers);
+    chordTo.x = s.px - primary.x;
+    chordTo.y = s.py - primary.y;
+    chordTo.z = s.pz - primary.z;
+    windingAngle += sweptAngle(chordFrom, chordTo);
     if (i % recordEvery === 0) pts.push(s.px, s.py, s.pz);
   }
   pts.push(s.px, s.py, s.pz);
 
-  return { points: new Float32Array(pts), fate, b };
+  return { points: new Float32Array(pts), fate, b, axialAngularMomentum, windingAngle };
+}
+
+function integrateKerr(
+  origin: Vec3,
+  dir: Vec3,
+  spin: number,
+  center: GravityCenter,
+  maxSteps: number,
+  escapeR: number,
+  recordEvery: number,
+): GeodesicResult {
+  const mass = 0.5 * center.rs;
+  const a = spin * mass;
+  const rPlus = horizonRadius(spin) * center.rs;
+  const capture = R_CAPTURE * rPlus;
+
+  const dLen = Math.hypot(dir.x, dir.y, dir.z);
+  const unitDir: Vec3 = { x: dir.x / dLen, y: dir.y / dLen, z: dir.z / dLen };
+  const start: Vec3 = {
+    x: origin.x - center.x,
+    y: origin.y - center.y,
+    z: origin.z - center.z,
+  };
+  const p0 = kerrNullMomentum(start, unitDir, a, mass);
+
+  const s: KerrState = { x: start.x, y: start.y, z: start.z, px: p0.x, py: p0.y, pz: p0.z };
+  const b = Math.hypot(
+    start.y * unitDir.z - start.z * unitDir.y,
+    start.z * unitDir.x - start.x * unitDir.z,
+    start.x * unitDir.y - start.y * unitDir.x,
+  );
+  const axialAngularMomentum = axialAngularMomentumOf(start, p0);
+
+  const pts: number[] = [origin.x, origin.y, origin.z];
+  let fate: GeodesicFate = 'maxsteps';
+  let windingAngle = 0;
+
+  for (let i = 0; i < maxSteps; i++) {
+    kerrFieldInto(field, s.x, s.z, -s.y, a, mass);
+    const radius = field.radius;
+    if (radius < capture) {
+      fate = 'captured';
+      break;
+    }
+    // Escape is tested against the marching direction dx/dlambda = p - f kappa k,
+    // not against p: near the hole the two differ by a large angle, and the
+    // sign of x . dx is what actually says the ray is leaving.
+    const kappa = 1 + field.kx * s.px + field.ky * s.pz + field.kz * -s.py;
+    const drag = field.f * kappa;
+    // dx/dlambda in the spin frame is (px - drag kX, pz - drag kY, -py - drag kZ);
+    // worldFrame maps that back to (X, -Z, Y).
+    const marchX = s.px - drag * field.kx;
+    const marchY = s.py + drag * field.kz;
+    const marchZ = s.pz - drag * field.ky;
+    const rCoord = Math.hypot(s.x, s.y, s.z);
+    if (rCoord > escapeR && s.x * marchX + s.y * marchY + s.z * marchZ > 0) {
+      fate = 'escaped';
+      break;
+    }
+
+    const dt = Math.min(Math.max(STEP_K * (radius - 0.9 * rPlus), DT_MIN), DT_MAX);
+    chordFrom.x = s.x;
+    chordFrom.y = s.y;
+    chordFrom.z = s.z;
+    rk4KerrStep(s, dt, a, mass);
+    chordTo.x = s.x;
+    chordTo.y = s.y;
+    chordTo.z = s.z;
+    windingAngle += sweptAngle(chordFrom, chordTo);
+    if (i % recordEvery === 0) pts.push(s.x + center.x, s.y + center.y, s.z + center.z);
+  }
+  pts.push(s.x + center.x, s.y + center.y, s.z + center.z);
+
+  return { points: new Float32Array(pts), fate, b, axialAngularMomentum, windingAngle };
 }
 
 /** Weak-field light deflection angle (radians) for impact parameter b, r_s = 1. */
diff --git a/src/physics/imageOrder.ts b/src/physics/imageOrder.ts
new file mode 100644
index 0000000..c6c14de
--- /dev/null
+++ b/src/physics/imageOrder.ts
@@ -0,0 +1,59 @@
+/**
+ * Image order: how many half turns light made around the hole before it
+ * reached the camera. Pure functions, no THREE, no DOM.
+ *
+ * The classifier is the winding angle Phi, the angle swept by the position
+ * vector along the ray, and not a count of equatorial-plane crossings: a
+ * perfectly straight, unlensed ray from a camera above the plane crosses the
+ * plane once, so a crossing counter calls it a first-order image. Winding does
+ * not have that failure.
+ *
+ * For a camera at elevation eps above the disc plane the direct image of the
+ * disc spans Phi in [eps, pi - eps] and the first-order image spans
+ * [pi + eps, 2pi - eps], so the boundaries at multiples of pi sit in the
+ * middle of a gap of width 2*eps. The margin is the camera elevation itself,
+ * which is why an exactly edge-on view is the one degenerate case.
+ *
+ * Winding is measured about the primary hole only. With a second hole in the
+ * scene the ray no longer stays in one plane and the count is indicative
+ * rather than exact.
+ */
+import type { Vec3 } from './geodesic';
+
+/**
+ * Highest order that gets its own colour. The shader selects among three
+ * tints with two mixes, so anything at or past two half turns shares one.
+ */
+export const IMAGE_ORDER_MAX = 2;
+
+/**
+ * Angle swept between two successive positions on a ray, small-angle form:
+ * |from x to| / (|from| |to|) rather than an acos, because it costs a cross
+ * product instead of an inverse trig call and the march never takes a large
+ * step in angle.
+ *
+ * The error budget is tied to the step clamp. The angle swept in one step is
+ * at most dt/r, and dt = clamp(STEP_K * (r - 0.9 r_h), DT_MIN, DT_MAX) forces
+ * r >= 3.2 before dt can reach DT_MAX, so dt/r peaks near 0.11 rad, where
+ * sin(t) understates t by 2.3e-4. Raise STEP_K or DT_MAX and that bound has to
+ * be rechecked, here and in the identical expression in shaders/kerr.glsl.
+ *
+ * Scale invariant in both arguments, so the caller feeds raw positions.
+ */
+export function sweptAngle(from: Vec3, to: Vec3): number {
+  const cx = from.y * to.z - from.z * to.y;
+  const cy = from.z * to.x - from.x * to.z;
+  const cz = from.x * to.y - from.y * to.x;
+  const lengths = Math.hypot(from.x, from.y, from.z) * Math.hypot(to.x, to.y, to.z);
+  if (lengths <= 0) return 0;
+  return Math.hypot(cx, cy, cz) / lengths;
+}
+
+/**
+ * Image order from an accumulated winding angle: 0 is the direct view, 1 is
+ * light that came round the far side once, 2 and beyond is the photon ring.
+ * A boundary belongs to the higher order.
+ */
+export function imageOrder(windingAngle: number): number {
+  return Math.min(Math.floor(windingAngle / Math.PI), IMAGE_ORDER_MAX);
+}
diff --git a/src/physics/kerr.ts b/src/physics/kerr.ts
new file mode 100644
index 0000000..cb5c6be
--- /dev/null
+++ b/src/physics/kerr.ts
@@ -0,0 +1,168 @@
+/**
+ * Kerr black hole: the closed forms, the Kerr-Schild field, and the frame the
+ * two live in. Pure functions, geometric units with r_s = 1 (so M = 0.5), no
+ * Three.js and no DOM.
+ *
+ * Two different spin numbers appear here and mixing them up is the easiest way
+ * to get everything subtly wrong, so they are named apart:
+ *
+ * - `spin` is the dimensionless a/M in [0, A_STAR_MAX]. Every closed-form
+ *   radius takes this and returns a length in r_s units.
+ * - `a` is the same spin in length units, a = spin * M (times r_s at the call
+ *   site when the hole has grown). The Kerr-Schild field takes this.
+ *
+ * Sign conventions. All Kerr math runs in a right-handed frame with the spin
+ * along +Z; `spinFrame` and `worldFrame` convert. `SPIN_AXIS` in constants.ts
+ * derives that direction from the disc's own orbital sense, so a positive spin
+ * is prograde with the gas. The signs of the `a` terms in the null vector `k`
+ * set the drag direction and are pinned by the prograde/retrograde capture
+ * test in __tests__/geodesic.test.ts, not by a citation.
+ *
+ * Sources: Bardeen, Press and Teukolsky (1972) for the ISCO and the photon
+ * orbits; Kerr (1963) in the Kerr-Schild Cartesian form for the field.
+ */
+import { M } from './constants';
+import type { Vec3 } from './geodesic';
+
+/** Which way round the hole an orbit runs, relative to the spin. */
+export type OrbitSense = 'prograde' | 'retrograde';
+
+function senseSign(sense: OrbitSense): number {
+  return sense === 'prograde' ? 1 : -1;
+}
+
+function clampToUnitInterval(x: number): number {
+  return Math.min(Math.max(x, -1), 1);
+}
+
+/**
+ * Outer event horizon, r+ = M (1 + sqrt(1 - (a/M)^2)).
+ * spin 0 -> 1.0 = R_S; spin 0.998 -> 0.5316; spin 1 -> M = 0.5.
+ */
+export function horizonRadius(spin: number): number {
+  return M * (1 + Math.sqrt(Math.max(1 - spin * spin, 0)));
+}
+
+/**
+ * Inner (Cauchy) horizon, r- = M (1 - sqrt(1 - (a/M)^2)). Nothing in the app
+ * renders it; it exists so the ordering test can assert r- < r+ and so
+ * docs/THEORY.md can point at a definition rather than a claim.
+ */
+export function innerHorizonRadius(spin: number): number {
+  return M * (1 - Math.sqrt(Math.max(1 - spin * spin, 0)));
+}
+
+/**
+ * Innermost stable circular orbit, the disc's inner edge (Bardeen, Press and
+ * Teukolsky 1972, eq. 2.21).
+ *
+ * spin 0 -> 3.0 r_s = R_ISCO for both senses; spin 0.998 prograde -> 0.6184;
+ * spin 1 prograde -> M = 0.5, retrograde -> 9M = 4.5.
+ */
+export function innermostStableCircularOrbit(spin: number, sense: OrbitSense): number {
+  const sgn = senseSign(sense);
+  const spin2 = spin * spin;
+  const z1 = 1 + Math.cbrt(1 - spin2) * (Math.cbrt(1 + spin) + Math.cbrt(1 - spin));
+  const z2 = Math.sqrt(3 * spin2 + z1 * z1);
+  return M * (3 + z2 - sgn * Math.sqrt(Math.max((3 - z1) * (3 + z1 + 2 * z2), 0)));
+}
+
+/**
+ * Radius of the equatorial circular photon orbit. Spin splits the single
+ * Schwarzschild photon sphere into two: the prograde one is dragged inward
+ * toward the horizon, the retrograde one pushed out.
+ *
+ * spin 0 -> 1.5 = R_PHOTON for both senses; spin 0.998 -> 0.5366 prograde and
+ * 1.9991 retrograde; spin 1 -> M = 0.5 prograde and 4M = 2.0 retrograde.
+ */
+export function circularPhotonOrbitRadius(spin: number, sense: OrbitSense): number {
+  const sgn = senseSign(sense);
+  return 2 * M * (1 + Math.cos((2 / 3) * Math.acos(clampToUnitInterval(-sgn * spin))));
+}
+
+/**
+ * Signed critical impact parameter b = L_z/E evaluated on the circular photon
+ * orbit of that sense: positive prograde, negative retrograde. Its magnitude
+ * is the apparent radius of that edge of the shadow, which is why the shadow
+ * goes lopsided as the spin rises.
+ *
+ * Solving R(r) = R'(r) = 0 for the equatorial null radial potential gives
+ * b = a +- 2 r sqrt(Delta) / (r - M) at r = r_photon.
+ *
+ * spin 0 -> +-3*sqrt(3)*M = +-B_CRIT; spin 0.998 -> +1.033 and -3.498;
+ * spin 1 retrograde -> -7M = -3.5.
+ *
+ * Prograde at exactly spin = 1 is degenerate: r_photon, r+ and M all coincide,
+ * (r - M) goes to zero and this expression is undefined (the true limit is
+ * 2M). The app never reaches it, because `setPrimarySpin` clamps to
+ * A_STAR_MAX = 0.998.
+ */
+export function criticalImpactParameter(spin: number, sense: OrbitSense): number {
+  const sgn = senseSign(sense);
+  const a = spin * M;
+  const r = circularPhotonOrbitRadius(spin, sense);
+  const delta = r * r - 2 * M * r + a * a;
+  return a + (sgn * 2 * r * Math.sqrt(Math.max(delta, 0))) / (r - M);
+}
+
+/**
+ * The Kerr-Schild radius at a point in the spin frame: the positive root of
+ * (X^2 + Y^2)/(r^2 + a^2) + Z^2/r^2 = 1, so surfaces of constant r are
+ * confocal oblate spheroids rather than spheres. Equals |x| exactly when
+ * a = 0, and approaches |x| from below as |x| grows.
+ *
+ * This is the radius every other Kerr expression is written in, and the one
+ * the horizon and capture tests are measured against.
+ */
+export function kerrSchildRadius(x: number, y: number, z: number, a: number): number {
+  const term = x * x + y * y + z * z - a * a;
+  return Math.sqrt(Math.max(0.5 * (term + Math.sqrt(term * term + 4 * a * a * z * z)), 0));
+}
+
+/**
+ * World coordinates -> the spin frame, a right-handed frame whose +Z lies
+ * along SPIN_AXIS = (0, -1, 0). Check: the disc's velocity direction at world
+ * (r, 0, 0) is (0, 0, 1), which maps to +Y, so increasing azimuth about +Z is
+ * prograde with the gas.
+ */
+export function spinFrame(world: Vec3): Vec3 {
+  return { x: world.x, y: world.z, z: -world.y };
+}
+
+/** The spin frame -> world coordinates; the exact inverse of `spinFrame`. */
+export function worldFrame(spun: Vec3): Vec3 {
+  return { x: spun.x, y: -spun.z, z: spun.y };
+}
+
+/** Kinematics of the prograde equatorial circular geodesic the disc rides. */
+export interface CircularOrbitKinematics {
+  /** Coordinate angular speed d(phi)/dt: sqrt(M) / (r^1.5 + a sqrt(M)). */
+  omega: number;
+  /** Orbital speed measured by the local non-rotating (ZAMO) observer. */
+  speedVsZamo: number;
+  /** 1/u^t, the gravitational + time-dilation factor for the emitted light. */
+  redshift: number;
+}
+
+/**
+ * Prograde equatorial circular geodesic at Boyer-Lindquist radius `radius`,
+ * with `a` in length units. At a = 0 these reduce algebraically and exactly to
+ * the three Schwarzschild expressions the disc shader has always used:
+ * sqrt(M/r^3), sqrt(M/(r - 2M)) and sqrt(1 - 3M/r).
+ */
+export function circularOrbitKinematics(radius: number, a: number): CircularOrbitKinematics {
+  const sqrtM = Math.sqrt(M);
+  const sqrtR = Math.sqrt(radius);
+  const r32 = radius * sqrtR;
+  const denom = r32 + a * sqrtM;
+  const delta = radius * radius - 2 * M * radius + a * a;
+  return {
+    omega: sqrtM / denom,
+    speedVsZamo:
+      (sqrtM * (radius * radius - 2 * a * sqrtM * sqrtR + a * a)) /
+      (Math.sqrt(Math.max(delta, 1e-9)) * denom),
+    redshift:
+      (Math.pow(radius, 0.75) * Math.sqrt(Math.max(r32 - 3 * M * sqrtR + 2 * a * sqrtM, 0))) /
+      denom,
+  };
+}
diff --git a/src/physics/relativity.ts b/src/physics/relativity.ts
new file mode 100644
index 0000000..6f1cc5b
--- /dev/null
+++ b/src/physics/relativity.ts
@@ -0,0 +1,86 @@
+/**
+ * Relativistic optics of a moving observer, in geometric units where c = 1 so
+ * beta is already a fraction of light speed. Pure functions, no THREE, no DOM.
+ *
+ * `aberrateLookDirection` is the executable specification of `aberratedRay()`
+ * in render/shaders/geodesic.frag, the same relationship physics/geodesic.ts
+ * already has with the geodesic march. The two are separate copies of one
+ * piece of algebra and must be edited together; the tests here are what fails
+ * when only one of them is.
+ */
+import type { Vec3 } from './geodesic';
+
+/**
+ * Ceiling on the observer speed the optics are computed from. gamma = 3.2 at
+ * 0.95, which is already a violent view, and it keeps 1 - beta^2 away from
+ * zero for a plunge that formally reaches light speed at the horizon.
+ */
+export const MAX_OBSERVER_BETA = 0.95;
+
+export function lorentzGamma(beta: number): number {
+  return 1 / Math.sqrt(1 - beta * beta);
+}
+
+/**
+ * Speed of a circular orbit at radius r, as measured by a static observer
+ * there: sqrt(M / (r - 2M)), the same expression `discEmission` uses for the
+ * gas (docs/THEORY.md part 9). 0.5 at the ISCO, r = 3 r_s.
+ *
+ * The denominator is floored rather than allowed to reach zero: there is no
+ * circular orbit at the horizon, and a tour that ends up there should read as
+ * "as fast as we model", not as a division by zero.
+ */
+export function circularOrbitBeta(r: number, rs: number): number {
+  return Math.min(Math.sqrt((0.5 * rs) / Math.max(r - rs, 0.3)), MAX_OBSERVER_BETA);
+}
+
+/**
+ * Speed of a body that fell from rest at infinity: sqrt(r_s / r), the escape
+ * speed relation of docs/THEORY.md part 3, run backwards. It reaches 1 at the
+ * horizon, so it is clamped.
+ */
+export function freeFallBeta(r: number, rs: number): number {
+  return Math.min(Math.sqrt(rs / Math.max(r, 1e-6)), MAX_OBSERVER_BETA);
+}
+
+export interface AberratedRay {
+  /** The same ray, expressed as a look direction in the static frame. */
+  dir: Vec3;
+  /** Received / emitted frequency ratio; above 1 looking into the motion. */
+  doppler: number;
+}
+
+/**
+ * Transform a look direction out of the observer's rest frame into the static
+ * coordinate frame the raymarch and the sky cubemap live in.
+ *
+ * Relativistic velocity addition applied to the photon's propagation
+ * direction -look, then negated back into a look direction:
+ *
+ *     dir     = (look/gamma - beta + (gamma/(gamma+1)) (look.beta) beta)
+ *               / (1 - look.beta)
+ *     doppler = 1 / (gamma (1 - look.beta))
+ *
+ * `look` must be a unit vector. At rest the whole thing is the identity, and
+ * the zero test below makes that exact rather than exact-to-rounding: a
+ * `normalize` of an already-unit vector can move it by an ulp, and the
+ * promise is that ordinary mouse orbiting renders the same frame it always
+ * did. It is a uniform-valued branch in the shader, so it costs nothing.
+ */
+export function aberrateLookDirection(look: Vec3, beta: Vec3): AberratedRay {
+  const beta2 = beta.x * beta.x + beta.y * beta.y + beta.z * beta.z;
+  if (beta2 === 0) return { dir: { x: look.x, y: look.y, z: look.z }, doppler: 1 };
+
+  const gamma = 1 / Math.sqrt(Math.max(1 - beta2, 1e-6));
+  const lookDotBeta = look.x * beta.x + look.y * beta.y + look.z * beta.z;
+  const invDenom = 1 / (1 - lookDotBeta);
+  const parallel = (gamma / (gamma + 1)) * lookDotBeta;
+  const x = (look.x / gamma - beta.x + parallel * beta.x) * invDenom;
+  const y = (look.y / gamma - beta.y + parallel * beta.y) * invDenom;
+  const z = (look.z / gamma - beta.z + parallel * beta.z) * invDenom;
+  const length = Math.hypot(x, y, z);
+  return {
+    dir: { x: x / length, y: y / length, z: z / length },
+    doppler: invDenom / gamma,
+  };
+}
diff --git a/src/render/__tests__/tourKinematics.test.ts b/src/render/__tests__/tourKinematics.test.ts
new file mode 100644
index 0000000..d894c21
--- /dev/null
+++ b/src/render/__tests__/tourKinematics.test.ts
@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { PerspectiveCamera } from 'three';
+import { CameraTour } from '../cameraTour';
+import { easedRunProgress, runSpeedFraction } from '../tourKinematics';
+import { circularOrbitBeta } from '../../physics/relativity';
+
+const RAMP = 0.15;
+
+describe('flyby speed profile', () => {
+  it('is the derivative of the distance travelled', () => {
+    const h = 1e-5;
+    for (let u = 0.02; u < 0.98; u += 0.01) {
+      const central = (easedRunProgress(u + h, RAMP) - easedRunProgress(u - h, RAMP)) / (2 * h);
+      expect(central).toBeCloseTo(runSpeedFraction(u, RAMP) / (1 - RAMP), 4);
+    }
+  });
+
+  it('is zero at both ends and full through the middle', () => {
+    expect(runSpeedFraction(0, RAMP)).toBe(0);
+    expect(runSpeedFraction(1, RAMP)).toBe(0);
+    for (let u = RAMP; u <= 1 - RAMP; u += 0.05) {
+      expect(runSpeedFraction(u, RAMP)).toBeCloseTo(1, 12);
+    }
+  });
+});
+
+describe('camera tour velocity', () => {
+  const cameraAt = (x: number, y: number, z: number): PerspectiveCamera => {
+    const camera = new PerspectiveCamera(60, 1.6, 0.1, 1000);
+    camera.position.set(x, y, z);
+    return camera;
+  };
+
+  it('is exactly zero before, at the start of, and after a flight', () => {
+    const tour = new CameraTour();
+    const camera = cameraAt(0, 4, 22);
+    expect(tour.beta.length()).toBe(0);
+
+    tour.start('circle', camera, 1);
+    expect(tour.beta.length()).toBe(0);
+    tour.update(0, camera);
+    expect(tour.beta.length()).toBe(0);
+
+    tour.update(3, camera);
+    expect(tour.beta.length()).toBeGreaterThan(0);
+    tour.cancel();
+    expect(tour.beta.length()).toBe(0);
+  });
+
+  it('points a settled circle flight along its orbit, at the orbital speed', () => {
+    const tour = new CameraTour();
+    const camera = cameraAt(0, 4, 22);
+    tour.start('circle', camera, 1);
+    for (let t = 0; t < 6; t += 1 / 60) tour.update(1 / 60, camera);
+
+    const radial = tour.beta.clone().normalize().dot(camera.position.clone().normalize());
+    expect(Math.abs(radial)).toBeLessThan(1e-9);
+    expect(tour.beta.length()).toBeCloseTo(circularOrbitBeta(camera.position.length(), 1), 9);
+  });
+
+  it('ramps a flyby in from rest and holds it below light speed', () => {
+    const tour = new CameraTour();
+    const camera = cameraAt(0, 4, 22);
+    tour.start('flyby', camera, 1);
+    tour.update(0, camera);
+    expect(tour.beta.length()).toBe(0);
+    for (let t = 0; t < 11; t += 1 / 60) {
+      tour.update(1 / 60, camera);
+      expect(tour.beta.length()).toBeLessThan(1);
+    }
+    expect(tour.beta.length()).toBeGreaterThan(0.2);
+  });
+
+  it('ramps a plunge in from rest along the spiral it is flying', () => {
+    const tour = new CameraTour();
+    const camera = cameraAt(0, 4, 22);
+    tour.start('flyin', camera, 1);
+    tour.update(0, camera);
+    expect(tour.beta.length()).toBe(0);
+
+    let previousRadius = camera.position.length();
+    for (let t = 0; t < 5; t += 1 / 60) {
+      tour.update(1 / 60, camera);
+      const radius = camera.position.length();
+      // Diving, so the velocity has to have an inward component.
+      expect(tour.beta.dot(camera.position)).toBeLessThan(0);
+      expect(radius).toBeLessThan(previousRadius);
+      previousRadius = radius;
+    }
+    expect(tour.beta.length()).toBeGreaterThan(0.1);
+    expect(tour.beta.length()).toBeLessThan(1);
+  });
+});
diff --git a/src/render/blackHolePass.ts b/src/render/blackHolePass.ts
index 6a9730b..b5f80c8 100644
--- a/src/render/blackHolePass.ts
+++ b/src/render/blackHolePass.ts
@@ -4,7 +4,8 @@
  * renders here. Output alpha is the horizon mask.
  */
 import * as THREE from 'three';
-import { glslDefineMap } from '../physics/constants';
+import { M, glslDefineMap } from '../physics/constants';
+import { horizonRadius } from '../physics/kerr';
 import type { QualityPreset } from '../settings';
 import { FullscreenPass } from './fullscreenPass';
 import geodesicFrag from './shaders/geodesic.frag';
@@ -27,8 +28,22 @@ export interface DiscState {
   brightness: number;
 }
 
+/** The primary hole: its size and how fast it turns. */
+export interface PrimaryState {
+  /** Schwarzschild radius, world units (animated during merger/ringdown). */
+  rs: number;
+  /** Dimensionless Kerr spin a/M in [0, A_STAR_MAX]; 0 is Schwarzschild. */
+  spin: number;
+}
+
 const QUALITY_STEPS: Record<QualityPreset, number> = { low: 128, medium: 256, high: 420 };
 
+/**
+ * A non-zero spin and an active secondary are mutually exclusive: the Kerr
+ * branch in the shader solves one hole exactly and has no superposition. The
+ * simulation enforces it (`setPrimarySpin` forces 0 while a binary exists),
+ * so this pass only has to stay consistent with what it is handed.
+ */
 export class BlackHolePass {
   private readonly pass: FullscreenPass;
   private readonly uniforms: Record<string, THREE.IUniform>;
@@ -37,6 +52,7 @@ export class BlackHolePass {
     this.uniforms = {
       uCamPos: { value: new THREE.Vector3() },
       uCamBasis: { value: new THREE.Matrix3() },
+      uCamBeta: { value: new THREE.Vector3() },
       uTanHalfFov: { value: 1 },
       uAspect: { value: 1 },
       uResolution: { value: new THREE.Vector2(1, 1) },
@@ -44,6 +60,8 @@ export class BlackHolePass {
       uTime: { value: 0 },
       uSky: { value: skyTexture },
       uRs: { value: 1 },
+      uKerrA: { value: 0 },
+      uHorizonR: { value: 1 },
       uBh2Active: { value: 0 },
       uBh2Pos: { value: new THREE.Vector3() },
       uBh2Rs: { value: 0.3 },
@@ -52,6 +70,7 @@ export class BlackHolePass {
       uDiscBrightness: { value: 1 },
       uJetStrength: { value: 0 },
       uWindStrength: { value: 0 },
+      uImageOrderTint: { value: 0 },
       uPlanetActive: { value: 0 },
       uPlanetPos: { value: new THREE.Vector3() },
       uPlanetRadii: { value: new THREE.Vector3(1, 1, 1) },
@@ -78,9 +97,24 @@ export class BlackHolePass {
     this.applyDefines(quality);
   }
 
-  /** Primary Schwarzschild radius (animated during merger/ringdown). */
-  setPrimaryRs(rs: number): void {
-    this.uniforms.uRs!.value = rs;
+  /**
+   * Size and spin of the primary, in one call because the three uniforms they
+   * drive are derived from each other and must never disagree: a horizon that
+   * does not match the spin puts the capture test in the wrong place.
+   */
+  setPrimary(primary: PrimaryState): void {
+    this.uniforms.uRs!.value = primary.rs;
+    this.uniforms.uKerrA!.value = primary.spin * M * primary.rs;
+    this.uniforms.uHorizonR!.value = horizonRadius(primary.spin) * primary.rs;
+  }
+
+  /**
+   * Camera velocity in units of c, world frame. Not folded into
+   * updateCamera(), which is driven from the camera matrix inside
+   * pipeline.render() and knows nothing about the tour.
+   */
+  setCameraBeta(beta: THREE.Vector3): void {
+    (this.uniforms.uCamBeta!.value as THREE.Vector3).copy(beta);
   }
 
   setSecondary(bh2: { pos: THREE.Vector3; rs: number } | null): void {
@@ -109,6 +143,15 @@ export class BlackHolePass {
     this.uniforms.uWindStrength!.value = strength;
   }
 
+  /**
+   * Image-order diagnostic overlay. 0 removes the winding accumulation from
+   * the march entirely, mirroring setJetStrength/setWindStrength, and it is a
+   * uniform rather than a define so toggling never recompiles the program.
+   */
+  setImageOrderTint(strength: number): void {
+    this.uniforms.uImageOrderTint!.value = strength;
+  }
+
   setPlanet(planet: PlanetState | null): void {
     if (!planet) {
       this.uniforms.uPlanetActive!.value = 0;
diff --git a/src/render/cameraTour.ts b/src/render/cameraTour.ts
index f5cd863..26b4991 100644
--- a/src/render/cameraTour.ts
+++ b/src/render/cameraTour.ts
@@ -12,8 +12,22 @@
  * moves keep their framing when the hole grows. The tour only writes
  * camera.position and aims it at the origin; the caller disables orbit
  * controls while update() returns true and re-enables them when it stops.
+ *
+ * The tour also publishes `beta`, the camera velocity the relativistic optics
+ * in the raymarcher are computed from, and that number is NOT the derivative
+ * of the camera path. It cannot be: the flights are played back on a
+ * compressed clock, moving roughly 3 r_s per wall-clock second, which is
+ * several times light speed in units where c = 1, and the fly-in's recovery
+ * teleport would spike it to infinity. What is published instead is the
+ * physical speed of the trajectory each move stands for: a circular orbit for
+ * 'circle', free fall from rest at infinity for 'flyby' and 'flyin', directed
+ * along that move's own analytic tangent. Both speeds are derived and
+ * documented (docs/THEORY.md parts 3 and 9), which an art-directed "tour
+ * clock" divisor would not be.
  */
 import * as THREE from 'three';
+import { circularOrbitBeta, freeFallBeta } from '../physics/relativity';
+import { easedRunProgress, runSpeedFraction } from './tourKinematics';
 
 export type TourKind = 'flyin' | 'flyby' | 'circle';
 
@@ -40,6 +54,8 @@ const FLYBY = {
 const FLYIN = {
   duration: 14,
   turns: 1.5,
+  /** Seconds over which the optics boost eases in from a standing start. */
+  boostRampTime: 1.0,
   endRadius: 1.12,
   fadeStartRadius: 2.4,
   fadeEndRadius: 1.25,
@@ -55,22 +71,6 @@ function smooth01(x: number): number {
   return t * t * (3 - 2 * t);
 }
 
-/**
- * Normalized distance travelled along the flyby at normalized time u: speed
- * smoothstep-ramps up over the first `ramp` fraction, holds, and ramps down
- * symmetrically. This is the analytic integral of that speed profile
- * (∫ smoothstep = x^3 - x^4/2 over a ramp), rescaled so progress(1) = 1.
- */
-function easedRunProgress(u: number, ramp: number): number {
-  if (u <= 0) return 0;
-  if (u >= 1) return 1;
-  const rampArea = (x: number): number => ramp * x * x * x * (1 - x / 2);
-  const total = 1 - ramp;
-  if (u < ramp) return rampArea(u / ramp) / total;
-  if (u <= 1 - ramp) return (ramp / 2 + (u - ramp)) / total;
-  return (total - rampArea((1 - u) / ramp)) / total;
-}
-
 export class CameraTour {
   private kind: TourKind | null = null;
   private rs = 1;
@@ -89,6 +89,16 @@ export class CameraTour {
   private recoverStartedAt = 0;
 
   private readonly scratchTarget = new THREE.Vector3();
+  private readonly scratchTangent = new THREE.Vector3();
+  private readonly scratchBasis = new THREE.Vector3();
+
+  /**
+   * Camera velocity in units of c, world frame, for the relativistic optics.
+   * Exactly the zero vector unless a flight is running, and every move ramps
+   * it in from exactly zero, so "at rest" is a fact of construction rather
+   * than a threshold.
+   */
+  readonly beta = new THREE.Vector3();
 
   get activeKind(): TourKind | null {
     return this.kind;
@@ -106,6 +116,7 @@ export class CameraTour {
     this.fadeValue = 1;
     this.recovering = false;
     this.recoverStartedAt = 0;
+    this.beta.set(0, 0, 0);
     this.startPos.copy(camera.position);
     this.startAzimuth = Math.atan2(camera.position.z, camera.position.x);
     // Spiral start in spherical terms, radius clamped so a start already at
@@ -118,6 +129,9 @@ export class CameraTour {
   cancel(): void {
     this.kind = null;
     this.fadeValue = 1;
+    // The camera stops dead at this instant, so the star field snapping back
+    // is consistent with what the camera is doing. It is a choice.
+    this.beta.set(0, 0, 0);
   }
 
   /** Drive the camera; returns true while the tour owns the camera. */
@@ -153,6 +167,11 @@ export class CameraTour {
     );
     const settle = smooth01(this.elapsed / CIRCLE.settleTime);
     camera.position.lerpVectors(this.startPos, this.scratchTarget, settle);
+    // Tangent of the target path, at the circular-orbit speed for wherever the
+    // camera has actually settled to. The settle blend doubles as the ramp in.
+    this.beta
+      .set(-Math.sin(azimuth), 0, Math.cos(azimuth))
+      .multiplyScalar(circularOrbitBeta(camera.position.length(), this.rs) * settle);
     return true;
   }
 
@@ -164,7 +183,8 @@ export class CameraTour {
     // length is chosen so both endpoints sit exactly `range` r_s from the hole.
     const halfLength =
       Math.sqrt(FLYBY.range ** 2 - FLYBY.offset ** 2 - FLYBY.height ** 2) * this.rs;
-    const progress = easedRunProgress(this.elapsed / FLYBY.duration, FLYBY.ramp);
+    const u = this.elapsed / FLYBY.duration;
+    const progress = easedRunProgress(u, FLYBY.ramp);
     this.scratchTarget.set(
       FLYBY.offset * this.rs,
       FLYBY.height * this.rs,
@@ -173,6 +193,13 @@ export class CameraTour {
     // Ease from wherever the camera was onto the start of the line.
     const blend = smooth01(this.elapsed / FLYBY.blendTime);
     camera.position.lerpVectors(this.startPos, this.scratchTarget, blend);
+    // The line runs along +z; the run's own speed profile is the ramp, so the
+    // boost is strongest exactly where the pass is fastest and zero at rest.
+    this.beta
+      .set(0, 0, 1)
+      .multiplyScalar(
+        freeFallBeta(camera.position.length(), this.rs) * runSpeedFraction(u, FLYBY.ramp),
+      );
     return true;
   }
 
@@ -196,6 +223,33 @@ export class CameraTour {
       radius * cosElevation * Math.sin(azimuth),
     );
 
+    // Tangent of the spiral, from the analytic derivatives of the three
+    // spherical coordinates above with respect to t, then given the free-fall
+    // speed at the current radius.
+    const dRadius = radius * Math.log(FLYIN.endRadius * this.rs / this.plungeRadius0);
+    const dAzimuth = FLYIN.turns * 2 * Math.PI;
+    const dElevation = -this.plungeElevation0 * 6 * t * (1 - t);
+    const sinElevation = Math.sin(elevation);
+    const cosAzimuth = Math.cos(azimuth);
+    const sinAzimuth = Math.sin(azimuth);
+    this.scratchTangent
+      .set(cosElevation * cosAzimuth, sinElevation, cosElevation * sinAzimuth)
+      .multiplyScalar(dRadius)
+      .addScaledVector(
+        this.scratchBasis.set(-sinAzimuth, 0, cosAzimuth),
+        radius * cosElevation * dAzimuth,
+      )
+      .addScaledVector(
+        this.scratchBasis.set(-sinElevation * cosAzimuth, cosElevation, -sinElevation * sinAzimuth),
+        radius * dElevation,
+      )
+      .normalize();
+    this.beta
+      .copy(this.scratchTangent)
+      .multiplyScalar(
+        freeFallBeta(radius, this.rs) * smooth01(this.elapsed / FLYIN.boostRampTime),
+      );
+
     // Fade to black across the photon-sphere approach (on radius, not time).
     this.fadeValue = smooth01(
       (radius - FLYIN.fadeEndRadius * this.rs) /
@@ -207,12 +261,15 @@ export class CameraTour {
     this.recovering = true;
     this.recoverStartedAt = this.elapsed;
     camera.position.set(0, FLYIN.recoverHeight * this.rs, FLYIN.recoverDistance * this.rs);
+    this.beta.set(0, 0, 0);
     return true;
   }
 
   /** Hold the overlook while brightness comes back; ends when fully faded in. */
   private updateRecover(camera: THREE.PerspectiveCamera): boolean {
     camera.position.set(0, FLYIN.recoverHeight * this.rs, FLYIN.recoverDistance * this.rs);
+    // Parked at the overlook: nothing is moving, so nothing is boosted.
+    this.beta.set(0, 0, 0);
     const t = (this.elapsed - this.recoverStartedAt) / FLYIN.recoverTime;
     this.fadeValue = smooth01(t);
     return t < 1;
diff --git a/src/render/photonPaths.ts b/src/render/photonPaths.ts
index 4b10ea0..23b8355 100644
--- a/src/render/photonPaths.ts
+++ b/src/render/photonPaths.ts
@@ -5,12 +5,12 @@
  * occluded by the horizon via the shared mask.
  */
 import * as THREE from 'three';
-import { B_CRIT } from '../physics/constants';
 import {
   integrateNullGeodesic,
   type GeodesicResult,
   type GravityCenter,
 } from '../physics/geodesic';
+import { criticalImpactParameter } from '../physics/kerr';
 import { maskUniforms } from './horizonMask';
 import pathVert from './shaders/path.vert';
 import pathFrag from './shaders/path.frag';
@@ -21,14 +21,32 @@ const MAX_CURVE_POINTS = 260;
 
 type PathKind = 'escaped' | 'captured' | 'critical';
 
+/**
+ * Everything about the spacetime the drawn rays have to agree with the shader
+ * on, in one value: widening the provider rather than adding a second one
+ * keeps that mirroring to a single source of truth.
+ */
+export interface LensingState {
+  centers: readonly GravityCenter[];
+  /** Dimensionless Kerr spin a/M; 0 with a secondary present. */
+  spin: number;
+}
+
 const KIND_COLORS: Record<PathKind, THREE.Color> = {
   escaped: new THREE.Color(0.55, 2.0, 2.6),
   captured: new THREE.Color(2.6, 0.9, 0.3),
   critical: new THREE.Color(2.4, 2.4, 2.4),
 };
 
-function kindOf(result: GeodesicResult): PathKind {
-  if (Math.abs(result.b - B_CRIT) < 0.05) return 'critical';
+/**
+ * Which side of the hole a ray goes round decides which critical impact
+ * parameter it has to be compared against: spin drags the prograde edge of the
+ * shadow in and pushes the retrograde edge out, so a single b_crit would
+ * mislabel half the fan.
+ */
+function kindOf(result: GeodesicResult, spin: number): PathKind {
+  const sense = result.axialAngularMomentum >= 0 ? 'prograde' : 'retrograde';
+  if (Math.abs(result.b - Math.abs(criticalImpactParameter(spin, sense))) < 0.05) return 'critical';
   return result.fate === 'captured' ? 'captured' : 'escaped';
 }
 
@@ -49,7 +67,7 @@ export class PhotonPathManager {
   private readonly meshes: THREE.Mesh[] = [];
   private readonly materials: Record<PathKind, THREE.ShaderMaterial>;
 
-  constructor(private readonly centersProvider: () => readonly GravityCenter[]) {
+  constructor(private readonly lensingProvider: () => LensingState) {
     const makeMaterial = (kind: PathKind): THREE.ShaderMaterial =>
       new THREE.ShaderMaterial({
         vertexShader: pathVert,
@@ -69,17 +87,18 @@ export class PhotonPathManager {
 
   /** Integrate and draw one photon; returns the trajectory result. */
   launch(origin: THREE.Vector3, dir: THREE.Vector3): GeodesicResult {
+    const { centers, spin } = this.lensingProvider();
     const result = integrateNullGeodesic(
       { x: origin.x, y: origin.y, z: origin.z },
       { x: dir.x, y: dir.y, z: dir.z },
-      { maxSteps: 6000, recordEvery: 2, centers: this.centersProvider() },
+      { maxSteps: 6000, recordEvery: 2, centers, spin },
     );
     const curvePoints = toCurvePoints(result.points);
     if (curvePoints.length >= 2) {
       const curve = new THREE.CatmullRomCurve3(curvePoints);
       const segments = Math.min(curvePoints.length * 2, 400);
       const geometry = new THREE.TubeGeometry(curve, segments, TUBE_RADIUS, 6, false);
-      const mesh = new THREE.Mesh(geometry, this.materials[kindOf(result)]);
+      const mesh = new THREE.Mesh(geometry, this.materials[kindOf(result, spin)]);
       mesh.frustumCulled = false;
       this.group.add(mesh);
       this.meshes.push(mesh);
diff --git a/src/render/shaders/geodesic.frag b/src/render/shaders/geodesic.frag
index 50da593..f5e58ff 100644
--- a/src/render/shaders/geodesic.frag
+++ b/src/render/shaders/geodesic.frag
@@ -1,18 +1,37 @@
-// Schwarzschild geodesic raymarcher: per pixel, integrates the photon
-// equation of motion  x'' = -1.5 * h^2 * x / r^5  (r_s = 1 units) with RK4
-// and an adaptive step, accumulating the accretion disc at equatorial-plane
-// crossings and testing the (tidally stretched) planet ellipsoid per step.
-// Escaped rays sample the star cubemap along the bent direction; captured
-// rays are the shadow. Alpha output is the horizon mask (0 = captured),
-// consumed by the overlay scene pass for occlusion.
+// Geodesic raymarcher: per pixel, integrates a null geodesic with RK4 and an
+// adaptive step, accumulating the accretion disc at equatorial-plane crossings
+// and testing the (tidally stretched) planet ellipsoid per step. Escaped rays
+// sample the star cubemap along the bent direction; captured rays are the
+// shadow. Alpha output is the horizon mask (0 = captured), consumed by the
+// overlay scene pass for occlusion.
+//
+// Two spacetimes live here, selected by one uniform-valued branch:
+//
+// - uKerrA == 0.0: the Schwarzschild superposition this app shipped with,
+//   x'' = -1.5 rs h^2 x / r^5, which is exact for one hole and the standard
+//   approximation for two. Every expression below it is the literal original,
+//   so a still hole renders exactly the frame it always did.
+// - uKerrA > 0.0: the exact Kerr metric in Cartesian Kerr-Schild form,
+//   integrated as a Hamiltonian system on (x, p) with p_t = -1. Single hole
+//   only; blackHolePass guarantees a spinning hole never has a secondary.
+//
+// The two are not unified on purpose. They are analytically identical at
+// a = 0 and not identical in floating point, and the a = 0 image is a
+// promise, not an approximation.
+//
+// The camera's own motion during a scripted flight enters once, before the
+// march, as a Lorentz transformation of the pixel's look direction, plus the
+// Doppler factor of that same ray applied to the whole received radiance.
 //
 // Compile-time defines injected from TS: MAX_STEPS, USE_RK4, BEAM_EXP,
 // R_CAPTURE, R_ESCAPE, STEP_K, DT_MIN, DT_MAX.
 
 #include ./noise.glsl;
+#include ./kerr.glsl;
 
 uniform vec3 uCamPos;
 uniform mat3 uCamBasis;
+uniform vec3 uCamBeta;  // camera velocity in units of c, world frame; zero unless a flight is running
 uniform float uTanHalfFov;
 uniform float uAspect;
 uniform vec2 uResolution;
@@ -20,6 +39,8 @@ uniform vec2 uJitter;
 uniform float uTime;
 uniform samplerCube uSky;
 uniform float uRs;      // primary Schwarzschild radius (grows after a merger)
+uniform float uKerrA;   // spin in length units, a = (a/M) * M * rs; 0 selects Schwarzschild
+uniform float uHorizonR; // outer horizon r+ in world units; equals uRs when uKerrA is 0
 uniform int uBh2Active; // secondary inspiraling black hole
 uniform vec3 uBh2Pos;
 uniform float uBh2Rs;
@@ -28,6 +49,7 @@ uniform float uDiscOuter;
 uniform float uDiscBrightness; // 0 disables the disc entirely
 uniform float uJetStrength;  // 0 disables the polar jet
 uniform float uWindStrength; // super-Eddington outflow; rises as the disc is fed
+uniform float uImageOrderTint; // 0 removes the winding accumulation from the march
 uniform int uPlanetActive;
 uniform vec3 uPlanetPos;
 uniform vec3 uPlanetRadii;
@@ -50,7 +72,21 @@ vec3 accelG(vec3 x, vec3 v) {
   return a;
 }
 
+// Angle swept about the primary between two march positions. Small-angle form
+// (see physics/imageOrder.ts for the error budget): the step clamp keeps the
+// per-step angle near 0.11 rad, where sin(t) understates t by 2.3e-4. Raising
+// STEP_K or DT_MAX invalidates that bound.
+float sweptAngle(vec3 from, vec3 to) {
+  float lengths = length(from) * length(to);
+  if (lengths <= 0.0) return 0.0;
+  return length(cross(from, to)) / lengths;
+}
+
 bool isCaptured(vec3 x) {
+  if (uKerrA > 0.0) {
+    float capK = R_CAPTURE * uHorizonR;
+    return kerrSchildRadius(spinFrame(x), uKerrA) < capK;
+  }
   float cap = R_CAPTURE * uRs;
   if (dot(x, x) < cap * cap) return true;
   if (uBh2Active == 1) {
@@ -62,36 +98,107 @@ bool isCaptured(vec3 x) {
 }
 
 float stepSizeAt(vec3 x) {
+  if (uKerrA > 0.0) {
+    // Margin measured from the horizon, which has shrunk with the spin.
+    return clamp(STEP_K * (kerrSchildRadius(spinFrame(x), uKerrA) - 0.9 * uHorizonR), DT_MIN, DT_MAX);
+  }
   float margin = length(x) - 0.9 * uRs;
   if (uBh2Active == 1) margin = min(margin, length(x - uBh2Pos) - 0.9 * uBh2Rs);
   return clamp(STEP_K * margin, DT_MIN, DT_MAX);
 }
 
-void integrateStep(inout vec3 x, inout vec3 v, float dt) {
+// The state marched is a velocity in the Schwarzschild branch and a momentum
+// in the Kerr branch; `photonDirection` is what turns either into the unit
+// direction the shading and the sky lookup want.
+vec3 photonDirection(vec3 x, vec3 p) {
+  if (uKerrA > 0.0) return kerrMarchDirection(x, p, uKerrA, 0.5 * uRs);
+  return p;
+}
+
+void integrateStep(inout vec3 x, inout vec3 p, float dt) {
+  if (uKerrA > 0.0) {
+    vec3 dx1, dp1, dx2, dp2, dx3, dp3, dx4, dp4;
+    float mass = 0.5 * uRs;
+    kerrDerivatives(x, p, uKerrA, mass, dx1, dp1);
+    kerrDerivatives(x + 0.5 * dt * dx1, p + 0.5 * dt * dp1, uKerrA, mass, dx2, dp2);
+    kerrDerivatives(x + 0.5 * dt * dx2, p + 0.5 * dt * dp2, uKerrA, mass, dx3, dp3);
+    kerrDerivatives(x + dt * dx3, p + dt * dp3, uKerrA, mass, dx4, dp4);
+    x += dt / 6.0 * (dx1 + 2.0 * dx2 + 2.0 * dx3 + dx4);
+    p += dt / 6.0 * (dp1 + 2.0 * dp2 + 2.0 * dp3 + dp4);
+    return;
+  }
 #if USE_RK4
-  vec3 a1 = accelG(x, v);
-  vec3 xB = x + 0.5 * dt * v;
-  vec3 vB = v + 0.5 * dt * a1;
+  vec3 a1 = accelG(x, p);
+  vec3 xB = x + 0.5 * dt * p;
+  vec3 vB = p + 0.5 * dt * a1;
   vec3 a2 = accelG(xB, vB);
   vec3 xC = x + 0.5 * dt * vB;
-  vec3 vC = v + 0.5 * dt * a2;
+  vec3 vC = p + 0.5 * dt * a2;
   vec3 a3 = accelG(xC, vC);
   vec3 xD = x + dt * vC;
-  vec3 vD = v + dt * a3;
+  vec3 vD = p + dt * a3;
   vec3 a4 = accelG(xD, vD);
-  x += dt / 6.0 * (v + 2.0 * vB + 2.0 * vC + vD);
-  v += dt / 6.0 * (a1 + 2.0 * a2 + 2.0 * a3 + a4);
+  x += dt / 6.0 * (p + 2.0 * vB + 2.0 * vC + vD);
+  p += dt / 6.0 * (a1 + 2.0 * a2 + 2.0 * a3 + a4);
 #else
   // Midpoint (RK2) for the low-quality preset.
-  vec3 a1 = accelG(x, v);
-  vec3 xm = x + 0.5 * dt * v;
-  vec3 vm = v + 0.5 * dt * a1;
+  vec3 a1 = accelG(x, p);
+  vec3 xm = x + 0.5 * dt * p;
+  vec3 vm = p + 0.5 * dt * a1;
   vec3 am = accelG(xm, vm);
   x += dt * vm;
-  v += dt * am;
+  p += dt * am;
 #endif
 }
 
+struct ObserverRay {
+  vec3 dir;       // look direction in the static frame, ready to march
+  float doppler;  // received / emitted frequency for this pixel
+};
+
+// Transform the pixel's look direction out of the camera's rest frame into the
+// static frame the march and the sky cubemap live in. Applied once per pixel,
+// before the march, and never inside it: the shadow, the ring, the disc and
+// the sky then aberrate together, which is the whole point. Aberrating only
+// the escaped direction would slide the star field while the shadow stayed
+// put and tear the image apart.
+//
+// The disc's and the jet's own g and delta are the emitter side of a different
+// transformation and are deliberately left alone.
+ObserverRay aberratedRay(vec3 look) {
+  ObserverRay ray;
+  // Exact identity at rest, by construction rather than by rounding: a
+  // normalize of an already-unit vector can move it by an ulp, and orbiting
+  // with the mouse has to render the frame it always did.
+  if (dot(uCamBeta, uCamBeta) == 0.0) {
+    ray.dir = look;
+    ray.doppler = 1.0;
+    return ray;
+  }
+  float gamma = inversesqrt(max(1.0 - dot(uCamBeta, uCamBeta), 1e-6));
+  float lookDotBeta = dot(look, uCamBeta);
+  float invDenom = 1.0 / (1.0 - lookDotBeta);
+  vec3 parallel = (gamma / (gamma + 1.0)) * lookDotBeta * uCamBeta;
+  ray.dir = normalize((look / gamma - uCamBeta + parallel) * invDenom);
+  ray.doppler = invDenom / gamma;
+  return ray;
+}
+
+// Beaming and colour for a received photon. Bolometrically the brightness of a
+// boosted source goes as D^4; BEAM_EXP is the 3.0 the disc and jet already
+// use, kept for continuity. The per-channel offset is art direction: there are
+// no spectra here, only RGB, so the hue is pushed the way a Planck spectrum
+// would move, and it is exactly neutral (1, 1, 1) at doppler = 1.
+const float SKY_HUE_SHIFT = 0.55;
+
+vec3 boostGainOf(float doppler) {
+  if (doppler == 1.0) return vec3(1.0); // at rest, exactly and for free
+  // Clamped so a fly-past does not turn into a white smear on the way in or a
+  // black hole in the sky on the way out. Art direction, not physics.
+  float shift = clamp(doppler, 0.35, 2.2);
+  return pow(vec3(shift), BEAM_EXP + vec3(-SKY_HUE_SHIFT, 0.0, SKY_HUE_SHIFT));
+}
+
 // Crude Planckian ramp: temperature scalar ~0 deep red -> ~1 white -> hotter blue.
 vec3 blackbody(float t) {
   vec3 c = mix(vec3(0.55, 0.04, 0.0), vec3(1.0, 0.45, 0.12), smoothstep(0.0, 0.45, t));
@@ -100,20 +207,32 @@ vec3 blackbody(float t) {
   return c;
 }
 
+// Orbital kinematics of the gas at radius r. The Kerr branch is the general
+// case and the a = 0 branch is its own algebraic limit, written out literally
+// so a still hole shades exactly as it always did, to the last bit.
+DiscKinematics discKinematics(float r) {
+  if (uKerrA > 0.0) return kerrCircularOrbit(r, uKerrA, 0.5 * uRs);
+  DiscKinematics orbit;
+  orbit.omega = sqrt(0.5 * uRs / (r * r * r));
+  orbit.beta = sqrt(0.5 * uRs / max(r - uRs, 0.3));
+  orbit.redshift = sqrt(max(1.0 - 1.5 * uRs / r, 0.0));
+  return orbit;
+}
+
 // Disc emission at an equatorial crossing. `marchDir` is our marching
 // direction (camera -> scene); the photon physically travels the other way.
 // Returns premultiplied rgb and coverage alpha.
 vec4 discEmission(vec3 hit, vec3 marchDir) {
   float r = length(hit.xz);
+  DiscKinematics orbit = discKinematics(r);
 
   // Shakura–Sunyaev temperature profile, normalized to peak at 1.
   float q = max(1.0 - sqrt(uDiscInner / r), 0.0);
   float tProf = pow(uDiscInner / r, 0.75) * pow(q, 0.25) * 2.05;
 
-  // Differential rotation: advect the noise field by the local Keplerian
-  // angular speed so streaks shear into trailing spirals on their own.
-  float omega = sqrt(0.5 * uRs / (r * r * r));
-  float ang = omega * uTime;
+  // Differential rotation: advect the noise field by the local angular speed
+  // so streaks shear into trailing spirals on their own.
+  float ang = orbit.omega * uTime;
   float ca = cos(ang);
   float sa = sin(ang);
   vec2 mq = vec2(hit.x * ca + hit.z * sa, -hit.x * sa + hit.z * ca);
@@ -129,16 +248,36 @@ vec4 discEmission(vec3 hit, vec3 marchDir) {
   // Doppler + gravitational shift for a circular geodesic emitter, using the
   // bent photon direction so the lensed secondary image beams correctly too.
   vec3 phiHat = normalize(vec3(-hit.z, 0.0, hit.x));
-  float beta = clamp(sqrt(0.5 * uRs / max(r - uRs, 0.3)), 0.0, 0.9);
+  float beta = clamp(orbit.beta, 0.0, 0.9);
   float gamma = inversesqrt(1.0 - beta * beta);
   float cosA = dot(-marchDir, phiHat);
-  float g = sqrt(max(1.0 - 1.5 * uRs / r, 0.0)) / (gamma * (1.0 - beta * cosA));
+  float g = orbit.redshift / (gamma * (1.0 - beta * cosA));
 
   vec3 col = blackbody(tProf * g) * tProf * pow(g, BEAM_EXP);
   col *= uDiscBrightness * 16.0 * (0.3 + 0.9 * density);
   return vec4(col * alpha, alpha);
 }
 
+// Diagnostic overlay: recolour the disc by how many half turns the light made
+// on its way here. The physics is only the floor(Phi / pi) partition; the
+// three colours are art direction, chosen to read apart at a glance.
+const vec3 ORDER_DIRECT_TINT = vec3(0.42, 0.66, 1.00);
+const vec3 ORDER_FIRST_TINT = vec3(1.00, 0.70, 0.26);
+const vec3 ORDER_RING_TINT = vec3(1.00, 0.36, 0.92);
+
+vec3 imageOrderTint(float windingAngle) {
+  float order = min(floor(windingAngle / 3.14159265), 2.0);
+  vec3 tint = mix(ORDER_DIRECT_TINT, ORDER_FIRST_TINT, step(0.5, order));
+  return mix(tint, ORDER_RING_TINT, step(1.5, order));
+}
+
+// Luminance preserving: only the hue moves, so switching the overlay on never
+// changes exposure, bloom or the alpha horizon mask.
+vec4 tintByImageOrder(vec4 emission, float windingAngle) {
+  float luma = dot(emission.rgb, vec3(0.2126, 0.7152, 0.0722));
+  return vec4(mix(emission.rgb, imageOrderTint(windingAngle) * luma, uImageOrderTint), emission.a);
+}
+
 // Optically thin polar jet: two narrow cones along the disc axis, filled with
 // braided filaments that twist with height and drift outward. Emission only,
 // so it never hides what is behind it, but it is integrated inside the
@@ -334,20 +473,36 @@ vec3 coronaEmission(vec3 p, float dt) {
 void main() {
   vec2 ndc = (gl_FragCoord.xy + uJitter) / uResolution * 2.0 - 1.0;
   vec3 x = uCamPos;
-  vec3 v = normalize(uCamBasis * vec3(ndc.x * uAspect * uTanHalfFov, ndc.y * uTanHalfFov, -1.0));
+  vec3 look = normalize(uCamBasis * vec3(ndc.x * uAspect * uTanHalfFov, ndc.y * uTanHalfFov, -1.0));
+
+  // Out of the camera's rest frame into the static frame, once per pixel.
+  ObserverRay ray = aberratedRay(look);
+  vec3 dir = ray.dir;
+  vec3 boostGain = boostGainOf(ray.doppler);
+
+  float phiWound = 0.0;
+  bool tintOrders = uImageOrderTint > 0.0;
 
   // Fast-forward a distant camera to the escape sphere; deflection out there
   // is negligible and the saved steps go to the photon ring instead.
   if (dot(x, x) > R_ESCAPE * R_ESCAPE) {
-    float tca = dot(-x, v);
+    float tca = dot(-x, dir);
     float d2 = dot(x, x) - tca * tca;
     if (tca < 0.0 || d2 > R_ESCAPE * R_ESCAPE * 0.98) {
-      gl_FragColor = vec4(textureCube(uSky, v).rgb, 1.0);
+      gl_FragColor = vec4(textureCube(uSky, dir).rgb * boostGain, 1.0);
       return;
     }
-    x += v * (tca - sqrt(R_ESCAPE * R_ESCAPE * 0.98 - d2));
+    vec3 xFar = x;
+    x += dir * (tca - sqrt(R_ESCAPE * R_ESCAPE * 0.98 - d2));
+    // The skipped chord still swept an angle about the hole, so the image
+    // order has to start from it rather than from zero.
+    if (tintOrders) phiWound = acos(clamp(dot(normalize(xFar), normalize(x)), -1.0, 1.0));
   }
 
+  // The Kerr branch marches a momentum, the Schwarzschild branch a velocity;
+  // at a = 0 the momentum is the direction itself, so this is the identity.
+  vec3 p = uKerrA > 0.0 ? kerrNullMomentum(x, dir, uKerrA, 0.5 * uRs) : dir;
+
   vec3 col = vec3(0.0);
   float T = 1.0;
   bool captured = false;
@@ -358,12 +513,16 @@ void main() {
       captured = true;
       break;
     }
-    if (dot(x, x) > R_ESCAPE * R_ESCAPE && dot(x, v) > 0.0) break;
+    if (dot(x, x) > R_ESCAPE * R_ESCAPE && dot(x, dir) > 0.0) break;
 
     float dt = stepSizeAt(x);
     vec3 xPrev = x;
-    vec3 vPrev = v;
-    integrateStep(x, v, dt);
+    vec3 dirPrev = dir;
+    integrateStep(x, p, dt);
+    dir = photonDirection(x, p);
+
+    float dPhi = 0.0;
+    if (tintOrders) dPhi = sweptAngle(xPrev, x);
 
     // Order the two possible hits inside this segment by their parameter.
     float sDisc = 2.0;
@@ -382,16 +541,20 @@ void main() {
     }
 
     // Volumetric, so these accumulate every step rather than at a crossing.
+    // Deliberately not tinted by image order: one ray crosses them at many
+    // orders, so a per-step tint would smear across the boundary.
     vec3 mid = mix(xPrev, x, 0.5);
-    col += T * jetEmission(mid, normalize(mix(vPrev, v, 0.5)), dt);
+    col += T * jetEmission(mid, normalize(mix(dirPrev, dir, 0.5)), dt);
     col += T * windEmission(mid, dt);
     col += T * coronaEmission(mid, dt);
 
     if (sDisc < sPlanet) {
-      vec4 e = discEmission(mix(xPrev, x, sDisc), normalize(mix(vPrev, v, sDisc)));
+      vec4 e = discEmission(mix(xPrev, x, sDisc), normalize(mix(dirPrev, dir, sDisc)));
+      if (tintOrders) e = tintByImageOrder(e, phiWound + sDisc * dPhi);
       col += T * e.rgb;
       T *= 1.0 - e.a;
     }
+    phiWound += dPhi;
     if (sPlanet <= 1.0) {
       // Opaque: anything behind the planet in this segment is hidden.
       col += T * shadePlanet(pPos, pNrm, pLocal);
@@ -400,10 +563,18 @@ void main() {
       break;
     }
     if (T < 0.01) break;
+
+    // Kerr only: the prograde photon orbit is dragged in toward the horizon,
+    // so near-critical rays wind far more and a ray that runs out of steps
+    // while still inside the escape sphere is a captured ray we could not
+    // afford to follow. Treating it as escaped speckles the shadow edge. The
+    // same rule would improve the a = 0 image, but applying it there would
+    // change the shipped frame, so the asymmetry is deliberate.
+    if (uKerrA > 0.0 && i == MAX_STEPS - 1 && dot(x, x) < R_ESCAPE * R_ESCAPE) captured = true;
   }
 
   if (!captured && !opaqueHit && T > 0.001) {
-    col += T * textureCube(uSky, normalize(v)).rgb;
+    col += T * textureCube(uSky, normalize(dir)).rgb;
   }
-  gl_FragColor = vec4(col, captured ? 0.0 : 1.0);
+  gl_FragColor = vec4(col * boostGain, captured ? 0.0 : 1.0);
 }
diff --git a/src/render/shaders/kerr.glsl b/src/render/shaders/kerr.glsl
new file mode 100644
index 0000000..58ad244
--- /dev/null
+++ b/src/render/shaders/kerr.glsl
@@ -0,0 +1,123 @@
+// Kerr in Cartesian Kerr-Schild form: the field, its analytic derivatives,
+// the null launch, and the disc's orbital kinematics.
+//
+// This file is the GPU half of physics/geodesic.ts and physics/kerr.ts. The
+// variable names and the order of the lines are deliberately identical to the
+// TypeScript so a side-by-side diff is a readable review: there is no headless
+// GL in this project, so that diff is the whole verification strategy for the
+// shader. If one side is edited the other has to be edited with it, or the
+// drawn photon paths stop landing on the rendered photon ring and nothing
+// fails a test.
+//
+// Nothing here reads a uniform. Spin arrives as `a` (length units, a = spin*M)
+// and the mass as `mass`, so these functions are as testable by reading as
+// their CPU twins.
+
+// World -> the spin frame, a right-handed frame whose +Z is SPIN_AXIS,
+// derived in physics/constants.ts from the disc's own orbital sense.
+vec3 spinFrame(vec3 w) { return vec3(w.x, w.z, -w.y); }
+vec3 worldFrame(vec3 s) { return vec3(s.x, -s.z, s.y); }
+
+// Kerr-Schild radius: the positive root of
+// (X^2+Y^2)/(r^2+a^2) + Z^2/r^2 = 1, equal to |X| when a is 0.
+float kerrSchildRadius(vec3 X, float a) {
+  float term = dot(X, X) - a * a;
+  return sqrt(max(0.5 * (term + sqrt(term * term + 4.0 * a * a * X.z * X.z)), 0.0));
+}
+
+struct KerrField {
+  float radius;
+  float f;   // 2 M r^3 / (r^4 + a^2 Z^2)
+  vec3 k;    // principal null direction, unit by construction
+};
+
+KerrField kerrField(vec3 X, float a, float mass) {
+  // Floored because r divides here; only the exact center is affected, and
+  // that is far inside a horizon no ray is ever marched past.
+  float radius = max(kerrSchildRadius(X, a), 1e-12);
+  float r2 = radius * radius;
+  float w = r2 + a * a;
+  float sigma = r2 * r2 + a * a * X.z * X.z;
+  KerrField field;
+  field.radius = radius;
+  field.f = 2.0 * mass * r2 * radius / sigma;
+  field.k = vec3((radius * X.x + a * X.y) / w, (radius * X.y - a * X.x) / w, X.z / radius);
+  return field;
+}
+
+// Hamiltonian derivatives, in world coordinates: dx/dlambda and dp/dlambda for
+// H = 0.5 (p.p - 1 - f kappa^2), kappa = 1 + k.p. `x` is measured from the hole.
+void kerrDerivatives(vec3 x, vec3 p, float a, float mass, out vec3 dx, out vec3 dp) {
+  vec3 X = spinFrame(x);
+  vec3 P = spinFrame(p);
+
+  KerrField field = kerrField(X, a, mass);
+  float r = field.radius;
+  float r2 = r * r;
+  float w = r2 + a * a;
+  float sigma = r2 * r2 + a * a * X.z * X.z;
+  float kappa = 1.0 + dot(field.k, P);
+
+  // grad r, from differentiating the spheroid equation above.
+  float d = r * (X.x * X.x + X.y * X.y) / (w * w) + X.z * X.z / (r2 * r);
+  vec3 gradR = vec3(X.x / (w * d), X.y / (w * d), X.z / (r2 * d));
+
+  // grad f = cRadial * gradR + cAxial * zHat.
+  float cRadial = 2.0 * mass * r2 * (3.0 * a * a * X.z * X.z - r2 * r2) / (sigma * sigma);
+  float cAxial = -4.0 * mass * a * a * r2 * r * X.z / (sigma * sigma);
+
+  // p . d_i k = aRadial * gradR_i + bAxis_i.
+  float aRadial = (X.x * P.x + X.y * P.y - 2.0 * r * (field.k.x * P.x + field.k.y * P.y)) / w -
+                  X.z * P.z / r2;
+  vec3 bAxis = vec3((r * P.x - a * P.y) / w, (a * P.x + r * P.y) / w, P.z / r);
+
+  float halfKappa2 = 0.5 * kappa * kappa;
+  float fKappa = field.f * kappa;
+  float radialWeight = halfKappa2 * cRadial + fKappa * aRadial;
+
+  dx = worldFrame(P - fKappa * field.k);
+  dp = worldFrame(radialWeight * gradR + vec3(0.0, 0.0, halfKappa2 * cAxial) + fKappa * bAxis);
+}
+
+// The marching direction: dx/dlambda normalized. At a = 0 the caller keeps its
+// own unit velocity instead, so this is never asked for there.
+vec3 kerrMarchDirection(vec3 x, vec3 p, float a, float mass) {
+  KerrField field = kerrField(spinFrame(x), a, mass);
+  vec3 P = spinFrame(p);
+  float kappa = 1.0 + dot(field.k, P);
+  return normalize(worldFrame(P - field.f * kappa * field.k));
+}
+
+// The null momentum whose spatial covector points along `dir`, so H(x, p) = 0
+// exactly. s = (f beta + sqrt(1 + f (1 - beta^2))) / (1 - f beta^2), which is
+// 1 when f is 0, so a distant camera launches p = dir unchanged.
+vec3 kerrNullMomentum(vec3 x, vec3 dir, float a, float mass) {
+  KerrField field = kerrField(spinFrame(x), a, mass);
+  float beta = dot(field.k, spinFrame(dir));
+  float f = field.f;
+  float scale = (f * beta + sqrt(1.0 + f * (1.0 - beta * beta))) / (1.0 - f * beta * beta);
+  return scale * dir;
+}
+
+struct DiscKinematics {
+  float omega;    // coordinate angular speed, advects the noise field
+  float beta;     // orbital speed measured by the local non-rotating observer
+  float redshift; // 1/u^t
+};
+
+// Prograde equatorial circular geodesic at Boyer-Lindquist radius r. At a = 0
+// these reduce algebraically to sqrt(M/r^3), sqrt(M/(r-2M)) and sqrt(1-3M/r),
+// which is why the a = 0 branch in geodesic.frag can keep those literals and
+// still be the same physics.
+DiscKinematics kerrCircularOrbit(float r, float a, float mass) {
+  float sqrtM = sqrt(mass);
+  float sqrtR = sqrt(r);
+  float r32 = r * sqrtR;
+  float denom = r32 + a * sqrtM;
+  float delta = r * r - 2.0 * mass * r + a * a;
+  DiscKinematics orbit;
+  orbit.omega = sqrtM / denom;
+  orbit.beta = sqrtM * (r * r - 2.0 * a * sqrtM * sqrtR + a * a) / (sqrt(max(delta, 1e-9)) * denom);
+  orbit.redshift = pow(r, 0.75) * sqrt(max(r32 - 3.0 * mass * sqrtR + 2.0 * a * sqrtM, 0.0)) / denom;
+  return orbit;
+}
diff --git a/src/render/tourKinematics.ts b/src/render/tourKinematics.ts
new file mode 100644
index 0000000..138b3d0
--- /dev/null
+++ b/src/render/tourKinematics.ts
@@ -0,0 +1,34 @@
+/**
+ * The flyby's speed profile and its integral. Two views of one idea: the
+ * profile says how fast the camera is going, the integral says where it is.
+ * Both are used, one to place the camera and one to boost the optics.
+ *
+ * Deliberately free of THREE so the test does not have to import a renderer.
+ */
+
+/**
+ * Normalized speed along the flyby at normalized time u: smoothstep up over
+ * the first `ramp` fraction, flat through the middle, symmetric down at the
+ * end. 0 at both ends, 1 through the middle.
+ */
+export function runSpeedFraction(u: number, ramp: number): number {
+  if (u <= 0 || u >= 1) return 0;
+  const x = u < ramp ? u / ramp : u > 1 - ramp ? (1 - u) / ramp : 1;
+  return x * x * (3 - 2 * x);
+}
+
+/**
+ * Normalized distance travelled by normalized time u: the analytic integral of
+ * `runSpeedFraction` (integral of smoothstep = x^3 - x^4/2 over a ramp),
+ * rescaled so progress(1) = 1. Its derivative is
+ * runSpeedFraction(u, ramp) / (1 - ramp).
+ */
+export function easedRunProgress(u: number, ramp: number): number {
+  if (u <= 0) return 0;
+  if (u >= 1) return 1;
+  const rampArea = (x: number): number => ramp * x * x * x * (1 - x / 2);
+  const total = 1 - ramp;
+  if (u < ramp) return rampArea(u / ramp) / total;
+  if (u <= 1 - ramp) return (ramp / 2 + (u - ramp)) / total;
+  return (total - rampArea((1 - u) / ramp)) / total;
+}
diff --git a/src/settings.ts b/src/settings.ts
index c24472d..e91ef8f 100644
--- a/src/settings.ts
+++ b/src/settings.ts
@@ -23,6 +23,11 @@ export interface SkySettings {
 export interface Settings {
   paused: boolean;
   timeScale: number;
+  /**
+   * Dimensionless Kerr spin a/M in [0, A_STAR_MAX], prograde with the disc.
+   * 0 is Schwarzschild and is what the app ships with.
+   */
+  spin: number;
   discEnabled: boolean;
   discBrightness: number;
   jetEnabled: boolean;
@@ -36,6 +41,19 @@ export interface Settings {
   photonsEnabled: boolean;
   photonCount: number;
   photonSpreadDeg: number;
+  /**
+   * Recolour the disc by image order. A diagnostic overlay, not part of the
+   * default look, so it ships off.
+   */
+  imageOrderTintEnabled: boolean;
+  imageOrderTintStrength: number;
+  /**
+   * Relativistic optics of a moving camera. Only ever non-zero while a
+   * scripted flight is running; mouse orbiting repositions the camera rather
+   * than flying it, so it stays exactly off there.
+   */
+  cameraBoostEnabled: boolean;
+  cameraBoostStrength: number;
   bloomStrength: number;
   quality: QualityPreset;
   tdeMode: TdeMode;
@@ -52,6 +70,7 @@ export function defaultSettings(): Settings {
   return {
     paused: false,
     timeScale: 1.0,
+    spin: 0,
     discEnabled: true,
     discBrightness: 1.0,
     jetEnabled: false,
@@ -63,6 +82,10 @@ export function defaultSettings(): Settings {
     photonsEnabled: false,
     photonCount: 8,
     photonSpreadDeg: 10,
+    imageOrderTintEnabled: false,
+    imageOrderTintStrength: 0.85,
+    cameraBoostEnabled: true,
+    cameraBoostStrength: 1.0,
     bloomStrength: 1.2,
     quality: 'medium',
     tdeMode: 'cinematic',
diff --git a/src/sim/__tests__/debris.test.ts b/src/sim/__tests__/debris.test.ts
index cc1a2fe..6ed0ec7 100644
--- a/src/sim/__tests__/debris.test.ts
+++ b/src/sim/__tests__/debris.test.ts
@@ -1,12 +1,34 @@
 import { describe, expect, it } from 'vitest';
 import { Vector3 } from 'three';
 import { createPool, spawnFromBody, updatePool } from '../debris';
-import { vCircular } from '../gravity';
+import { vCircular, type GravityEnv } from '../gravity';
+import { horizonRadius, innermostStableCircularOrbit } from '../../physics/kerr';
 import type { Body } from '../types';
 import { mulberry32 } from './rng';
 
 const DT = 1 / 60;
 
+/** The boundaries a hole of unit r_s and this spin puts on the debris. */
+function envForSpin(spin: number): GravityEnv {
+  return {
+    rs: 1,
+    discInnerRadius: innermostStableCircularOrbit(spin, 'prograde'),
+    horizonRadius: horizonRadius(spin),
+    bh2: null,
+  };
+}
+
+/** One circularised managed particle at radius r, ready to be absorbed. */
+function circularisedParticle(r: number): ReturnType<typeof createPool> {
+  const pool = createPool(1);
+  pool.alive = 1;
+  pool.pos.set([r, 0, 0]);
+  pool.vel.set([0, 0, vCircular(Math.max(r, 1.5))]);
+  pool.life[0] = 1;
+  pool.flags[0] = 1;
+  return pool;
+}
+
 function sheddingBody(): Body {
   return {
     kind: 'planet',
@@ -146,6 +168,32 @@ describe('debris pool', () => {
     expect(absorbedTotal).toBe(1);
   });
 
+  it('takes the disc edge from the env, so spin moves where debris starts fading', () => {
+    // r = 2.0 is inside the still hole's inner edge at 3.0 and well outside
+    // the spinning hole's at 1.16, so the same particle starts being taken
+    // into the disc in one case and is left alone in the other.
+    const still = circularisedParticle(2.0);
+    updatePool(still, DT, 0, envForSpin(0));
+    expect(still.life[0]!).toBeLessThan(1);
+
+    const spinning = circularisedParticle(2.0);
+    updatePool(spinning, DT, 0, envForSpin(0.9));
+    expect(spinning.life[0]!).toBe(1);
+  });
+
+  it('takes the kill radius from the env, so a shrunken horizon stops eating early', () => {
+    // r = 0.8 is inside the still hole's kill radius of 1.05 and outside the
+    // near-extremal one of 0.56. Killing it at 1.05 around a hole whose disc
+    // reaches 0.62 would swallow debris before it could ever be absorbed.
+    const still = circularisedParticle(0.8);
+    updatePool(still, DT, 0, envForSpin(0));
+    expect(still.alive).toBe(0);
+
+    const spinning = circularisedParticle(0.8);
+    updatePool(spinning, DT, 0, envForSpin(0.998));
+    expect(spinning.alive).toBe(1);
+  });
+
   it('the secondary hole swallows nearby particles without disc credit', () => {
     const pool = createPool(1);
     pool.alive = 1;
@@ -154,7 +202,7 @@ describe('debris pool', () => {
     pool.life[0] = 1;
     pool.flags[0] = 1;
 
-    const env = { rs: 1, bh2: { pos: new Vector3(6.05, 0, 0), m: 0.15 } };
+    const env: GravityEnv = { ...envForSpin(0), bh2: { pos: new Vector3(6.05, 0, 0), m: 0.15 } };
     const { absorbed } = updatePool(pool, DT, 0, env);
     expect(pool.alive).toBe(0);
     expect(absorbed).toBe(0);
diff --git a/src/sim/debris.ts b/src/sim/debris.ts
index c2dc6d2..b896eec 100644
--- a/src/sim/debris.ts
+++ b/src/sim/debris.ts
@@ -26,7 +26,8 @@ export type Rng = () => number;
 /** Ballistic particles are culled once they are clearly gone. */
 const BALLISTIC_CULL_RADIUS = 60;
 
-const DEFAULT_ENV: GravityEnv = { rs: 1, bh2: null };
+/** A still hole of unit size: the a = 0 ISCO and the a = 0 horizon. */
+const DEFAULT_ENV: GravityEnv = { rs: 1, discInnerRadius: 3.0, horizonRadius: 1.0, bh2: null };
 
 /** Scratch for the spawn loop, which must not allocate per particle. */
 const launchVelocity = { x: 0, y: 0, z: 0 };
@@ -210,8 +211,13 @@ export interface PoolStepResult {
  * the first `alive` entries stay packed.
  *
  * Managed particles get PW gravity, inspiral drag, disc-plane settling, an
- * absorption fade at the inner edge (absorbRadius * rs), and a hard kill at
- * killRadius * rs. Ballistic particles get gravity only and die far out
+ * absorption fade at the disc's inner edge, and a hard kill just outside the
+ * horizon. Both radii come from the env rather than from art constants times
+ * rs, because both move with the hole's spin: at a/M = 0.9 the horizon is at
+ * 0.66 r_s, and a kill radius of 1.05 r_s would sit outside an inner edge
+ * that has come in to 1.16 r_s, so debris would vanish before it could ever
+ * be absorbed and the disc feed would silently stop being credited.
+ * Ballistic particles get gravity only and die far out
  * (r > 60), at max age, or inside the capture radius, never absorbed.
  * Any particle that strays inside 1.05x the secondary hole's Schwarzschild
  * radius is swallowed by it: killed with no disc credit.
@@ -227,8 +233,8 @@ export function updatePool(
   const rs = env.rs;
   const bh2 = env.bh2;
   const bh2CaptureR = bh2 ? 1.05 * 2 * bh2.m : 0;
-  const absorbRadius = DEBRIS_TUNING.absorbRadius * rs;
-  const killRadius = DEBRIS_TUNING.killRadius * rs;
+  const absorbRadius = env.discInnerRadius;
+  const killRadius = DEBRIS_TUNING.killRadius * env.horizonRadius;
   const dragFactor = 1 - drag * dt;
   let absorbed = 0;
 
diff --git a/src/sim/gravity.ts b/src/sim/gravity.ts
index f91be55..bfbbb2a 100644
--- a/src/sim/gravity.ts
+++ b/src/sim/gravity.ts
@@ -7,16 +7,26 @@
  * edge), so bodies and debris naturally destabilize and plunge where the
  * disc ends. rs defaults to 1 (the initial primary), and grows after a
  * binary merger.
+ *
+ * Honesty note: matter stays Paczynski-Wiita even when the hole spins. Only
+ * the boundaries move with the spin, through `discInnerRadius` and
+ * `horizonRadius` below, which are handed in rather than derived here.
+ * docs/THEORY.md says so in the cheat table.
  */
 import { Vector3 } from 'three';
 
 /**
- * Gravity sources seen by bodies and debris: the primary's Schwarzschild
- * radius and, while a binary inspiral is running, the secondary hole
- * (Newtonian point mass m at pos).
+ * Gravity sources and boundaries seen by bodies and debris: the primary's
+ * Schwarzschild radius, the two radii that move with its spin, and, while a
+ * binary inspiral is running, the secondary hole (Newtonian point mass m at
+ * pos).
  */
 export interface GravityEnv {
   rs: number;
+  /** Where debris is taken into the disc: the prograde ISCO, world units. */
+  discInnerRadius: number;
+  /** Outer horizon r+ of the primary, world units. */
+  horizonRadius: number;
   bh2: { pos: Vector3; m: number } | null;
 }
 
diff --git a/src/sim/types.ts b/src/sim/types.ts
index 999a0f4..ccad579 100644
--- a/src/sim/types.ts
+++ b/src/sim/types.ts
@@ -87,6 +87,13 @@ export interface World {
   binary: BinaryState | null;
   /** Primary Schwarzschild radius; 1 initially, grows after a merger. */
   primaryRs: number;
+  /**
+   * Dimensionless Kerr spin a/M of the primary, prograde with the disc. It is
+   * a property of the hole rather than a per-step argument, which is what
+   * keeps `stepWorld`'s parameter list from growing again. Forced to 0 while
+   * a second hole is in the scene: superposed centers have no Kerr form.
+   */
+  spin: number;
   debris: DebrisPool;
   /** 0..boostMax; disc brightness multiplier is (1 + discBoost). Decays. */
   discBoost: number;
diff --git a/src/sim/world.ts b/src/sim/world.ts
index 582e26c..73e4cfe 100644
--- a/src/sim/world.ts
+++ b/src/sim/world.ts
@@ -6,6 +6,8 @@
  */
 import { Vector3 } from 'three';
 import { BINARY_TUNING, BODY_TUNING, DEBRIS_TUNING, DISC_TUNING, TDE_TUNING } from '../config';
+import { A_STAR_MAX } from '../physics/constants';
+import { horizonRadius, innermostStableCircularOrbit } from '../physics/kerr';
 import type { TdeMode } from '../settings';
 import { createBinary, stepBinary, stepRingdown } from './binary';
 import { stepBody } from './body';
@@ -31,6 +33,7 @@ export function createWorld(maxParticles: number = DEBRIS_TUNING.maxParticles):
     body: null,
     binary: null,
     primaryRs: 1,
+    spin: 0,
     debris: createPool(maxParticles),
     discBoost: 0,
     spawnAcc: 0,
@@ -140,9 +143,33 @@ export function placeBinary(world: World, requested: Vector3): void {
   if (world.binary?.phase === 'ringdown') {
     world.primaryRs = world.binary.rsFinal;
   }
+  // Two holes are superposed rather than solved, and superposition has no Kerr
+  // form, so a second hole forces the primary to stop spinning.
+  world.spin = 0;
   world.binary = createBinary(world.primaryRs, requested);
 }
 
+/**
+ * Ask the primary to spin at `requested` (dimensionless a/M) and return the
+ * spin actually applied, so the caller can tell the user when it was
+ * overridden. Clamped to the Thorne limit here rather than trusted from the
+ * slider, because the near-extremal closed forms are only well conditioned
+ * below it, and forced to 0 while a second hole is in the scene.
+ */
+export function setPrimarySpin(world: World, requested: number): number {
+  const spin = world.binary === null ? Math.min(Math.max(requested, 0), A_STAR_MAX) : 0;
+  world.spin = spin;
+  return spin;
+}
+
+/** The radii that move with the spin, in world units. */
+function boundariesOf(world: World): { discInnerRadius: number; horizonRadius: number } {
+  return {
+    discInnerRadius: innermostStableCircularOrbit(world.spin, 'prograde') * world.primaryRs,
+    horizonRadius: horizonRadius(world.spin) * world.primaryRs,
+  };
+}
+
 /**
  * Ceiling on a single body/debris integration step. The body and the debris
  * are integrated numerically (semi-implicit Euler), so a compressed clock has
@@ -192,6 +219,7 @@ export function stepWorld(
 
   const env: GravityEnv = {
     rs: world.primaryRs,
+    ...boundariesOf(world),
     bh2:
       world.binary?.phase === 'inspiral'
         ? { pos: world.binary.pos, m: world.binary.rs2 / 2 }
diff --git a/src/ui/panel.ts b/src/ui/panel.ts
index f303a87..a5e20cb 100644
--- a/src/ui/panel.ts
+++ b/src/ui/panel.ts
@@ -11,10 +11,21 @@
  */
 import GUI, { type Controller } from 'lil-gui';
 import { BODY_TUNING, DEBRIS_TUNING, DISC_TUNING } from '../config';
+import { A_STAR_MAX } from '../physics/constants';
 import { defaultSettings, type QualityPreset, type Settings } from '../settings';
 import type { TourKind } from '../render/cameraTour';
 import { PRESETS, type Preset } from './presets';
 
+/**
+ * The numbers quoted here are asserted in physics/__tests__/kerr.test.ts, so
+ * the tooltip cannot drift away from what the app actually renders.
+ */
+const SPIN_TOOLTIP =
+  'How fast the hole turns, as a fraction of the fastest it can. 0 is a still hole and gives the classic image. Turn it up and the hole drags space around with it: the shadow goes lopsided, with its prograde edge pulled in to 1.06 rₛ while the far edge swings out to 3.50 rₛ, the horizon shrinks from 1 rₛ to 0.53 rₛ, and the disc’s inner edge follows the last stable orbit in from 3 rₛ to 0.62 rₛ, so the inner disc runs hotter and much faster. 0.998 is the Thorne limit, the fastest a hole fed by a disc can spin, because the last photons it swallows spin it back down. Spin roughly doubles the cost of a frame.';
+
+const SPIN_UNAVAILABLE_TOOLTIP =
+  'Two holes are superposed rather than solved, and there is no spinning version of that, so spin is off while a second hole is in the scene.';
+
 export interface PanelActions {
   placePlanet(): void;
   placeStar(): void;
@@ -63,6 +74,12 @@ export interface ControlPanel {
   gui: GUI;
   /** Repaint every control from the settings object it is bound to. */
   refreshDisplays(): void;
+  /**
+   * Enable or disable the spin slider. Kerr is a single-hole solution, so a
+   * second hole in the scene takes the control away rather than letting the
+   * user set a value the renderer will silently ignore.
+   */
+  setSpinAvailable(available: boolean): void;
 }
 
 export interface PanelOptions {
@@ -175,12 +192,36 @@ export function buildPanel(
     camera.add(actions, 'stopTour').name('Stop flight (Esc)'),
     'Ends the flight and hands the camera back to mouse control.',
   );
+  explain(
+    camera.add(settings, 'cameraBoostEnabled').name('Relativistic view'),
+    'Applies the real optics of a fast camera while a flight is running. The star field bunches toward the direction of travel, the sky ahead blueshifts and brightens, the sky behind reddens and dims, and the shadow itself shifts with them. Nothing changes while you orbit with the mouse: that camera is being repositioned, not flown.',
+  );
+  explain(
+    camera.add(settings, 'cameraBoostStrength', 0, 1, 0.05).name('Flight speed'),
+    'Fraction of the flight’s real speed the optics are computed from. At 1 you get the speed the move would actually have: about 0.33c circling at 5.5 rₛ, 0.41c at the closest point of a fly past, and up to 0.95c at the end of a plunge. At 0.5 you see the same flight at half that speed, and at 0 the effect is exactly off.',
+  );
   explain(
     camera.add(actions, 'toggleCinematic').name(compact ? 'Hide the interface' : 'Hide the interface (H)'),
     'Cinematic mode: fades this panel and the readout for a clean, wallpaper-like frame.',
   );
   camera.close();
 
+  // Above the disc folder because spin moves the disc's inner edge: this is
+  // the control that decides where the gas is allowed to start.
+  const hole = gui.addFolder('Black hole');
+  const spinController = explain(
+    hole.add(settings, 'spin', 0, A_STAR_MAX, 0.002).name('Spin (a/M)'),
+    SPIN_TOOLTIP,
+  );
+  addResetButton(
+    hole,
+    () => {
+      settings.spin = shipped.spin;
+    },
+    'Back to a still, non-spinning hole.',
+  );
+  hole.close();
+
   const disc = gui.addFolder('Accretion disc');
   explain(
     disc.add(settings, 'discEnabled').name('Show'),
@@ -298,6 +339,14 @@ export function buildPanel(
     'Angular width of the fan. A narrow fan near the critical impact parameter shows rays splitting between capture and escape.',
   );
   explain(paths.add(actions, 'clearPaths').name('Clear rays'), 'Removes every drawn ray.');
+  explain(
+    paths.add(settings, 'imageOrderTintEnabled').name('Tint image orders'),
+    'Diagnostic overlay. Colours the disc by how far the light wound around the hole before it reached you: blue is the direct view, amber is light that came round the far side once, magenta is the photon ring, two or more half turns. Only the hue changes, the brightness is left alone.',
+  );
+  explain(
+    paths.add(settings, 'imageOrderTintStrength', 0, 1, 0.05).name('Tint strength'),
+    'How far the disc colour is pushed toward the diagnostic hue. 0 leaves the disc alone, 1 replaces its colour entirely and keeps its brightness. The second-order band is thinner than a pixel at normal framing, so pause and let the frame settle to see it.',
+  );
   paths.close();
 
   const sound = gui.addFolder('Sound');
@@ -379,5 +428,12 @@ export function buildPanel(
     explain(tuning.add(DISC_TUNING, 'boostDecayTau', 1, 30, 0.5).name('Boost decay tau'), 'How long a disc feeding boost lingers.');
     tuning.close();
   }
-  return { gui, refreshDisplays };
+
+  const setSpinAvailable = (available: boolean): void => {
+    if (available) spinController.enable();
+    else spinController.disable();
+    spinController.domElement.title = available ? SPIN_TOOLTIP : SPIN_UNAVAILABLE_TOOLTIP;
+  };
+
+  return { gui, refreshDisplays, setSpinAvailable };
 }
diff --git a/src/ui/presets.ts b/src/ui/presets.ts
index d48de70..95a7fec 100644
--- a/src/ui/presets.ts
+++ b/src/ui/presets.ts
@@ -35,6 +35,7 @@ export interface Preset {
       Settings,
       | 'tdeMode'
       | 'timeScale'
+      | 'spin'
       | 'gwTimeCompression'
       | 'tdeTimeCompression'
       | 'discEnabled'
@@ -46,6 +47,8 @@ export interface Preset {
       | 'gridEnabled'
       | 'gridOpacity'
       | 'bloomStrength'
+      | 'cameraBoostEnabled'
+      | 'cameraBoostStrength'
     >
   > & { sky?: Partial<SkySettings> };
   body: ({ kind: BodyKind } & Placement) | null;
@@ -114,6 +117,17 @@ export const PRESETS: readonly Preset[] = [
     camera: { distance: 26, elevation: 0.12, azimuth: 2.2 },
     cinematic: false,
   },
+  {
+    id: 'kerr',
+    name: 'Spinning hole (Kerr)',
+    description:
+      'A near-extremal hole seen almost edge on. The shadow is visibly D shaped, the bright ring is dragged tight against the horizon on the approaching side, and the disc runs all the way down to 0.62 rₛ.',
+    look: { spin: 0.95, discEnabled: true, discBrightness: 1.1, jetEnabled: false, gridEnabled: false, bloomStrength: 1.0 },
+    body: null,
+    binary: null,
+    camera: { distance: 18, elevation: 0.09, azimuth: 1.7 },
+    cinematic: false,
+  },
   {
     id: 'wallpaper',
     name: 'Wallpaper (hides the UI)',

From ec6da2751319750f0d76c9f2a68c82aa0d92d1c0 Mon Sep 17 00:00:00 2001
From: Ashish Nagar <ashishnagar31@gmail.com>
Date: Fri, 31 Jul 2026 16:47:14 -0400
Subject: [PATCH 4/4] Fix what the verification agents found

Three implementations came back needs-work. The findings, and what they cost:

A blocker in the beacon. `apparentImageRadius` returns an impact parameter,
which is a distance in the sky plane, and main.ts placed the sprite that far
along the probe's own direction in three dimensions. That only agrees when
the probe happens to sit side on to the camera; once it swings behind the
hole the image landed inside the shadow, the one place an escaping photon
cannot come from. Placement now projects into the sky plane first, so the
offset from the hole's centre is the impact parameter in every geometry, and
the image is lifted toward the camera so the horizon mask cannot eat it.

The test that should have caught it asserted the scalar against b_crit
rather than measuring where the image lands, so it passed throughout. The
replacement measures the sky plane offset from six directions including
directly behind the hole, which is the case that was broken.

The Kerr preset claimed an inner disc edge of 0.62 r_s while shipping spin
0.95, which puts it at 0.97. That is the ISCO for 0.998. Three doc comments
in kerr.ts carried stale values that the shipped closed forms contradict,
including the file a reader goes to for exactly those numbers.

The light curve recorded forever. Nothing cleared `recording` after a flare,
so the ring filled with post-flare zeros and then decimated the event itself
to make room for them: the longer a scene sat idle, the coarser its record
of the disruption became.

Two claims were true only at one slider position. The light curve's decay
index moves with the disruption clock, so the tooltip and the cheat sheet now
give the range and point at the live fit the caption already prints. The
"spin was set to 0" note fired while `settings.spin` kept the user's value,
so the slider disagreed with the note; it now sets what it says it sets.

Also: `setSpinAvailable(boolean)` was a boolean parameter in a public
interface, which the project standard forbids, and the beacon preset
inherited whatever spin was left over, demonstrating a Schwarzschild
solution against a dragged horizon.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/THEORY.md                        |  2 +-
 src/config.ts                         |  6 +++
 src/main.ts                           | 19 +++++--
 src/physics/kerr.ts                   |  6 +--
 src/sim/__tests__/beaconImage.test.ts | 73 +++++++++++++++++++++++++++
 src/sim/beacon.ts                     | 40 +++++++++++++++
 src/ui/lightCurve.ts                  | 20 ++++++++
 src/ui/panel.ts                       | 19 ++++---
 src/ui/presets.ts                     |  7 ++-
 9 files changed, 176 insertions(+), 16 deletions(-)
 create mode 100644 src/sim/__tests__/beaconImage.test.ts

diff --git a/docs/THEORY.md b/docs/THEORY.md
index c4cb45c..003e6e8 100644
--- a/docs/THEORY.md
+++ b/docs/THEORY.md
@@ -985,7 +985,7 @@ the other column.
 | **The disc is infinitely thin.** | A volumetric disc multiplies the per-pixel cost. | Raymarched volume with real optical depth. |
 | **Three clocks run fast.** | A disruption takes days, an inspiral from $8\,r_s$ takes about 1600 time units, and a probe dropped from $7\,r_s$ takes forty seconds to stop being visible. | Nothing: the trajectories are exact, only the clock is compressed, and the app says so in the interface. |
 | **No light travel-time delay.** | You see the whole disc at one instant rather than each part as it was when its light left. The infalling probe is drawn at its current coordinate position too, with propagation treated as instantaneous: that changes the time constant of the freeze, not the fact of it. | Track photon arrival times through the march. |
-| **The light curve is not the fallback law.** | We plot the disc's feeding glow, which is the absorbed-debris rate smeared by a decay time, fed by debris that a drag term circularises on a fixed timescale. | Leave the debris on its own orbits and plot the arrival rate directly. As it stands the curve decays like $t^{-7.3}$, so the app draws the law next to it and says which is which. |
+| **The light curve is not the fallback law.** | We plot the disc's feeding glow, which is the absorbed-debris rate smeared by a decay time, fed by debris that a drag term circularises on a fixed timescale. | Leave the debris on its own orbits and plot the arrival rate directly. As it stands the decay is far steeper than $t^{-5/3}$ and its index moves with the disruption clock, from about $-12$ at the slowest setting to about $-3$ at the fastest, so the app draws the law next to the curve, prints the live fit, and says which is which. |
 
 | **The sky is invented.** | It follows real structure (luminosity function, dust extinction, clustering) but it is not a star catalogue. | A real survey texture, at the cost of every image looking identical. |
 
diff --git a/src/config.ts b/src/config.ts
index dd986e1..0fe5bae 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -132,6 +132,12 @@ export const DISC_TUNING = {
 };
 
 export const LIGHT_CURVE_TUNING = {
+  /**
+   * Recording stops once the boost falls below this fraction of the flare's
+   * own peak. Without a stop the ring fills with post-flare zeros and starts
+   * decimating the event itself to make room for them.
+   */
+  fadedFraction: 0.002,
   /**
    * Sampling period on the *disruption clock* (see the two-clocks note at the
    * top of this file), so the recorded shape does not change when the
diff --git a/src/main.ts b/src/main.ts
index 3732070..02d44a9 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -25,7 +25,12 @@ import { RenderPipeline, type AccumMode } from './render/pipeline';
 import { SpacetimeGrid } from './render/spacetimeGrid';
 import { Starfield } from './render/starfield';
 import { defaultSettings } from './settings';
-import { observeBeacon, releasePoint, type BeaconObservables } from './sim/beacon';
+import {
+  imagePosition,
+  observeBeacon,
+  releasePoint,
+  type BeaconObservables,
+} from './sim/beacon';
 import { displayRs, orbitalOmegaWall } from './sim/binary';
 import { bodyScale } from './sim/body';
 import { nextWaveState, restingWave } from './sim/gravitationalWave';
@@ -398,8 +403,11 @@ function syncSpin(): void {
   const available = world.binary === null;
   if (available !== spinWasAvailable) {
     spinWasAvailable = available;
-    panel.setSpinAvailable(available);
+    if (available) panel.enableSpin();
+    else panel.disableSpin();
     if (!available && settings.spin > 0) {
+      settings.spin = 0;
+      panel.refreshDisplays();
       showTransientNote('spin is modelled for a single hole, so it was set to 0');
     }
   }
@@ -419,6 +427,9 @@ function syncImageOrderTint(): void {
 }
 
 // --- infalling beacon sync (scratch object, no per-frame allocation) ---
+/** Scratch for the hole-to-camera direction; never allocated per frame. */
+const toCameraDirection = new THREE.Vector3();
+
 const beaconState: BeaconState = {
   pos: new THREE.Vector3(),
   radius: BEACON_TUNING.radius,
@@ -441,7 +452,9 @@ function syncBeacon(view: BeaconObservables | null, viewportHeight: number): voi
   }
   // Drawn at the apparent radius, not the coordinate radius: near the horizon
   // the image piles up on the photon ring instead of sinking into the shadow.
-  beaconState.pos.copy(beacon.direction).multiplyScalar(view.apparentRadius);
+  // The radius is an impact parameter, so it is applied in the sky plane.
+  toCameraDirection.copy(rig.camera.position).normalize();
+  imagePosition(beacon.direction, toCameraDirection, view.apparentRadius, beaconState.pos);
   beaconState.radius = BEACON_TUNING.radius * beacon.horizonRs;
   beaconState.redshift = view.redshift;
   beaconState.brightness = BEACON_TUNING.emission * settings.beaconBrightness;
diff --git a/src/physics/kerr.ts b/src/physics/kerr.ts
index cb5c6be..f7ea685 100644
--- a/src/physics/kerr.ts
+++ b/src/physics/kerr.ts
@@ -56,7 +56,7 @@ export function innerHorizonRadius(spin: number): number {
  * Innermost stable circular orbit, the disc's inner edge (Bardeen, Press and
  * Teukolsky 1972, eq. 2.21).
  *
- * spin 0 -> 3.0 r_s = R_ISCO for both senses; spin 0.998 prograde -> 0.6184;
+ * spin 0 -> 3.0 r_s = R_ISCO for both senses; spin 0.998 prograde -> 0.61849;
  * spin 1 prograde -> M = 0.5, retrograde -> 9M = 4.5.
  */
 export function innermostStableCircularOrbit(spin: number, sense: OrbitSense): number {
@@ -72,7 +72,7 @@ export function innermostStableCircularOrbit(spin: number, sense: OrbitSense): n
  * Schwarzschild photon sphere into two: the prograde one is dragged inward
  * toward the horizon, the retrograde one pushed out.
  *
- * spin 0 -> 1.5 = R_PHOTON for both senses; spin 0.998 -> 0.5366 prograde and
+ * spin 0 -> 1.5 = R_PHOTON for both senses; spin 0.998 -> 0.53695 prograde and
  * 1.9991 retrograde; spin 1 -> M = 0.5 prograde and 4M = 2.0 retrograde.
  */
 export function circularPhotonOrbitRadius(spin: number, sense: OrbitSense): number {
@@ -89,7 +89,7 @@ export function circularPhotonOrbitRadius(spin: number, sense: OrbitSense): numb
  * Solving R(r) = R'(r) = 0 for the equatorial null radial potential gives
  * b = a +- 2 r sqrt(Delta) / (r - M) at r = r_photon.
  *
- * spin 0 -> +-3*sqrt(3)*M = +-B_CRIT; spin 0.998 -> +1.033 and -3.498;
+ * spin 0 -> +-3*sqrt(3)*M = +-B_CRIT; spin 0.998 -> +1.05544 and -3.498;
  * spin 1 retrograde -> -7M = -3.5.
  *
  * Prograde at exactly spin = 1 is degenerate: r_photon, r+ and M all coincide,
diff --git a/src/sim/__tests__/beaconImage.test.ts b/src/sim/__tests__/beaconImage.test.ts
new file mode 100644
index 0000000..9ca87a3
--- /dev/null
+++ b/src/sim/__tests__/beaconImage.test.ts
@@ -0,0 +1,73 @@
+/**
+ * The property that matters for the frozen image: wherever the probe is, its
+ * picture lands outside the shadow.
+ *
+ * The apparent radius is an impact parameter, a distance in the sky plane, so
+ * the only honest test is the one that measures the sky plane offset in a real
+ * viewing geometry rather than comparing the scalar against b_crit.
+ */
+import { describe, expect, it } from 'vitest';
+import { Vector3 } from 'three';
+import { B_CRIT, R_S } from '../../physics/constants';
+import { apparentImageRadius, imagePosition } from '../beacon';
+
+/** Distance of a point from the line of sight, which is what the eye sees. */
+function skyPlaneOffset(point: Vector3, toCamera: Vector3): number {
+  return point.clone().addScaledVector(toCamera, -point.dot(toCamera)).length();
+}
+
+const DIRECTIONS: ReadonlyArray<[string, Vector3]> = [
+  ['side on', new Vector3(1, 0, 0)],
+  ['directly behind the hole', new Vector3(0, 0, -1)],
+  ['directly in front of the hole', new Vector3(0, 0, 1)],
+  ['almost behind', new Vector3(0.02, 0.01, -1).normalize()],
+  ['above', new Vector3(0, 1, 0)],
+  ['oblique', new Vector3(0.4, 0.5, -0.77).normalize()],
+];
+
+describe('where the frozen image is drawn', () => {
+  const toCamera = new Vector3(0, 0, 1);
+  const out = new Vector3();
+
+  it('always lands outside the shadow, from every direction', () => {
+    // A probe one part in ten thousand above the horizon: the hardest case,
+    // because its apparent radius has bottomed out at the photon ring.
+    const radius = apparentImageRadius(R_S * 1.0001, R_S);
+    for (const [name, direction] of DIRECTIONS) {
+      imagePosition(direction, toCamera, radius, out);
+      expect(`${name}: ${skyPlaneOffset(out, toCamera).toFixed(3)}`).toBe(
+        `${name}: ${(B_CRIT * R_S).toFixed(3)}`,
+      );
+    }
+  });
+
+  it('puts the image exactly at the impact parameter, whatever the geometry', () => {
+    for (const [, direction] of DIRECTIONS) {
+      for (const r of [1.2, 2, 5, 20]) {
+        const radius = apparentImageRadius(r * R_S, R_S);
+        imagePosition(direction, toCamera, radius, out);
+        expect(skyPlaneOffset(out, toCamera)).toBeCloseTo(radius, 6);
+      }
+    }
+  });
+
+  it('keeps the image on the probe’s own side of the sky', () => {
+    // A probe to the right must not have its image drawn to the left.
+    imagePosition(new Vector3(1, 0, -0.3).normalize(), toCamera, 4, out);
+    expect(out.x).toBeGreaterThan(0);
+    imagePosition(new Vector3(-1, 0, -0.3).normalize(), toCamera, 4, out);
+    expect(out.x).toBeLessThan(0);
+  });
+
+  it('is lifted toward the camera so the horizon mask cannot eat it', () => {
+    imagePosition(new Vector3(0, 0, -1), toCamera, 4, out);
+    expect(out.dot(toCamera)).toBeGreaterThan(0);
+  });
+
+  it('never returns a non-finite position, even dead in line', () => {
+    for (const direction of [new Vector3(0, 0, 1), new Vector3(0, 0, -1)]) {
+      imagePosition(direction, toCamera, 4, out);
+      expect(Number.isFinite(out.length())).toBe(true);
+    }
+  });
+});
diff --git a/src/sim/beacon.ts b/src/sim/beacon.ts
index bf82b2e..60c0951 100644
--- a/src/sim/beacon.ts
+++ b/src/sim/beacon.ts
@@ -248,6 +248,46 @@ export function apparentImageRadius(r: number, rs: number): number {
   return r / Math.sqrt(1 - rs / r);
 }
 
+/**
+ * How far toward the camera the image is lifted, as a fraction of its own
+ * apparent radius. The overlay pass hides fragments lying beyond the hole, and
+ * an image whose whole point is that it sits outside the shadow must never be
+ * eaten by that test.
+ */
+const IMAGE_LIFT = 0.35;
+
+/**
+ * Where to draw the probe's image, in world space.
+ *
+ * `apparentImageRadius` is an impact parameter: a distance measured in the sky
+ * plane, perpendicular to the line of sight. Placing the sprite that far along
+ * the probe's own direction is only right when the probe happens to sit side
+ * on to the camera. Once it swings behind the hole, that placement drops the
+ * image into the middle of the shadow, which is the one place an escaping
+ * photon can never come from.
+ *
+ * So the direction is projected into the sky plane first, and the radius is
+ * applied there. The projected offset from the hole's centre is then exactly
+ * the impact parameter, whatever the viewing geometry.
+ */
+export function imagePosition(
+  direction: Vector3,
+  toCamera: Vector3,
+  apparentRadius: number,
+  out: Vector3,
+): Vector3 {
+  const alongView = direction.dot(toCamera);
+  out.copy(direction).addScaledVector(toCamera, -alongView);
+  if (out.lengthSq() < 1e-10) {
+    // Dead in line with the hole, so every azimuth on the ring is equally
+    // right. Pick a stable one instead of dividing by zero.
+    out.set(-toCamera.y, toCamera.x, 0);
+    if (out.lengthSq() < 1e-10) out.set(1, 0, 0);
+  }
+  out.normalize().multiplyScalar(apparentRadius);
+  return out.addScaledVector(toCamera, apparentRadius * IMAGE_LIFT);
+}
+
 /**
  * Where a click on the disc plane releases the probe: same azimuth, same
  * radius, lifted out of the plane by `BEACON_TUNING.inclination`.
diff --git a/src/ui/lightCurve.ts b/src/ui/lightCurve.ts
index dfa7a63..223f55c 100644
--- a/src/ui/lightCurve.ts
+++ b/src/ui/lightCurve.ts
@@ -194,6 +194,14 @@ export function recordFeeding(curve: FlareCurve, { disruptionDt, boost }: Feedin
   curve.elapsed += disruptionDt;
   if (curve.elapsed - curve.lastSampleAt < curve.interval) return;
 
+  // Stop once the flare is over. Left running, the ring fills with post-flare
+  // zeros and then decimates the real curve to make room for them, so the
+  // longer you leave the scene alone the coarser the record of the event gets.
+  if (curve.count > 0 && hasFaded(curve, boost)) {
+    curve.recording = false;
+    return;
+  }
+
   if (curve.count === curve.capacity) halveResolution(curve);
   curve.time[curve.count] = curve.elapsed;
   curve.boost[curve.count] = boost;
@@ -201,6 +209,18 @@ export function recordFeeding(curve: FlareCurve, { disruptionDt, boost }: Feedin
   curve.lastSampleAt = curve.elapsed;
 }
 
+/**
+ * True once the boost has sat far below its own peak for long enough that
+ * nothing is coming back. The threshold is a fraction of the peak rather than
+ * an absolute number, because the peak height depends on the body and the mode.
+ */
+function hasFaded(curve: FlareCurve, boost: number): boolean {
+  let peak = 0;
+  for (let i = 0; i < curve.count; i++) peak = Math.max(peak, curve.boost[i]!);
+  if (peak <= 0) return false;
+  return boost < LIGHT_CURVE_TUNING.fadedFraction * peak;
+}
+
 /**
  * Throw away every other sample and double the sampling period, so a flare
  * that outlives the buffer degrades in resolution instead of in span. The
diff --git a/src/ui/panel.ts b/src/ui/panel.ts
index bcef6f9..75ca1d3 100644
--- a/src/ui/panel.ts
+++ b/src/ui/panel.ts
@@ -81,7 +81,9 @@ export interface ControlPanel {
    * second hole in the scene takes the control away rather than letting the
    * user set a value the renderer will silently ignore.
    */
-  setSpinAvailable(available: boolean): void;
+  /** Spin is a one-hole solution, so the control is disabled while a second hole is in the scene. */
+  enableSpin(): void;
+  disableSpin(): void;
 }
 
 export interface PanelOptions {
@@ -276,7 +278,7 @@ export function buildPanel(
   );
   explain(
     lightCurve.add(settings, 'lightCurveFallbackReference').name('Reference law (t^-5/3)'),
-    'Draws the classic fallback law through the peak of the recorded curve: bound debris returns at a rate proportional to t^(-5/3), which is how real tidal disruption flares are identified. It is anchored at the peak and never fitted, because this simulation does not reproduce the law and the gap is the interesting part. Its debris is dragged into the disc on a fixed timescale instead of returning on its own orbits, and the feeding glow has a decay time of its own, so the recorded curve falls off several times faster and its slope moves with the Disruption speed slider. See part 11 of docs/THEORY.md.',
+    'Draws the classic fallback law through the peak of the recorded curve: bound debris returns at a rate proportional to t^(-5/3), which is how real tidal disruption flares are identified. It is anchored at the peak and never fitted, because this simulation does not reproduce the law and the gap is the interesting part. Its debris is dragged into the disc on a fixed timescale instead of returning on its own orbits, and the feeding glow has a decay time of its own, so the recorded curve falls off far more steeply, and how steeply depends on the Disruption speed slider (roughly -12 at its slowest, -3 at its fastest). The caption prints the live fit next to the law so you can see the gap rather than take this on trust. See part 11 of docs/THEORY.md.',
   );
   lightCurve.close();
 
@@ -472,11 +474,14 @@ export function buildPanel(
     tuning.close();
   }
 
-  const setSpinAvailable = (available: boolean): void => {
-    if (available) spinController.enable();
-    else spinController.disable();
-    spinController.domElement.title = available ? SPIN_TOOLTIP : SPIN_UNAVAILABLE_TOOLTIP;
+  const enableSpin = (): void => {
+    spinController.enable();
+    spinController.domElement.title = SPIN_TOOLTIP;
+  };
+  const disableSpin = (): void => {
+    spinController.disable();
+    spinController.domElement.title = SPIN_UNAVAILABLE_TOOLTIP;
   };
 
-  return { gui, refreshDisplays, setSpinAvailable };
+  return { gui, refreshDisplays, enableSpin, disableSpin };
 }
diff --git a/src/ui/presets.ts b/src/ui/presets.ts
index 17b65fd..4a84f3b 100644
--- a/src/ui/presets.ts
+++ b/src/ui/presets.ts
@@ -131,7 +131,7 @@ export const PRESETS: readonly Preset[] = [
     id: 'kerr',
     name: 'Spinning hole (Kerr)',
     description:
-      'A near-extremal hole seen almost edge on. The shadow is visibly D shaped, the bright ring is dragged tight against the horizon on the approaching side, and the disc runs all the way down to 0.62 rₛ.',
+      'A near-extremal hole seen almost edge on. The shadow is visibly D shaped, the bright ring is dragged tight against the horizon on the approaching side, and the disc runs down to 0.97 rₛ, a third of the way in from the 3 rₛ a still hole allows.',
     look: { spin: 0.95, discEnabled: true, discBrightness: 1.1, jetEnabled: false, gridEnabled: false, bloomStrength: 1.0 },
     body: null,
     binary: null,
@@ -147,7 +147,10 @@ export const PRESETS: readonly Preset[] = [
     // Disc dimmed and outflow off: the probe ends up on the shadow rim, where
     // the inner disc and the photon ring are the brightest things in frame,
     // and by then it is nine decades fainter than it started.
-    look: { discEnabled: true, discBrightness: 0.5, jetEnabled: false, windEnabled: false, gridEnabled: false, timeScale: 1, beaconTimeCompression: 3, beaconBrightness: 3.5, bloomStrength: 1.3 },
+    // spin 0 on purpose: the probe integrates a Schwarzschild radial geodesic
+    // anchored to r_s, so demonstrating it against a dragged horizon would be
+    // showing one solution inside another spacetime.
+    look: { spin: 0, discEnabled: true, discBrightness: 0.5, jetEnabled: false, windEnabled: false, gridEnabled: false, timeScale: 1, beaconTimeCompression: 3, beaconBrightness: 3.5, bloomStrength: 1.3 },
     body: null,
     binary: null,
     beacon: { radius: 7, angle: 0.9 },