FullThrottle is a free and fast web app providing Formula 1 telemetry charts and session replays. Compare across drivers, laps, sessions, rounds, and years right from your browser.

Note

This is a hobby project and is under heavy development. If you find any bugs or want to request a feature please submit an issue or create a PR.

Features

• Interactive Telemetry: Scrub through laps and watch speed, throttle, brake, RPM, and gears synced to the track map.
• Live Track Map: Car positions and corners for session replays and per-lap analysis.
• Full Session Replays: Includes leaderboards, maps, and replay for Race, Qualifying, Free Practice, and a few Pre-season testing sessions.
• Head to Head Comparisons: Compare different drivers for a session across laps, compounds, and even years.

Architecture

FullThrottle is built edge-first. The goal was to efficiently get the telemetry to end users, and let the browser do all the work.

• Frontend: Built with SvelteKit (Svelte 5) for a fast and reactive interface.
• Visualizations: D3.js for all the telemetry visualizations
• Data Pipeline:
  • Raw telemetry is sourced using FastF1 in Python, then pre-processed into compressed Parquet format.
  • Parquet files and session metadata are uploaded to a Hugging Face dataset, which acts as the CDN origin.
  • The frontend requests .parquet files from Hugging Face's CDN. Each file is a few MB.
  • The client parses the data in-browser using hyparquet. Once a session is loaded, switching between drivers and laps is near-instant.

Data Pipeline

Telemetry ingestion is run locally via the scripts in ingest/. F1's live timing servers block cloud/datacenter IP ranges (including GitHub-hosted Actions runners), so automated cron runs in the cloud return empty data.

Running Ingest

To pull recent sessions, process Parquet files, rebuild metadata, and upload to Hugging Face:

cd ingest
python3 ingest.py 2026
python3 build_metadata.py
python3 upload.py

Data Storage

Region	What lives there	Who writes it
GitHub repo (static/metadata.json)	Session index loaded by the frontend	Committed manually after ingest
Hugging Face dataset	All .parquet + .json session files	Uploaded via upload.py
Local dev (static/data/)	Downloaded copy for offline development	Developer, via hf download

static/data/ is gitignored. The repo only tracks metadata.json.

Development

Prerequisites

• Node.js (v20+, v24 LTS recommended)
• npm, pnpm, or bun
• Python/pip (to grab the Hugging Face CLI)

Installation

1. Clone the repository:

   git clone https://github.com/Chiroyce1/FullThrottle.git
   cd FullThrottle

2. Install dependencies:

   npm install

3. Start the development server:

   npm run dev

4. Open your browser and navigate to http://localhost:5173.

5. Optional: To have the telemetry data load instantly, you can download the .parquet files from Hugging Face and place them in the /static/data directory.

   All the pre-processed .parquet telemetry and .json metadata files are on Hugging Face - 2025 and 2026 data is currently available, more to come soon. The download might take a while.

   python3 -m pip install huggingface_hub # global install of the cli
   hf download fullthrottlef1/fullthrottle --repo-type dataset --local-dir ./static/data

Testing

To run the telemetry algorithm tests (which execute directly against the downloaded Parquet data):

npm run test

Analytics

FullThrottle uses PostHog for anonymized web analytics and user feedback during the early development/testing period, alongside Cloudflare for web hosting and analytics.

License, Contibuting and AI

This project is licensed under the AGPLv3 License - see the LICENSE file for more information.

Consider this a starting point for the project. I expect to refactor a lot of it and I'm hoping to get contributions that will help improve the overall code quality and fix bugs that are definitely still present.

If you find any bugs or want to request a feature please submit an issue or create a PR.

Contributions are welcome! Entirely AI generated PRs can be rejected outright. It is expected that you actually understand the code changes you are introducing and have tested and verified them locally before submitting a PR.