How we turned F1 time gaps into metres of racetrack

Time deltas are one of the least intuitive things you can put in front of a person.

If I tell you a driver qualified 0.175 seconds ahead, that is precise and completely unfeelable. Nobody has an internal sense of a tenth of a second. It is a number, and it stays a number.

So we tried a different way to show it: convert the time gap into physical distance on the track, and draw it to scale. This is a short write-up of how that works, where the model is honest and where it cheats, and why the result makes the data click.

The core idea

A gap in time becomes a gap in space if you know the speed:

distance = gap_seconds * speed_metres_per_second

At the sort of speed a Formula 1 car carries across the line, roughly 300 km/h, that is about 83 metres per second. So:

0.1 s  ->  ~8.3 metres
0.175 s -> ~14.5 metres, about three car lengths
1.940 s -> ~161 metres

Suddenly it is not an abstract tenth. It is a chunk of tarmac you can picture. A gap you could not feel becomes a distance you can.

Drawing it to scale

The number on its own is already better, but the thing that makes people stop is drawing it.

We draw it on a straight, treated as a ruler: a finish line, with a distance marker every few metres behind it. The reference car's nose sits on the line, and every other car is
placed straight back by its gap turned into metres, sorted by gap. A qualifying spread from pole to the back of the grid becomes a visible stretch of tarmac you can pace out.

Roughly:

  const SPEED = 83.3; // m/s, the reference car's line speed
  const gapMetres = gapSeconds * SPEED;
  const setbackFromLine = gapMetres; // straight back along the ruler

One honest wrinkle: the cars are also nudged slightly sideways so none hides directly behind the one ahead. That sideways position carries no data at all, it exists purely so you
can see every car. Only the distance along the straight means anything.

Roughly:

const SPEED = 83.3; // m/s, representative speed near the line
const gapMetres = gapSeconds * SPEED;
const chaseDistance = leaderDistanceAlongPath - gapMetres;
// then sample the circuit path at chaseDistance to get x, y

The rendering is the easy part once you think of the track as a single parametric path and just walk backwards along it.

Where the model is honest, and where it cheats

This is the part worth being upfront about, because a naive version is misleading.

Speed is not constant. A car is doing maybe 320 km/h on a straight and 90 km/h in a slow corner. The same 0.2 second gap is a very different distance depending on where on the lap it opens up. Using a single representative speed is a simplification, and it is most accurate near the line and least accurate through the slow stuff.

So the honest framing is "gap expressed as distance at racing speed," not "the exact spot the second car physically was." For qualifying, where the interesting gaps are set on flying laps at high speed, that assumption holds up well. For race pace behind a safety car it would be nonsense, so we do not apply it there.

Being clear about the assumption is what keeps it a useful visualisation rather than a fake-precise one.

Why it works

The trick is not the arithmetic, it is the swap of unit.

People are bad at abstract quantities and good at physical ones: distance, size, the time it takes to walk somewhere. Translate an abstract unit into a physical one and the reader's body does the understanding for you. It is the same reason "an area the size of Wales" beats a number in square kilometres.

Time-to-distance is just one instance of that. You can do the same move with a currency figure, a data-transfer rate, a page-load time. Find the physical analogue and the number stops being a number.

See it running

We built this into a live tool that runs it for every qualifying session on the real circuit shape, so you can pick a race and watch the gaps redraw as distance:

https://www.formuladream.app/f1-interactive/tools/f1-gap-visualizer

It is part of Formula Dream, a free F1 companion app. But the idea travels well beyond racing, and that is really the point: if you are visualising something abstract, try turning it into a distance and see if it suddenly makes sense.

DEV Community