mrkeyoor.com_
Fri 16 Oct 18:52 UTC
Dataevaluationupdated 08 Oct 2026

f1-race-replay review

F1 Race Replay is a Python desktop application that turns FastF1 race data into an animated track replay with driver positions, timing, tyres, and telemetry windows. It gives an F1 fan a way to inspect a past session without building the data-processing and interface layers from scratch.

+64stars / 7d
Verdict

Our F1 Race Replay run passed 69 of 85 tests, while 16 GUI imports failed for missing OpenGL libraries and the installed environment carried 37 known vulnerabilities. Try it as an enthusiast desktop tool if animated sessions and hackable telemetry windows outweigh some rough data and packaging edges. Do not use its leaderboard as an authoritative race record, and resolve the missing license file before redistributing a fork.

We ran it

Lab card: what happened when we ran f1-race-replayScreenshot of f1-race-replay (github.com/IAmTomShaw/f1-race-replay)
Install✓ · 19s79 packages · 1142 MB
Build✓ · 1s
Tests✗ · 9s69 passed · 16 failed of 85 (pytest)
Known vulns37(pip-audit)
Repo79 files~17,061 lines of source · 18 MB · 1 CI workflows · tests dir

Answers from our run

Does f1-race-replay build from source?

Dependencies installed in 19 seconds (79 packages), and the build succeeded in 1 seconds. We cloned commit efdb8a3 into a clean Debian container with 3 CPUs and no project-specific setup.

Do f1-race-replay's tests pass?

Not all of them: 69 of 85 passed and 16 failed when we ran the project's own test command (pytest). Some failures need services or credentials a bare container does not have.

Does f1-race-replay have known vulnerabilities in its dependencies?

pip-audit flagged 37 known advisories in the dependency tree at the time of our run.

Who should not use f1-race-replay?

Analysts who need the displayed running order to be authoritative: the README admits leaderboard inaccuracies, and issue 331 describes order flipping at lap boundaries.

What are the alternatives to f1-race-replay?

FastF1, MultiViewer, F1DB. Our F1 Race Replay run passed 69 of 85 tests, while 16 GUI imports failed for missing OpenGL libraries and the installed environment carried 37 known vulnerabilities.

Setup2/5Fast install, but 16 GUI imports failed without system OpenGL
Docs4/5Detailed controls, modes, telemetry format, and known limitations
Community4/56,600-plus stars and an October 6 push, with many open reports
Maturity2/5Useful breadth, but accuracy, audit, and licensing gaps remain

Discussed on

  1. hnAn interactive Formula 1 race viz and data analysis tool built with Python4 points

Who it’s for

F1 fans who want an interactive replay rather than another static timing chart.
Python developers building custom pit-wall windows from replayed telemetry.
Data students who can tolerate imperfect positioning while exploring race sessions.
Desktop users with OpenGL support and enough disk space for a 1,142 MB Python environment plus cached sessions.

Who it’s NOT for

Analysts who need the displayed running order to be authoritative: the README admits leaderboard inaccuracies, and issue 331 describes order flipping at lap boundaries.
Headless Linux or minimal-container users expecting the GUI modules to import without system graphics libraries: 16 tests failed in our sandbox because libGL.so.1 or library GL was missing.
Security-controlled environments that require a clean dependency audit: our installed environment had 37 known vulnerabilities.
Contributors who need unambiguous reuse terms: the README says MIT, but no license file exists and issue 316 remains open about that gap.
Memory-limited machines processing full grids: issue 327 reports worker MemoryError failures when a session object is copied into multiple tasks.

Setup reality

Our sandbox installed 79 packages in 19 seconds and used 1,142 MB. The build succeeded in 1 second. Pytest finished in 9 seconds with 69 passes and 16 failures out of 85; every visible failure was an import error for missing libGL.so.1 or library GL. Pip-audit found 37 known vulnerabilities.

The application needs Python 3.11 or newer, FastF1, Arcade, pyglet, PySide6, and a working graphical desktop. Past-session data downloads through FastF1 on first use and is cached locally. The optional telemetry stream opens a newline-delimited JSON feed on localhost port 9999; no API credential is documented.

A fresh Debian container needs a system OpenGL library before all modules can even import. The README also requires OpenGL 3.3 or newer and documents a separate conda workaround. First session loads take longer because data must be downloaded, processed, and cached, but our lab did not measure that runtime.

The replay makes FastF1 data easier to inspect

F1 Race Replay turns a past session into moving cars on a rendered circuit. You can pause, rewind, change playback speed, hide interface layers, select drivers, and inspect speed, gear, DRS, lap, and tyre information. Safety Car periods appear too, although that car's position is simulated because the source data does not include its GPS path. The result is closer to a personal pit-wall screen than a notebook chart.

The basic workflow is approachable. Run python main.py, pick a year and round in the graphical menu, then wait while FastF1 downloads and processes the session. Direct commands can open a race, sprint, or qualifying session and refresh cached data. Playback offers 0.5x, 1x, 2x, and 4x controls. The README warns that a first load takes longer, but our lab did not measure session download or rendering speed.

A localhost feed turns the replay into a development surface

An optional telemetry mode publishes newline-delimited JSON over a TCP socket on localhost port 9999. Frames carry driver positions, throttle, brake, gear, DRS, tyres, weather, replay state, and session timing. The repository also provides a PitWallWindow base class that handles the connection and window cleanup, so a developer can concentrate on a custom analysis panel rather than the transport code.

That feed is the most interesting reason to choose this project over a fixed viewer. It can drive side windows for sector times, race control messages, strategy, or selected-driver telemetry while the main replay runs. Sector fields may be null when timing is unavailable, and the documentation tells consumers to treat null as unknown rather than zero. This is practical guidance for anyone calculating an ideal lap from 3 sectors.

What happened when we ran it

Our sandbox installed commit efdb8a3 in 19 seconds, adding 79 packages and using 1,142 MB on disk. The checkout itself contained 79 files, about 17,061 lines of source, and occupied 18 MB. A build check succeeded in 1 second. The environment was an unprivileged Debian container with 3 CPUs, 8 GB of RAM, Python 3.12, and no secrets.

Pytest completed in 9 seconds with 69 passes and 16 failures out of 85 tests. The failed cases all came from the import sweep. Modules for driver telemetry, the pit wall, race control, sector times, track position, tyre strategy, qualifying, the main replay, and session startup could not load because libGL.so.1 or library GL was absent. The log supports that narrow finding and no broader cause.

Pip-audit reported 37 known vulnerabilities in the installed environment. The repository had 1 CI workflow file, a tests directory, and no Dockerfile. This is a better test outcome than a suite that never starts: 69 cases did run. It still means the documented pip installation was insufficient for importing the complete application on fresh Debian, and the dependency audit needs review before use inside a controlled environment.

Running order can be visually wrong at lap boundaries

The README already says its leaderboard can be inaccurate in the opening corners, around pit stops, and at the finish. Open issue 331 goes further: it reports that per-lap distance resets to zero at each lap boundary while the application ranks drivers by that value. A leader crossing the line can therefore appear behind cars still finishing the previous lap. That affects the central replay, not a decorative side panel.

Issue 327 describes a different cost on Windows with Python 3.12.7. A full-grid session can raise MemoryError when the complete FastF1 session object is passed to each worker task. Another current report covers a 2026 Bahrain replay crashing when circuit marker information is missing. These are user reports rather than failures from our 85-test run, but each names a reproducible session or workload that a buyer can check.

The desktop requirements are missing from the pip command

The README asks for Python 3.11 or newer and installs nine top-level requirements, including FastF1, Arcade, pyglet, and PySide6. It also states that OpenGL 3.3 or newer is required and gives conda users a libstdcxx-ng workaround for context errors. Our Debian result adds a specific boundary: the 1,142 MB Python environment still lacked the system GL library needed to import 16 modules.

There is no Dockerfile, which is reasonable for an interactive desktop app but removes a reference Linux image. The requirements file also has no version pins. A new issue reports that Python 3.14 installation can fall into a local Pymunk build through Arcade, while our Python 3.12 install succeeded in 19 seconds. Use the interpreter version from a known working setup, then test graphics and one complete session before blaming FastF1 or the replay code.

The README's MIT claim lacks a license file

The README labels the project MIT, but GitHub's repository API reports no detected license and the root has no LICENSE file. Open issue 316 has tracked that exact mismatch since July 23, 2026. A sentence in a README shows intent, yet contributors and redistributors should not have to infer the operative license text. Ask the maintainer to add it before shipping a modified version.

Development is plainly active. GitHub recorded the last push on October 6, 2026, and 154 open issues and pull requests combined. The API returned no latest release, so users currently track commits instead of a tagged package line. That activity makes the project worth trying for an F1 data hobbyist, but the unpinned environment, 37 audit findings, order bug, and missing license file keep it out of serious analytical workflows.

Alternatives

ProjectWhat it isPick it when
FastF1The Python library underneath this project for loading and analyzing Formula 1 timing and telemetry data.pick this instead when notebooks, plots, and your own calculations matter more than an animated replay interface.
MultiViewerA polished desktop viewing companion for Formula 1 timing, video, maps, and telemetry.pick this instead when you want a finished spectator application and do not need open Python source to modify.
F1DBA structured open database of Formula 1 history and results in several export formats.pick this instead when historical records and queryable results matter more than telemetry playback.

What people are saying

  1. [github-trending] IAmTomShaw/f1-race-replay

Sources

  1. F1 Race Replay README
  2. Telemetry stream documentation
  3. Running-order lap boundary report
  4. Full-session memory report
  5. Missing license file report
  6. Measured F1 Race Replay commit

More data reviews

wine-quality-svc-tuning · dhis2-immunisation-audit · OpenTerminal · The-Quant-Trading-Vault · multimodal-product-discovery · edgequake · the whole board →