Toyota GR Racing Simulator Codename Jimmys Racing

A live racing simulator that predicts optimal pit stop windows during Yellow Flag periods, helping teams make split-second decisions that could mean the difference between victory and defeat.

Comment

Inspiration

As a Windows and Android developer, I've always been fascinated by data science and machine learning, constantly seeking opportunities to explore these technologies. When I saw the "Hack the Track" challenge, I realized this was the perfect opportunity to step outside my comfort zone and dive deep into racing analytics. The ability to process the generated telemetry and turn that data into readable, timely insights for critical decision-making is genuinely captivating.

What it does

-Toyota GR Racing Simulator has an awesome dashboard.

  • Real-time Telemetry Monitoring: Displays live racing data including speed, position, engine metrics, braking performance, and driving analysis
  • Yellow Flag Detection & Prediction: Automatically identifies Yellow Flag periods and predicts their duration
  • ML-Powered Pit Strategy: Uses two machine learning models (Gradient Boosting and Random Forest) to recommend optimal pit stop timing with confidence scores
  • Multi-Circuit Support: Analyzes telemetry from 8 different circuits (Bahrain, Monaco, Silverstone, Spa, Suzuka, Monza, COTA, Interlagos)
  • Playback Simulation: Replay races at 1x-25x speed with complete control
  • Professional Visualization: Clean, dark-themed interface optimized for quick decision-making under pressure
  • Low Resource Consumption: Necessity led me to build a lightweight version that performs well, even on limited hardware."

How we built it

Frontend & Visualization:

  • Dash/Plotly: My first time building a web-based dashboard. Coming from desktop applications, learning the callback-based architecture and reactive programming model was a significant learning curve
  • Real-time Updates: Implemented interval-based callbacks to simulate live telemetry streaming

Data Processing:

  • Pandas & NumPy: Processing millions of telemetry data points across 8 circuits
  • Apache Parquet: Chose this format for efficient storage and fast loading of large datasets
  • Feature Engineering: Created over 15 derived metrics (trail braking, apex speed, intensity, delta to leader)

Machine Learning:

  • Scikit-learn: Implemented two models for pit stop recommendations:
    • Gradient Boosting Classifier: For precise predictions with high confidence
    • Random Forest Classifier: For ensemble validation
  • Training Data: Used historical Yellow Flag patterns, tire wear data, distance to pits, and lap timing

Deployment:

  • Render: Cloud deployment with automatic builds

Challenges we ran into

  1. Time Pressure: The short delivery window was intense. I had to make quick decisions about features vs. polish, ultimately creating two versions (full and lightweight).

  2. Python at Scale: While I had some Python experience, working with large telemetry datasets (15MB+ parquet files) taught me about memory optimization, chunking, and efficient data structures.

  3. ML Integration: This was my first real-world ML implementation. Understanding feature importance, preventing overfitting, and tuning hyperparameters while racing against deadlines was challenging.

  4. Real-time Performance: Balancing smooth 1-second updates with complex calculations (15+ metrics per update) while keeping CPU usage low required careful optimization.

  5. Visualization vs. Performance: Had to abandon heavy graph-based visualizations in favor of value tables to meet the low-resource requirement.

Accomplishments that we're proud of

  • Functional ML Pipeline: Built my first end-to-end ML system that actually makes useful predictions
  • UI/UX: Created an interface that looks and feels competitive
  • 8 Circuits Analyzed: Processed and optimized telemetry from 8 different racing circuits
  • Dual Model Validation: Implemented ensemble learning with confidence scoring
  • Production Deployment: Successfully deployed to Render
  • Performance Optimization: Lightweight version

What we learned

  • Real-time data processing and visualization with Dash/Plotly
  • Practical machine learning
  • Working with Parquet for convenience
  • Production to cloud platforms
  • Feature engineering for racing telemetry
  • Callback-based reactive programming
  • Rapid prototyping under time pressure
  • Yellow Flag patterns and pit strategy
  • Trail braking analysis and apex speed calculation

What's next for Toyota GR Racing Simulator Codename Jimmys Racing

Short-term:

  1. Live Data Integration: Connect to real APIs instead of simulated
  2. *Historical *: Overlay current lap vs. best lap for instant performance feedback
  3. Multi-vehicle Track: Monitor entire race field simultaneously

Medium-term:

  1. Deep Learning Models: Experiment with LSTM networks for time-series prediction of Yellow Flag durations
  2. Weather Integration: Include weather data for recommendations
  3. Fuel Strategy: Include fuel consumption
  4. Voice Alerts: Audio notifications for critical pit window opportunities

Long-term Vision:

  1. Real Team Integration: Partner with actual racing teams for real-world testing

Built With

Share this project:

Updates