A replay should be a place, not a recording.

Almost every replay app plays a video. A video is a picture of a broadcast: the camera is where the director put it, the field is a photograph, and nothing on screen can be checked against the timing. Scrub back and the picture changes; the race does not.

The data behind a race is not like that. Position, lap, gap and telemetry for every car are recorded, and they are all on one clock. So the question was whether the same data could be drawn as a place — a circuit you can look at, with the cars on it moving at the times they actually moved, and the numbers beside them.

The drawing is the easy half. The hard half is what the app is allowed to show when the data is thin. A 3D view is persuasive, and a persuasive view that guesses is worse than a table that admits a gap.

Three habits run through the category, and each one gives up the same thing: the ability to check a claim.

Vantage is deliberately narrow. It replays one recorded race, on one circuit, and it is honest about the limits of what that recording contains.

The three cameras answer three different questions. **Overview** shows the whole field, so the shape of the race is visible: where the pack is, where the gaps opened. **Follow** stays with one car and can be orbited and pinched; the selected car keeps its label and its ground ring. **Battle** frames two cars together, and a group-count badge discloses when projected cars overlap rather than inventing lanes for them.

All three read the same clock. The scrubber is the replay; the cameras are views onto it.

The app replays documented OpenF1 recordings from the 2024 Japanese Grand Prix — position, lap, timing and telemetry for a 120-second excerpt.

The timing screen shows the recorded order with a gap or an interval, the last lap, and the age of the source. Sparse events are not inferred from the miniature: a timing screen that quietly invents a missing event is worse than one that admits the data is thin.

The lab screen puts the telemetry on the same clock as the cars — speed traces for two drivers, time-aligned, with speed, throttle, brake, gear and RPM read out at the shared cursor. The miniature and the numbers are the same moment, so a claim can be checked.

Returning from the background leaves the replay paused at the last cursor rather than jumping forward, and timing and telemetry stay available while it is paused.

The native client draws the circuit, the field and the cameras with Expo GL and Three.js. There is no WebView and no video playback: the circuit is a miniature on an olive tabletop, built from editable Blender sources, with the cars as moving projections.

The renderer does 2× supersampling in the native target — an sRGB target, with a linear path and a direct fallback. On the test handset that cut the hard-step fraction from 0.640 to 0.298, so the visible stair-stepping on the track edges roughly halved. It also roughly doubles the measured GPU frame cost, and a hundred seconds of playback is 3.99% janky against 1.72% without it, so **60 fps is not claimed**. A 1.5× experiment traded sharpness for GPU headroom without a consistent jank win, and no adaptive mode is shipped.

Everything claimed here was measured on a physical Samsung Note 20 5G running a release APK — not a simulator and not a mockup. Startup, camera-change and moving-field pixel gates pass as real GL-region comparisons rather than UI-only checks. The pacing figures, the overview framing fix and the supersampling are recorded in the repository's own validation notes, and `npm run check` runs the typechecker, the linter and 39 pure tests.

The honest part: the gaps are specific, and the repository lists them.

Drawing seventeen cars on a circuit in a GL context turned out to be the straightforward part. The part that took the work was deciding what the app was allowed to show when the data was thin.

A car crossing the line is a fact. A car in second place is a judgement the data has to support. So the group-count badge discloses overlapping projections instead of drawing lanes that were never there, the timing screen shows the age of its source instead of inferring sparse events from the miniature, and the miniature is never allowed to be the source of a number.

The second lesson was that a measurement you do not publish is a measurement you did not make. The render notes carry the hard-step fraction, the jank percentage, the changed-pixel counts from the camera sweep, and the 1.5× experiment that did not help — including the costs that were accepted rather than hidden.