DEV Community: Formula Neon

Who owned each corner? Mapping F1 lap dominance in minisectors

Formula Neon — Sun, 02 Aug 2026 12:52:22 +0000

A qualifying laptime is a single number, and a single number hides almost everything interesting about the lap.

Two drivers can set nearly identical times in completely different ways: one is quickest through the fast corners, another claws it back under braking, a third is untouchable on the run to the line. The final gap is just the sum of all of that. So the question we wanted to answer was not who was fastest, it was where each driver was fastest.

This is a short write-up of how we turn a set of laps into a track coloured by who owned each part of it, where the model is honest, and where you have to be careful.

The core idea: split the lap, compare segment by segment

A lap is a sequence of samples, each with a position on the track and a timestamp. On its own that is just a squiggle. The move that makes it readable is chopping the lap into minisectors: short segments, a few hundred metres each, defined by distance along the track rather than by time.

Distance matters here. If you split by time, every driver's segments land in different places and you cannot compare them. Split by distance and segment n is the same piece of tarmac for everyone, so "who was fastest through segment n" is a fair question.

For each segment you compute the time each driver spent crossing it, then colour the racing line by the winner:

for each driver:
  resample their lap to a common distance axis (0..trackLength)
  for each minisector [d0, d1]:
    t_in  = interpolate time at distance d0
    t_out = interpolate time at distance d1
    segmentTime[driver][sector] = t_out - t_in

for each minisector:
  winner = argmin over drivers of segmentTime[driver][sector]
  colour that stretch of the racing line with winner's team colour

The resample-to-a-common-distance-axis step is the whole trick. Raw telemetry is sampled in time, not distance, so before you can compare "the same corner" across drivers you interpolate every lap onto a shared distance grid. After that, the comparison is just an argmin per segment.

The lap nobody drove

Once you have per-driver segment times, one more line gives you something people love: the theoretical best lap.

theoreticalBest = sum over sectors of ( min over drivers of segmentTime[sector] )

Take the fastest time anyone set through each minisector and stitch them together. It is always quicker than the actual pole, sometimes by more than a second, because no single driver strings every segment's best together on one lap. It is a clean measure of how much time was left on the track.

Where you have to be careful

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

Segment boundaries are a choice. Make them too long and you blur two corners into one verdict; too short and telemetry noise starts flipping the winner back and forth. There is no single correct length, only one that is honest for the track. We tune it so each segment is roughly one feature, a corner or a straight, not half of two.

Alignment is by distance, not lap distance travelled. Drivers take slightly different lines, so their raw distance-travelled differs over a lap. You align to track position (progress along the circuit), otherwise a wider line reads as "slower" purely from geometry.

It is per segment, not per driver. A colour means "fastest through this stretch," full stop. It does not mean that driver was faster overall, and the map is deliberately honest about that: a lap can be a patchwork of colours and still belong, on total time, to the driver who barely shows up on it.

Being explicit about those keeps it a useful visualisation instead of a confident-looking wrong one.

Why it reads so well

The arithmetic is almost nothing, an interpolation and an argmin. The value is entirely in the swap of representation: from a laptime, which is one opaque number, to a map, which your eye reads instantly.

Where one colour dominates, that driver was building the lap. Where it flickers between colours, the field was trading tenths corner by corner. You stop reading a time and start reading a story, and you did not have to understand a single millisecond to get it.

See it running

We built this into a live tool that colours any 2026 qualifying session on the real track shape, so you can pick a race and drivers and watch the domination map redraw:

https://www.formuladream.app/f1-interactive/tools/track-domination

It is part of Formula Dream, a free F1 companion app. But the pattern travels: any time you have parallel runs over the same course, a race, a build pipeline, an A/B rollout, splitting by position and colouring by the local winner turns "who was fastest overall" into the far more useful "who was fastest where."

How we turned F1 time gaps into metres of racetrack

Formula Neon — Thu, 30 Jul 2026 16:47:29 +0000

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.