Unofficial Logo

GR Teleforge — Project Overview

Inspiration

Motorsport telemetry is extremely detailed, but turning raw CSV files into something understandable normally requires advanced tools and expert race engineers. We wanted to build something that could take the raw Toyota GR telemetry dataset and automatically transform it into synchronized data, meaningful events, and clean visualizations without any manual work.

The idea was simple: make race-level telemetry analysis accessible, fast, and automated.

What It Does

Teleforge:

Ingests raw Gazoo Racing telemetry files using a memory-efficient chunked-reading method.
Synchronizes all cars into one unified Master Timeline.
Detects corners automatically using changes in satellite direction data.
Identifies overtakes using filtered movement logic and distance/duration checks.
Determines the cause of each position change (braking, throttle, gearing, etc.).
Displays everything in a smooth 60 FPS playback UI with real-time motion.
Generates natural-language coaching explanations for each detected event.

How We Built It

Backend Pipeline

The backend is a multi-stage Python pipeline that handles:

File ingestion with custom routines that prevent system memory issues.
High-frequency (20×/sec) time-series alignment essential for accurate comparison.
Data cleanup to fix non-standard column formatting.
Corner detection based on directional change over time.
Overtake filtering using distance + duration rules.
Causal input analysis by mathematically comparing driver inputs.

Frontend Architecture

The frontend is built using a modern web framework with utility-first styling.

Key features:

Custom 60 FPS playback loop synced to the browser’s refresh rate.
Direct DOM manipulation + Refs for ultra-smooth steering wheel + car marker updates.
Lightweight state management for predictable rendering.
Track maps rendered as simple geometric SVG shapes with pan/zoom.

Challenges We Ran Into

20GB+ dataset synchronization required specialized chunk-loading to avoid crashes.
Bad/irregular column formats broke early math steps and needed iterative cleaning.
Time alignment drift appeared repeatedly during data cleanup and had to be solved robustly.
Achieving 60 FPS playback meant bypassing React’s render cycle entirely and using direct transforms.
We were all CS students with zero motorsport or telemetry experience, so translating raw data into something visually understandable was extremely difficult. We had to teach ourselves how to convert noisy, high-frequency numerical streams into smooth on-screen motion, how to visually represent driver inputs, and how to build a synchronized playback engine from scratch without any prior exposure to race data visualization.

Accomplishments

Built a backend capable of fully automated race-engineering workflows:
- data sync
- corner detection
- overtake detection
- driver-input analysis
- auto-generated explanations
Implemented a browser-based 60 FPS playback engine driven by the Master Timeline.
Created a unified data-transmission pipeline that keeps the system seamless end-to-end.

What We Learned

Time-series alignment is absolutely critical for motorsport analytics.
Memory-safe multi-gigabyte processing requires careful file architecture and iteration.
React alone cannot hit 60 FPS : refs + transform operations are required.
Low-level vector math enables features like curvature detection and corner analysis.

What’s Next for GR Teleforge

Future upgrades include:

Cloud deployment as a fully hosted web app.
Per-lap comparison overlays.
Integration of the Ideal Racer model for optimal braking/throttle guidance.
A full season-long analytics dashboard.

Our Learning Curve

We were complete beginners in almost every area of this project.
We had never:

processed multi-gigabyte time-series data,
aligned telemetry streams at high frequency,
built a 60 FPS playback engine, or
implemented low-level math for race analytics.

Every step was a learning victory, and each frustrating crash became a breakthrough. Building Teleforge forced us to teach ourselves advanced data engineering, frontend rendering, and motorsport analytics from scratch, and we’re proud of the result.