F1TENTH / RoboRacer Autonomous Racing

Real-time autonomy stack for F1TENTH / RoboRacer head-to-head racing on a 1:10-scale car. The system combines LiDAR particle-filter localization, optimized racelines, opponent prediction, and a JAX-based MPPI controller running 8,192 rollouts at 40 Hz on a Jetson Orin Nano. This stack is being prepared for the ICRA 2026 RoboRacer competition in Vienna, where I am competing as part of Penn xLab with support from Penn Robotics and Autonomous Systems (RAS). The competition brings together autonomous racing teams from universities and organizations around the world, including teams from CMU, ETH Zurich, and TU Munich.

My work focused on the MPPI controller, opponent-aware cost design, integration with CUDA particle-filter localization, a C++ opponent-prediction node, ROS 2 systems integration, real-time debugging, and a web-based raceline editor for race-day tuning.

• ROS 2 Humble on a Jetson Orin Nano
• JAX MPPI controller: 8,192 rollouts x 8-step horizon at 40 Hz
• Integrated CUDA-accelerated LiDAR particle-filter localization, 8,000 particles at 50 Hz on isolated cores alongside MPPI
• C++ opponent-prediction node: LiDAR clustering + raceline-arclength Kalman filtering on (s, v) for predictive overtaking
• Opponent-aware MPPI cost for dynamic avoidance and overtaking
• Raceline Studio: web UI to edit waypoints + speed profiles and hot-swap into the running MPPI node via a ROS 2 service
• Real-time debugging: BEST_EFFORT QoS on debug topics, rate-gated visualization, pose-driven controller callbacks

Repos: https://github.com/cedrichld/opp_aware_mppi_f1tenth and https://github.com/cedrichld/raceline_UI_f1tenth

Race-Day Hardware Deployment

Deployed on a Jetson Orin Nano with CPU pinning: particle filter on cores 0-2, MPPI on 3-5, opponent predictor sharing core 5 with spillover. RELIABLE QoS for /drive to the VESC; BEST_EFFORT + subscriber-count gating for debug topics to avoid race-day Foxglove backpressure stalls.

MPPI Pipeline and Cost Stack

Sampling-based predictive control in JAX on the Jetson Orin Nano's GPU. 8,192 rollouts at every step, 8-step horizon (~0.8 s lookahead), 40 Hz control rate. Softmax temperature lambda = 0.05 weights low-cost rollouts; unified memory preallocation (XLA_PYTHON_CLIENT_PREALLOCATE) avoids JAX fragmentation under continuous control. Sub-linear scaling let us push sample count well past the original 2K baseline. The cost stack combines raceline tracking, speed-profile tracking, signed-distance-field wall avoidance, and opponent-aware penalties driven by the predictor.

Opponent Prediction

C++ ROS 2 node that clusters LiDAR returns into candidate opponents, projects each onto the raceline's arclength axis, and runs a Kalman filter on (s, v) to predict where the opponent will be a horizon into the future. The MPPI cost function consumes those predictions for opponent-aware rollout scoring.

Raceline Studio — live raceline editing

Practical race-day tooling: a Flask + rclpy web app to drag waypoints, adjust speed profiles, optimize racelines, and push updates live to the running MPPI node through a ROS 2 service. No file reloads, no controller restart. Speeds up race-day tuning loops from minutes to seconds. Also includes a CLI raceline optimizer for batch profiling.

Simulation and Foxglove visualizations

Hardware brings extra failure modes; the simulator stays the fastest iteration loop for the controller and cost design. Below: an obstacle-avoidance run on the real car at Levine (UPenn) and a dynamic-obstacle clip from a Houston run that exercises the opponent predictor closing the loop.

Prior Coursework — Pure Pursuit, RRT*, Follow-the-Gap

Earlier passes on the same hardware platform covering classical racing controllers: pure pursuit on optimized racelines, RRT* for obstacle-aware planning, and follow-the-gap as the reactive baseline. The overlay below shows the planned line vs the car's actual track during pure pursuit tuning.