💻 computer science

TurboMPC: Fast, Scalable, and Differentiable Model Predictive Control on the GPU

This paper introduces TurboMPC, a fully GPU-based, differentiable model predictive control solver that leverages a co-designed JAX-CUDA implementation to achieve significant speedups over existing methods while supporting complex constraints and enabling efficient, large-scale tuning for robotics applications.

Original authors: Gabriel Bravo-Palacios, Jianghan Zhang, Zachary Pestrikov, Brian Plancher, Thomas Lew

Published 2026-06-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Gabriel Bravo-Palacios, Jianghan Zhang, Zachary Pestrikov, Brian Plancher, Thomas Lew

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are driving a race car. To drive fast without crashing, you need a co-pilot who can instantly calculate the perfect path forward, considering the car's physics, the track's curves, and the fact that you can't turn the steering wheel instantly. This co-pilot is called Model Predictive Control (MPC).

For a long time, this co-pilot lived on a standard computer chip (a CPU). It was smart and careful, but it worked like a single person solving a puzzle one piece at a time. It was too slow to handle the massive amounts of data needed for modern robotics or to "learn" from thousands of practice runs at once.

TurboMPC is a new, super-powered co-pilot that lives entirely on a GPU (the same type of chip used for high-end video games and AI). Here is how the paper explains it, using simple analogies:

1. The "GPU Factory" vs. The "CPU Workshop"

Think of the old CPU solvers as a workshop with one master craftsman. They are very good at solving complex, tricky puzzles (like a car with stiff, hard-to-move parts), but they can only work on one puzzle at a time.

TurboMPC is like a massive factory floor with thousands of workers. Because it runs on a GPU, it can solve hundreds or thousands of driving puzzles simultaneously.

The Result: In tests, TurboMPC was up to 58 times faster than the best existing GPU tools and 15 times faster than the best CPU tools.

2. The "Swiss Army Knife" of Constraints

Most fast GPU tools are like a plastic toy car: they are fast, but they can only drive on flat, smooth surfaces. If you add a bump (a safety constraint) or a sharp turn (a complex rule), they break or stop working.

TurboMPC is like a real, rugged off-road vehicle. It can handle:

Safety Walls: It knows how to stay within boundaries (like not hitting a wall).
Smoothness: It knows how to avoid jerky movements that could break the car's engine.
Stiff Springs: It can handle "stiff" physics (like a suspension that barely moves) without getting confused.
The "Slack" Safety Net: If a situation is impossible (like a wall appearing out of nowhere), TurboMPC has a "slack variable." Think of this as a soft, stretchy rubber band that allows the car to slightly bend the rules just enough to keep moving forward, rather than crashing and stopping the whole process. This is crucial for learning, because if the car crashes in a simulation, the learning stops.

3. The "Learning Loop" (Differentiability)

The paper emphasizes that TurboMPC is differentiable.

The Analogy: Imagine you are teaching a student to drive. If they make a mistake, you need to tell them exactly which muscle to move differently next time.
The Problem: Old solvers were like a "black box." You put a driving plan in, and a path came out, but you couldn't easily trace back why the path was chosen to improve the plan.
The Solution: TurboMPC is like a transparent glass box. It can not only drive the car but also instantly calculate exactly how to tweak the "rules" (like how much to brake or how sharp to turn) to make the car faster next time. This allows it to be used in Reinforcement Learning (learning by trial and error) and Imitation Learning (learning by watching experts).

4. Real-World Racing: The Lexus LC500

The authors didn't just test this in a computer; they put it in a real Lexus LC500 race car.

The Experiment: They used a method called Bayesian Optimization (a smart way to guess the best settings) to tune the car's driving parameters. Because TurboMPC is so fast, they could run thousands of virtual "practice laps" in parallel on the GPU.
The Outcome: The car with the auto-tuned TurboMPC drove significantly faster than a car with a human-tuned driver. It knew exactly when to brake hard and when to accelerate, pushing the car closer to its physical limits without spinning out.
The Long Horizon: The most impressive feat was planning ahead. The baseline system could only plan about 100 steps ahead before losing control. TurboMPC successfully planned 8,000 steps ahead.
- Analogy: Imagine driving down a highway. The old system could only see 100 feet ahead. TurboMPC could see miles ahead, allowing it to anticipate a curve three turns away and start adjusting its speed immediately.

Summary

TurboMPC is a new tool that takes the "smart planning" of robotics and moves it from a slow, single-person workshop to a high-speed, parallel factory. It is fast enough to learn from thousands of simulations at once, flexible enough to handle complex real-world rules, and powerful enough to drive a real race car faster than a human could tune it.

The authors have made this tool open-source, meaning anyone can use this "factory" to build their own fast, learning robots.

Technical Summary: TurboMPC

Problem Statement

Robotics is increasingly leveraging GPUs for parallel simulation, large-scale learning, and neural network inference. However, Model Predictive Control (MPC), a cornerstone of robotic control, remains largely CPU-centric. Existing high-performance MPC solvers exploit the temporal sparsity of optimal control problems (OCPs) via sequential Riccati recursions, which are difficult to parallelize on GPUs. Conversely, existing GPU-based differentiable solvers often restrict problem formulations to expose parallelism, sacrificing support for essential robotics features such as implicit integrators (for stiff dynamics), control-rate costs (for actuator protection), state inequality constraints (for safety), and slack variables (for feasibility). This creates a tradeoff where researchers must choose between the expressiveness required for real-world deployment and the scalability required for modern learning pipelines.

Methodology

The authors present TurboMPC, a differentiable MPC solver designed to run entirely on the GPU while supporting expressive problem formulations. The solver addresses the OCP defined as minimizing a cost function subject to dynamics, equality constraints, and inequality constraints (with optional slack variables).

Core Algorithmic Design

Outer Loop (SQP): TurboMPC solves the OCP using Sequential Quadratic Programming (SQP). At each iteration, it linearizes constraints and quadratizes the cost to form a convex Quadratic Program (QP).
Inner Solver (ADMM): The resulting QPs are solved using a custom Alternating Direction Method of Multipliers (ADMM) scheme.
- Inspired by OSQP, it utilizes a splitting scheme but introduces a specific handling for slack variables (inspired by [48]) to avoid extending the problem size.
- The primal update involves solving a linear system derived from the KKT conditions.
- The solver employs over-relaxation strategies and adaptive step-size parameters ( $\sigma, \rho$ ) to balance primal and dual residuals.
Differentiability (Implicit Differentiation): To support learning pipelines, the solver computes gradients via implicit differentiation at the converged solution.
- It differentiates the active-set Karush-Kuhn-Tucker (KKT) conditions.
- Unlike forward-pass solvers that may rely on block-tridiagonal structures (e.g., PCG), the backward pass linear system often lacks this structure due to cross-time couplings from implicit dynamics or control-rate costs.
- Therefore, TurboMPC uses cuDSS (a direct sparse factorization library) as a unified primitive for both forward and backward passes, ensuring robustness and differentiability across all supported features.

Implementation and Co-Design

TurboMPC employs a co-design approach integrating the optimization algorithm, GPU implementation, and learning infrastructure:

JAX Frontend: The outer SQP loop, problem linearization, and batching are handled in JAX, providing automatic differentiation and easy integration with learning pipelines.
Fused CUDA Backend: The entire ADMM inner loop is implemented as a fused CUDA kernel. This minimizes kernel launch overhead, which is significant for iterative solvers.
Linear Algebra: The solver uses cuDSS for sparse direct factorization. While this incurs a constant-factor overhead compared to iterative methods like PCG, it provides generality across explicit/implicit dynamics and supports batched factorization.
Scalability: The architecture supports online deployment (low latency, single instance) and batched offline evaluation (high throughput) from a single API.

Key Contributions

Full-Feature GPU Solver: TurboMPC is the first differentiable GPU solver to simultaneously support state/control inequality constraints, implicit integrators, cross-time-coupled costs, and slack variables.
Performance: It achieves significant speedups over state-of-the-art baselines. In simulation, it demonstrates up to 15× speedup over CPU-based solvers (acados) and 58× speedup over existing GPU differentiable solvers (mpc.pytorch) for specific batch sizes and horizons.
Real-World Deployment: The solver was deployed on a full-scale Lexus LC500 for minimum-time racing.
- Auto-Tuning: Using GPU-batched Bayesian optimization, the system automatically tuned MPC parameters, resulting in significantly faster lap times compared to hand-tuned baselines.
- Long-Horizon Planning: TurboMPC successfully maintained vehicle control with planning horizons exceeding 8000 knot points (8× longer than the baseline's limit), demonstrating unprecedented scalability for online control.
Learning Integration: The solver was validated in reinforcement learning (RL), imitation learning (IL), and neural network cost function training tasks, successfully recovering expert weights and training policies with analytic gradients.

Results

Simulation Benchmarks: In linear-system RL scaling tests, TurboMPC outperformed baselines as batch size, horizon, and problem dimension increased. While CPU solvers (acados) were faster for single-instance solves, TurboMPC dominated in batched scenarios.
Humanoid Imitation Learning: The solver successfully recovered cost weights for a Unitree G1 humanoid balancing task, achieving a median weight recovery error of 0.59 and demonstrating stable closed-loop balancing in MuJoCo.
Autonomous Racing:
- Speed: The auto-tuned policy drove 2.44 m/s faster on average than the hand-tuned baseline.
- Scalability: At a horizon of $N=1024$ , the OSQP-based baseline lost control, whereas TurboMPC maintained control. It scaled to $N > 8000$ without failure.
- Throughput: GPU-accelerated Bayesian optimization achieved ~150 trials/hour compared to ~21 trials/hour on CPU, a ~7.1× speedup.

Significance and Claims

The paper claims that TurboMPC bridges the gap between the structured decision-making of MPC and the scale of modern learning-based robotics. By running entirely on the GPU and supporting complex, realistic formulations, it enables:

Scalable Learning: Integration of MPC into RL, IL, and Bayesian optimization pipelines with large batch sizes.
Expressive Control: The ability to model stiff dynamics and safety constraints without sacrificing performance.
Real-Time Long-Horizon Planning: The capability to plan over extremely long horizons (thousands of nodes) in real-time, which is critical for high-speed autonomous driving.

The authors acknowledge limitations, including the constant-factor overhead of direct sparse factorization compared to iterative methods, the reliance on double precision (limiting low-precision GPU utilization), and the potential for gradient discontinuities at active-set transitions. They suggest future work in hybrid backends and mixed-precision arithmetic.

Availability: The solver is open-sourced at https://github.com/ToyotaResearchInstitute/turbompc.