NVIDIA's cuOpt Beats Every Open-Source Solver With 5000x GPU Speedup

Mathematical solvers have quietly been one of the last major workloads still stuck on CPUs. That is changing fast. NVIDIA cuOpt just claimed the top spot on the Hans Mittelmann benchmarks as the fastest open-source solver across three optimization problem classes, and the entire codebase is now sitting on GitHub under an Apache 2.0 license.

cuOpt is a GPU-accelerated optimization library that solves Linear Programming (LP), Quadratic Programming (QP), and Vehicle Routing Problems (VRP), with support for Quadratically Constrained Quadratic Programming (QCQP), Second-Order Cone Programming (SOCP), and Mixed Integer Linear Programming (MILP) in beta. If you have ever waited hours for a CPU-based solver to grind through a supply chain model, this release deserves a closer look.

What the benchmark win actually means

The Hans Mittelmann benchmarks, maintained at Arizona State University, are the de facto scoreboard for optimization software. The Simplex and Barrier benchmarks were replaced by benchmarks that measure how well solvers find a primal-dual feasible point or an optimal basic solution, and separate tracks now exist for MIP and network LPs.

The context matters. In August 2024 Gurobi withdrew from the benchmarks, and on 12/24/2024 MindOpt followed suit. With two major commercial solvers off the board, the leaderboard has become a battle among the remaining CPU incumbents and a new wave of GPU-native entrants. cuOpt won the 2026 LPFeas Hans Mittelmann leaderboard as the world's fastest open-source LP solver, and three out of the four LP solvers on the board are now GPU-accelerated.

Why GPUs finally cracked linear programming

Classical LP algorithms like Simplex are inherently sequential, which is why they resisted GPU acceleration for decades. The breakthrough came from a different family of methods. The evolution of LP solvers has been marked by significant milestones from Simplex to the interior point method, and the introduction of primal-dual linear programming (PDLP) has brought another significant advancement, which cuOpt has implemented with GPU acceleration.

PDLP is a first-order method dominated by two operations: sparse matrix-vector multiplication and elementwise maps. Both are memory-bandwidth bound, which is exactly where modern GPUs shine. Memory bandwidth refers to the amount of data that can be transferred per second, and while CPUs handle hundreds of GB/s, the NVIDIA HGX B100 has a bandwidth of eight TB/s, two orders of magnitude larger. Because PDLP relies heavily on memory-intensive patterns like Map and SpMV, its performance scales directly with memory bandwidth, meaning future NVIDIA GPU upgrades will automatically make PDLP faster, unlike CPU-based solvers.

The speedup numbers

Independent and vendor benchmarks paint a consistent picture, though the magnitude depends heavily on the problem structure:

• On Mittelmann's benchmark set at 10^-4 tolerance, cuOpt was faster than a state-of-the-art CPU LP solver on 60% of instances and more than 10x faster on 20%, with the largest observed speedup reaching 5000x on a large-scale multi-commodity flow problem.
• cuOpt delivers 8x+ speedups over leading CPU-only open source solvers and is Apache 2.0 licensed.
• HiGHS combined with cuOpt GPU acceleration improves MIP gap from 28% to 21% on certain problem classes.

The MIP story is more nuanced. cuOpt uses GPU acceleration to deliver high-quality solutions to MIP problems through primal heuristics, enabling the discovery of new solutions for four open instances from the MIPLIB benchmark set, with substantial improvements in solution quality and number of feasible solutions compared to leading open-source CPU solvers. Under the hood, three novel evolutionary algorithms refine the model, applied on stagnation detection for an additional 3% reduction in the primal gap, alongside a Branch and Bound approach with diving threads and a subMIP-based Evolutionary Algorithm.

Where it still falls short

cuOpt is not a drop-in replacement for every use case. The MIP solver in particular has honest caveats. MIP is NP-hard, meaning no known algorithm can solve all such problems quickly in the worst case; commercial MIP solvers routinely deliver optimal solutions for many large instances, but certain problems remain intractable or require prolonged computation. The GitHub README is upfront that the MIP solver is under active development and excels at finding high-quality feasible solutions quickly, while proving those solutions optimal is still being worked on.

There is also a hardware-cost tradeoff worth watching. The H100 was roughly five times more expensive than the RTX A6000, but Mittelmann benchmark results showed the H100 was between two and six times faster on all but one problem, so bigger GPUs do not always give proportional returns on smaller LPs.

Getting it into your stack

The install story is refreshingly boring, which is a compliment. cuOpt requires CUDA 12.0+ or 13.0+, an NVIDIA driver 525.60.13 or newer, and Volta architecture or better. For CUDA 12.x:

pip install \
  --extra-index-url=https://pypi.nvidia.com \
  cuopt-server-cu12==26.6.* cuopt-sh-client==26.6.*

Conda and Docker paths are also supported, with images published on the NVIDIA Docker Hub. The bigger deal for existing operations research teams is integration. You can accelerate existing AMPL, CVXPY, PuLP, Pyomo, and SciPy models with zero-code integration. If your team already has a PuLP or JuMP codebase, you point it at cuOpt and get GPU acceleration without rewriting the model.

A minimal LP in the native Python API looks like this:

from cuopt.linear_programming.problem import Problem, CONTINUOUS, MAXIMIZE
from cuopt.linear_programming.solver_settings import SolverSettings
problem = Problem("Simple LP")
x = problem.addVariable(lb=0, vtype=CONTINUOUS, name="x")
y = problem.addVariable(lb=0, vtype=CONTINUOUS, name="y")
problem.addConstraint(x + y <= 10, name="c1")
problem.addConstraint(x - y >= 0, name="c2")

Who actually needs this

The workloads where cuOpt earns its keep are the ones where solver latency blocks a business decision:

• Vehicle routing and last-mile delivery with thousands of stops and dynamic time windows
• Supply chain and production planning with millions of variables
• Energy dispatch and unit commitment, where cuOpt has achieved up to 20x speedups in large-scale unit commitment problems
• PageRank-style flow problems and quadratic assignment
• Agentic workflows where an LLM generates constraints on the fly and needs sub-second solves

The last one is where things get interesting. NVIDIA also ships an open cuOpt reference workflow and cuOpt agent skills to translate natural language business problems into mathematical models and optimized decisions in seconds. Pair that with a fast enough solver and optimization stops being a batch job you run overnight, and starts looking like a callable tool inside an agent loop.

The bigger picture

For twenty years, the commercial LP and MIP market has been a three-horse race between Gurobi, CPLEX, and Xpress, with performance gaps measured in single-digit percentages between releases. GPU acceleration is the first thing in a long time that changes the shape of the curve rather than nudging it. When two of the three commercial leaders pull out of public benchmarks in the same year an open-source GPU solver takes the top of the leaderboard, that is a signal worth reading. The NVIDIA developer blog and the cuOpt documentation are the fastest way in if you want to benchmark it against your own workload.