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

Abstract: Robotics increasingly relies on GPUs for parallel simulation, large-scale learning, and neural-network inference. For model predictive control (MPC) to scale with this paradigm, solvers must run efficiently on this hardware while remaining fast, differentiable, and compatible with expressive MPC formulations used in robotics. We present TurboMPC, a differentiable MPC solver that runs entirely on the GPU and supports state and control inequality constraints, implicit integrators, cross-time-coupled costs, and slack variables. TurboMPC combines sequential quadratic programming (SQP), an alternating direction method of multipliers (ADMM) inner solver, implicit differentiation, and a co-designed JAX-CUDA implementation for efficiency and ease of use. In simulation, we validate TurboMPC on constrained planning, humanoid imitation learning, and reinforcement learning with neural-network cost function tasks, achieving up to $15\times$ and $58\times$ speedups over state-of-the-art CPU and GPU differentiable solvers, respectively. We deploy TurboMPC on a full-scale car for minimum-time racing and find that batched, GPU-accelerated tuning of MPC parameters via Bayesian optimization yields significantly faster driving than a hand-tuned baseline. TurboMPC also scales to planning horizons of over $8000$ knot points while maintaining control of the vehicle. We open-source TurboMPC at: https://github.com/ToyotaResearchInstitute/turbompc

• The paper presents TurboMPC, a GPU-native, differentiable MPC solver that integrates nonlinear dynamics and realistic constraints for large-scale robotics applications.
• It employs a sequential quadratic programming approach with an ADMM-based QP solver and block-sparse GPU factorization, achieving significant speedups over CPU alternatives.
• Experimental results demonstrate its robustness and scalability across diverse tasks such as drone navigation, humanoid imitation learning, and autonomous racing.

TurboMPC: Differentiable GPU Model Predictive Control for Large-Scale Robotics and Learning

Introduction and Motivation

The adoption of model predictive control (MPC) as an online optimal control framework in robotics and autonomous systems has been constrained by a lack of solver infrastructure that is simultaneously differentiable, scalable, fast enough for deployment, and expressive enough to capture realistic constraints and dynamics. The paper "TurboMPC: Fast, Scalable, and Differentiable Model Predictive Control on the GPU" (2606.24039) introduces a GPU-native differentiable MPC solver that integrates advanced optimal control formulations—including state/control inequalities, implicit integration for stiff systems, cross-time coupling, and slack variables—into an efficient, learning-compatible pipeline. The approach unifies rapid, batched GPU execution, differentiability, and broad constraint handling in a single solver, facilitating its integration in end-to-end optimization pipelines for robotics, learning, and autonomous driving at scale.

Solver Formulation and Implementation

TurboMPC addresses general optimal control problems subject to nonlinear dynamic constraints, pointwise state/control inequalities, rate constraints for actuator smoothing, and optional slack variables for feasibility. The solver adopts a sequential quadratic programming (SQP) outer loop that linearizes and quadratizes the OCP at each iteration, with an ADMM QP solver as its core. Notably, the ADMM implementation leverages the block-sparse (time-structured) nature of the OCP, performing the core linear algebra on the GPU using a direct sparse factorization backend (cuDSS), facilitating simultaneous fast online evaluation and the computation of exact gradients via implicit differentiation.

The co-design includes a high-level JAX API for seamless integration with machine learning infrastructure, while an efficient fused CUDA backend enables fast batched rollouts and learning updates. Crucially, the linear system architecture and choice of solver primitive allow for robust handling of both the forward (primal) and backward (sensitivity) passes, in contrast to the limitations of PCG-based approaches, which are often incompatible with the backward pass for implicit/coupled dynamics.

Key Features and Theoretical Contributions

TurboMPC supports:

• State and control inequalities at all time steps, essential for safety and feasibility in robotics.
• Implicit integration and cross-time costs, accommodating stiff or coupled system dynamics prevalent in high-performance robotics and adversarial environments.
• Rate constraints and slack variables, crucial for actuator protection, feasibility under model mismatch, and stable learning in RL/IL settings.
• Differentiable solution map via implicit differentiation at the active-set KKT solution, enabling analytic gradients despite nontrivial constraint activation patterns and penalty couplings.

The design is motivated by the need to co-optimize forward (policy evaluation) and backward (learning signals) paths for integration with RL, IL, and Bayesian optimization workflows.

Simulation Experiments

Drone Obstacle Avoidance and Constraint Satisfaction

The solver is validated on a 6-DoF drone navigation task requiring state and input constraints for obstacle avoidance and actuator box limits. The inclusion of slack variables is shown to improve solver robustness across diverse initializations, with the trade-off of minor but bounded constraint violations—a critical property for large-scale batched learning and real-world deployment.

Figure 2: Closed-loop MPC trajectories for drone obstacle avoidance show feasible navigation under state and control constraints via TurboMPC.

Linear System RL Scalability

Evaluation on linear quadratic MPC with box-constrained control demonstrates strong scaling properties in both batch size and horizon. TurboMPC achieves up to $15\times$ speedup over acados (CPU) and $58\times$ over mpc.pytorch (GPU) for challenging problem sizes. The performance gap increases with batch size and horizon, validating the efficiency of the block-sparse GPU QP architecture.

Figure 4: Mean solve times (forward and backward passes) scale favorably for TurboMPC relative to acados and mpc.pytorch across batch size, horizon, and problem dimension for RL tasks.

Differentiability in Nonlinear, Constraint-Aware Tasks

The solver supports end-to-end differentiability in imitation learning (IL) for humanoid balance recovery and neural-network parameterized MPC policies in RL. TurboMPC successfully recovers expert cost weights with low imitation loss, confirming that the gradients through the constraint-aware solution map are numerically accurate and learning-stable.

Figure 1: Weight recovery and closed-loop imitation loss for humanoid IL tasks; TurboMPC enables constraint-aware weight learning and stable balancing.

Figure 3: RL with a trainable neural-network cost function: TurboMPC optimizes tracking error efficiently and yields improved closed-loop performance after gradient-based learning.

Autonomous Racing and Online Controller Tuning

A critical demonstration is the deployment on a physical autonomous racing platform (Lexus LC 500), solving a minimum-time track following OCP with real vehicle dynamics and high-dimensional parameter search spaces.

• Bayesian optimization for MPC parameter auto-tuning: TurboMPC enables batched, fully on-GPU hyperparameter optimization using Bayesian sampling, yielding significantly faster lap times compared to hand-tuned controllers, with a $2.44$ m/s mean velocity improvement.
• Very-long-horizon MPC at deployment: The solver handles OCPs with horizon $N > 8000$, a factor of $8\times$ longer than the maximum for the OSQP-based CPU baseline, enabling multi-corner lookahead in racing.

  Figure 5: Auto-tuning of MPC cost parameters enables higher speed and more aggressive behavior relative to baseline hand tuning.

  

  Figure 6: TurboMPC solve times versus planning horizon, exhibiting superior scalability far beyond the OSQP-based baseline for large $N$.

  

Figure 7: At $N=1024$, the OSQP baseline fails catastrophically while TurboMPC maintains full track control, demonstrating the limits of CPU-based approaches.

Implications and Future Directions

The ability to run fast, expressive, and differentiable MPC solvers entirely on the GPU fundamentally changes the scalability of hardware-in-the-loop learning and control. The practical consequences include:

• Large-batch parallel RL and IL: Integrating TurboMPC into batched simulation workflows enables the data regimes and gradient fidelity required by modern deep RL/IL for robotic control.
• Auto-tuning for robust deployment: Fast batched rollouts make online controller auto-tuning (e.g., via BO) tractable on real platforms, addressing the persistent gap between simulation and deployment performance.
• Very-long-horizon, constraint-rich OCPs: By supporting planning horizons and problem classes beyond previous CPU/generic solver limitations, TurboMPC unlocks new capability for multi-scale planning and learning.

Critically, the paper claims that direct sparse factorization (used for both the forward and backward passes) offers uniform robustness and supports all constraint/feature classes needed for complex, real-world control tasks, despite a constant-factor runtime penalty relative to idealized PCG-based approaches. The architectural co-design ensures that differentiability and constraint handling are not sacrificed for speed.

Limitations remain in conic constraint support, active-set transition gradient stability, and low-precision compute utilization, which motivate further research into hybrid factorization schemes, differentiable conic solvers, and robust mixed-precision solution methods.

Conclusion

"TurboMPC: Fast, Scalable, and Differentiable Model Predictive Control on the GPU" (2606.24039) establishes a new benchmark for the deployment of MPC in robotics and autonomous learning by unifying GPU-native execution, full differentiability, realistic constraint support, and large-scale batch/horizon scalability. The solver’s integration of SQP, ADMM, and implicit differentiation onto a fused JAX-CUDA-cuDSS stack addresses longstanding challenges in bridging model-based control and gradient-based learning at scale. The implications are profound for data-driven robotic control, auto-tuning for autonomy, and scalable, constraint-rich policy learning across high-dimensional and physically realistic systems.