Release Notes#

Release Notes 26.10#

New Features (26.10)#

  • New Java interface for LP, QP, QCQP, SOCP and MIP

  • New RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics for MIP

  • MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes

  • New primal heuristic for MIPs with arc-flow formulations

  • MIP solver includes new portfolio of CPUFJ heuristics with diversification

  • New compound move types in MIP CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair

  • New LNS heuristic for MIP that uses ruin-and-repair logic

  • New techniques for exploiting degeneracy in MIP

  • New implied indicator and capacity lifting presolve strengthening for fixed-charge MIP models

  • New MIP presolve: Block Bounded Value Elimination for binary problems

  • New MIP presolve: dual aggregation for binary variables with a single lock

  • New MIP presolve: exhaustive coefficient reduction for binary rows

  • New Curtis-Reid scaling for PDLP

  • New primal simplex method for LPs

  • Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides

  • The C API now exposes solver statistics as scalar solution attributes

  • New cuOptSetLogCallback for capturing solver logs in C API

  • Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time

  • The gRPC server now solves routing problems (VRP, TSP, and PDP). A Python gRPC routing client is included with cuOpt

  • A new HTTP proxy forwards requests to the gRPC server. The 26.10 container starts the proxy and gRPC server by default

Breaking Changes (26.10)#

  • The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command

  • The proxy and gRPC servers (container defaults) support routing problems of up to 5500 locations with a travel time matrix, or 8000 without one. For larger problems use the legacy HTTP server.

  • libcuopt is split into client, mathopt and routing components, with separate wheels and conda packages; libcuopt is now a thin metapackage

  • The CUOPT_DISTRIBUTED_PDLP_PARTITIONER setting introduced in 26.08 is now CUOPT_MULTIGPU_PDLP_PARTITIONER

  • The CUOPT_USE_DISTRIBUTED_PDLP setting introduced in 26.08 has been removed; use method and num_gpus instead

  • When building from source the build.sh script no longer installs libcuopt into conda env by default

Improvements (26.10)#

  • MIP heuristics improved by 3.2x on primal integral metric (geomean over the feasible MIPLIB2017 instances)

  • QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set)

  • PDLP now uses column reduction on large problems (~2x faster in geomean over LPFeas addendum instances)

  • Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations)

  • PDLP now fuses the Halpern update into the projection kernels to improve performance

  • Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex

  • LP presolve now uses less memory by freeing the transpose matrix and PSLP reduced problem

  • LPs with poor scaling are now attempted without presolve, even if PSLP declares infeasibility

  • LP presolve now uses PSLP version 0.1.0; this version includes many improvements and bug fixes

  • MIP presolve now uses iteration and work limits rather than time limits

  • Set solution callbacks now use presolve and postsolve

  • Dual simplex now perturbs the cost more aggressively and uses primal simplex to remove perturbations

  • Dual simplex now attempts to remove perturbations when variables leave the basis

  • Dual simplex now tries several initial points on problems with dual degenerate bounded variables

  • Dual simplex’s bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips

  • SOCP now use a tighter default tolerance on the duality gap without a performance regression

  • QCQP to SOCP conversion performance is improved and memory required is reduced

  • QP/SOCP presolve now eliminates free variables with zero cost

  • QP presolve now removes empty columns

  • Barrier now performs Ruiz scaling and builds the augmented system on the GPU

  • Barrier now scales QCQP/SOCP constraints by variable bounds before Ruiz equilibration

  • Barrier now performs iterative refinement on GPU when using the normal equations

  • Barrier now prints the cumulative setup time before the solve

  • Barrier termination check now has reduced GPU/host synchronization overhead

  • Barrier now has parameters to control adaptive regularization

  • Barrier now has parameters for tuning primal and dual regularization

  • Barrier now has a parameter to control bounding free variables

  • Barrier now has more initial point options

  • MIP root relaxation now honors the LP method selected

  • MIP performance improvement in duplicate cut detection

  • MIP reduced cost strengthening now stores lurking bounds based on incumbent objective value

  • MIP now includes a new Mod-2 cut separator for zero-half cuts

  • MIP random number generators are now per-worker instead of process wide; eliminating a source of nondeterminism

  • MIP time to first solution is improved by reducing overheads

  • MIP CPUFJ now has a fast-path heuristic for binary problems with integer activities

  • MIP CPUFJ now has structure-aware starts and repairs

  • Solution callback publication is now unified across solver components

  • Routing now uses cost instead of distance terminology when the objective does not represent a physical distance

  • The gRPC server now accepts a MIP starting solution

  • The gRPC server now checks GPU health and shuts down if the GPU is unusable. It also provides the standard gRPC readiness and liveness probes

Bug Fixes (26.10)#

  • Fix an issue in the C API when accessing solutions on infeasible problems

  • Fix an issue in MPS writer on problems with no linear constraints

  • Fix ranged constraint conversion and MPS writing/reading round trips

  • Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagated to Papilo

  • Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3)

  • Fix a missing header in log for multi-GPU PDLP

  • Fix an issue in multi-GPU PDLP where the solver stopped silently when asking for more GPUs than available

  • Fix an issue on the C API where performing a multi-GPU PDLP solve on a problem built from row types and RHS was not supported

  • Fix an issue on multi-GPU PDLP where project_initial_primal was ignored

  • Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished

  • Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution

  • Fix several issues in barrier related to the cuDSS threading layer

  • Fix a bug on QCQP/SOCP problems with ranged rows

  • Fix an issue in QP/SOCP presolve where removing empty columns could corrupt memory, causing heap corruption errors or cudaErrorLaunchFailure

  • Fix nondeterminism in barrier when --cudss-deterministic=1

  • Fix an issue with QPs where duality gap was not included in the termination criteria

  • Fix a buffer overflow when getting the dual solution or reduced costs of a QCQP; these requests now return an error

  • Fix an issue in QP and SOCP where a large dual residual was reported for the final solution, even at an optimal solution

  • Fix an issue in dual simplex logs where bound flips were not accounted for in objective

  • Fix an issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective

  • Fix an issue in dual simplex where dual variables and dual feasibility was not recomputed after basis repair

  • Fix MIP presolve incorrectly fixing continuous variables using integer-variable tolerance

  • Fix false optimality declaration in MIP deterministic mode

  • Fix several issues in MIP where the time limit was not respected

  • Fix an issue in MIP where flow cover cut generation was accidentally O(n^2)

  • Fix an issue in MIP where a large amount of time could elapse between logs

  • Fix an issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions

  • Fix an issue in MIP where termination was delayed during root cut passes

  • Fix an issue in MIP where the sub-MIP was not correctly stopped when the main solve finished

  • Fix an issue in MIP with halting cut passes

  • Fix an issue in MIP feasibility jump where weights were uninitialized when adding an objective cut

  • Fix an issue in MIP GF2 presolve where rank-deficient problems were incorrectly classified as infeasible

  • Fix an issue in MIP GF2 presolve where some one-sided rows were treated as equalities

  • Fix an issue in MIP presolve when performing single-lock-dual-aggregation

  • Fix an issue with tolerances in MIP mod-2 cuts

  • Fix a race condition in the asynchronous clique table generator and clique cuts

  • Fix an unsynchronized read/write of the MIP clique table

  • Fix a memory overflow in MIP when there were many feasible solutions

  • Disable clique table generation in MIP when running in deterministic mode

  • Fix an issue where the random number seed could change if multiple solves were performed within the same process

  • Fix an issue in routing: keep host sources alive for async route-view copies

  • Fix an issue in routing: avoid division by zero when vehicle capacity is zero

  • Fix an issue in routing: guard diagonal element lookup against negative offsets in top_k

  • Fix an issue in routing: uncapturable RMM copies inside CUDA graph captures

  • Fix an issue in routing: handle CUDA graph errors

  • Fix an issue where a PDLP warm start was ignored on a remote gRPC solve

  • Fix an issue where a gRPC connection could be closed during a long or idle solve because the server did not accept the client’s keepalive pings

  • Fix an issue where stopping cuopt_cli or cuopt_grpc_server did not stop the solver process

  • Fix an issue in the Python gRPC client where waiting for a remote solve blocked other Python threads

Deprecations (26.10)#

  • The container’s default server is now the HTTP proxy plus cuopt_grpc_server, in place of the legacy HTTP server. The legacy HTTP server is still shipped in 26.10 and will be removed in 26.12. See “Starting the Container” on the Legacy HTTP Server page in the 26.10 user guide for the legacy container command and for CUOPT_SERVER_TYPE=legacy in Kubernetes. That page links to the 26.08 guide. Differences are in “Deprecated Interfaces Not Provided by the Proxy Server” in the 26.10 user guide.

  • Custom gRPC clients should now send solver settings through the parameters string map; individual setting fields are deprecated

Documentation (26.10)#

  • Show mamba commands directly instead of a conda-then-swap note

  • Document the VRP gRPC client (RoutingClient)

  • Update NVIDIA Brev documentation links

New Contributors (26.10)#

  • @nvidiacbrissette (#1524)

  • @vgong-nv (#1888)

  • @Juan-Francisco-Robles (#1299)

  • @ZedingZhang (#1925)

  • @vuule (#1900)

  • @neuriv (#1947)

  • @derluke (#1775)

Release Notes 26.08#

New Features (26.08)#

  • New Multi-GPU PDLP: distribute LP solves across multiple GPUs using METIS partitioning; 2.5x–8.8x speedup on 8 NVLink-connected B200 GPUs

  • New free-format MPS parser with faster parse time on large models

  • New recursive RINS heuristic for MIP

  • New zero-half (odd-cycle) cuts for MIP

  • New vector length diving and Farkas diving heuristics for MIP

  • Routing: accept NumPy and pandas inputs in the routing Python DataModel in addition to cuDF

  • C API: extend getters with additional query functions

  • C API: automatic CPU/GPU memory selection for problem construction (supports remote solve via gRPC from CPU host)

  • gRPC: Python interface to the C++ gRPC async client

  • gRPC: allow TLS arguments in the Python gRPC async API

  • UBI10 (Red Hat Universal Base Image) container variant for FIPS 140-3 compliant environments; image tags use -ubi10 suffix (e.g. latest-cu13-ubi10)

Breaking Changes (26.08)#

  • Routing DataModel now defers GPU device construction to solve time; applications that accessed device-side data between DataModel construction and the solve call must be updated

  • Removed the deprecated get_solved_by_pdlp() method from the Python LP solution object; use get_solved_by() instead

Improvements (26.08)#

  • Include Q matrix in Ruiz scaling to improve convergence

  • Exploit sparsity in Barrier’s augmented system on problems with large second order cone constraints

  • Conflict graph improvements: incorporate non-binary rows and probing implications

  • Improve Ruiz equilibration heuristic to also check column imbalance on QPs

  • Papilo-based primal/dual crush in MIP presolve

  • Reduce host memory footprint of concurrent LP solves

  • Remove pinned host memory from the barrier solver

  • Expose diving hyperparameters for MIP solver configuration

  • Unify threading model in the MIP solver using OpenMP tasks

  • MIP log cleanup and improved readability

  • Add short cu12/cu13 Docker tag aliases

  • Remove cuda-python as an explicit dependency

  • gRPC: objective_scaling_factor is now optional in requests

  • gRPC: assign workers to distinct GPUs via cudaSetDevice

Bug Fixes (26.08)#

  • Allow zero-valued coefficient updates in the LP Python model

  • Fix an issue in PDLP with cublas error capture and hang on infeasible solutions

  • Fix bug in barrier solver where cuDSS descriptors were being freed before their backing buffers

  • Fix a bug in MIP where root cut pass CPU feasibility-jump solutions were dropped by GPU heuristics

  • Add guard in MIP for huge bounds in bounds propagation

  • Fix a bug in MIP with incorrect GF2 presolve constraint addressing

  • Fix a bug in MIP in variable fixing for initial solutions

  • Fix issue in MIP in clique size computation and numerical issues

  • Fix a bug in MIP clique cut generation where small adjacency-list cliques were skipped and complement pairs were mishandled

  • Fix an issue in MIP where cut generation did not obey the time limit

  • Fix an issue on QPs where maximization was not supported

  • Fix rotated second-order cone detection: make canonical quadratic constraint Q matrix in triplet form

  • Fix nonconvex quadratic constraint detection bug

  • Fix a bug on QCQP models that incorrectly threw an unsupported exception

  • Fix second-order cone index collision and incorrect quadratic constraint to cone conversion for rotated cone constraints

  • Validate MPS row type byte before enum cast to avoid undefined behavior

  • Fix routing min-vehicles bug

  • Fix libomp ABI incompatibility

  • gRPC: fix race condition in gRPC with log streaming

  • gRPC: cancel active jobs on delete

  • gRPC: terminate workers cleanly on server shutdown

  • gRPC: drain all remaining log lines at job completion in StreamLogs

  • Fix row-major layout not preserved when resizing routing capacity routes

  • Fix routing YAML best-results export

  • Fix import cuopt.routing failing on GPU-less hosts (CPU-only clients)

Documentation (26.08)#

  • Align cuOpt documentation branding and update Doxygen configuration

  • Update cuOpt MIP positioning documentation

New Contributors (26.08)#

  • @jolorunyomi

  • @cafzal

  • @Sylendran95

  • @jackthepunished

  • @fallintoplace

  • @arhag23

  • @divyegala

Release Notes 26.06#

New Features (26.06)#

  • Add support for quadratic constraints (convex quadratic, second-order cone, and rotated second-order cone) in the barrier solver

  • Add support for semi-continuous variables in the MIP solver

  • Add support for reading LP (.lp) files; LP files are accepted wherever MPS files were previously, including the compressed variants (.lp.gz, .lp.bz2)

  • Branch and bound workers now maintain their own heaps and steal nodes from other workers; on average, this increases the number of nodes explored by 3x given a fixed time limit

  • Add support for detecting and exploiting symmetry in MIP

  • Add support for flow cover cuts in MIP

  • Add support for detecting and exploiting discrete objective steps in MIP

  • Add support for handling free variables directly in barrier’s augmented system when a problem has a quadratic objective or constraints

  • New right-looking Markowitz LU factorization for dual simplex and crossover

  • Add setting for specifying a limit on the number of nodes explored in branch and bound

  • Add setting for disabling probing in cuOpt MIP presolve

Breaking Changes (26.06)#

  • Routing API: drop const qualifier in raft::handle_t on the data_model_view_t

  • Move libmps_parser into libcuopt and the mps_parser Python module into cuopt; the standalone libmps_parser shared library and Python module are no longer shipped. Imports should move from libmps_parser to cuopt. Refer to https://github.com/NVIDIA/cuopt/pull/1193

Improvements (26.06)#

  • Replace SpMV calls with SpMVOp calls in PDLP; 9% faster

  • Improve performance of QP solver on portfolio optimization problems

  • Improve performance of dual simplex (remove unnecessary BTran, swap coefficients for faster reduced cost calculation, trigger basis refactorization based on work limits); 16% faster on NETLIB LP, 6% faster on MIPLIB relaxations

  • Improve accuracy of dual simplex (refactor when optimal and primal residual is large with basis updates present)

  • Reduce concurrent overhead for LP solves

  • Reduce memory footprint of PDLP by around 50%

  • Unify threading model across LP (concurrent mode) and MIP to use OpenMP task model to allow stricter control of the number of threads

  • Unify Python read API on Problem for both MPS and LP file formats

  • Build and test with CUDA 13.2

  • Build against OpenSSL3 in container and wheel for gRPC

  • Substantially expand the in-repo skill set for AI coding agents (Copilot, Cline, Windsurf, Jules, Aider, Codex) covering developer onboarding, installation, numerical optimization, routing, and the server; add NVIDIA-signed skill cards, evaluation datasets, and a skill-evolution workflow under skills/

Bug Fixes (26.06)#

  • Fix a bug in MIP where the probing cache did not correctly update the model after each batch

  • Fix a bug in MIP where loose tolerances in the objective function could lead to incorrect integrality detection

  • Fix a bug in MIP where branch and bound nodes could be lost when a plunge exits early due to LP solve limits

  • Fix a bug in MIP where the lower bound could be incorrect when using a single thread

  • Fix a bug in LP/QP where dual variables and reduced costs could be incorrect when applying implied bounds to free variables

  • Fix an issue in crossover where adding slack variables to a rank-deficient basis was accidentally O(rows^2)

Deprecated APIs (26.06)#

  • Python API: readMPS is deprecated

  • C API: cuOptCreateQuadraticProblem and cuOptCreateQuadraticRangedProblem is deprecated

  • LP batch mode is deprecated

Documentation (26.06)#

  • Refresh the contributor guide (CONTRIBUTING.md) with conda-environment recommendations and clarified test-suite scope

  • Update the MIP scaling guide

  • Migrate the support link to GitHub Discussions and tidy broken doc links

New Contributors (26.06)#

  • @np96

  • @srib

  • @yuwenchen95

  • @Bubullzz

  • @aycsi

Release Notes 26.04#

New Features (26.04)#

  • Run no-relaxation heuristics before presolve

  • Add new MIP cuts: clique cuts and implied bounds cuts

  • Add support for FP32 and mixed precision in PDLP

  • Add option for using Batch PDLP in reliability branching

  • Add UnboundedOrInfeasible termination status

  • Expose settings for tuning heuristics

  • Add support for Python 3.14

  • Add support for writing presolved model to a file

  • gRPC based remote execution support on Python, C and CLI interface for LP/QP and MIP

Breaking Changes (26.04)#

  • The solved_by_pdlp field in the Python LP solution object was changed to solved_by

  • Drop support for Python 3.10

Improvements (26.04)#

  • Improve reliability branching by better ranking of unreliable variables

  • Generate more MIR and Knapsack cuts

  • Improve aggregation and complementation in MIR cuts

  • Use variable lower and variable upper bounds in MIR cuts

  • Improve numerics of mixed integer Gomory cuts

  • Lift knapsack cuts

  • Improve row and objective scaling for MIP

  • Use objective function integrality when pruning node

  • Reduce time for Markowitz factorization in dual simplex

  • Reduce time for dual push inside crossover

  • Reduce number of free variables in barrier

  • Add gap information to primal heuristics logs when root relaxation is still solving

  • Refactoring agentic skills to follow standard skill structure and add developer skills

  • Adding skill to evolve skills

Bug Fixes (26.04)#

  • Fix a bug in LP/MIP where cuOpt reported incorrect termination status; we now correctly report UnboundedOrInfeasible

  • Fix a bug in MIP where Papilo’s probing presolver crashed; fix will be pushed upstream

  • Fix a bug in MIP with a missing stream sync in the probing cache that was causing a crash

  • Fix a bug in MIP leading to incorrect dual bound when nodes remain in the heap

  • Fix a bug in MIP where nodes with objective less than the incumbent objective value were incorrectly fathomed

  • Fix a bug in MIP where variables could violate their bounds in Feasibility Jump on the CPU

  • Fix a bug in MIP where a race condition could occur when sharing solutions between branch and bound and heuristics

  • Fix a bug in MIP where the solver was not respecting the time limit

  • Fix a bug in MIP where the solver terminated at the end of the root relaxation solve

  • Fix a bug in QP where quadratic terms were not written out to MPS files

  • Fix a bug in MIP where cuOpt was taking a long time to terminate after optimal solution found

  • Fix a bug in LP/barrier on problems containing variables with infinite lower bounds

  • Fix a bug in MIP where batch PDLP for strong branching was running on the problem without cuts

  • Fix a bug in Python API when using x + x*x, +x, -x expressions

  • Update to the latest version of PSLP which includes bug fixes for incorrect infeasible classification

Documentation (26.04)#

  • Update docs to clarify the usage of getIncumbentValues() in the Python API

Release Notes 26.02#

New Features (26.02)#

  • New parallel reliability branching inside MIP solver

  • Mixed Integer Gomory, Mixed Integer Rounding, Knapsack and Strong Chvatal Gomory cuts are now added at root node

  • Added an option to use batch PDLP when running strong branching at the root. Based on Batched First-Order Methods for Parallel LP Solving in MIP (Nicolas Blin, Stefano Gualandi, Christopher Maes, Andrea Lodi, Bartolomeo Stellato)

  • Quadratic programming (QP) solver is now generally available (previously beta)

  • New infeasibility detection option for PDLP’s default solver mode Stable3

  • Solutions callbacks added to C API. Users can now retrieve the dual bound and pass in user data

  • Multiple new diving techniques added for finding integer feasible solutions

  • The PSLP presolver is enabled by default for LP problems. Use the presolve option to select Papilo or disable

  • Added a batch solve for routing to boost throughput for many similar instances

  • Added experimental support for determinism in the parallel branch-and-bound solver. GPU heuristics are not supported yet in this mode

Breaking Changes (26.02)#

  • The signatures of the solution callbacks have changed for the Python API

  • To use PDLP warm start, presolve must now be explicitly disabled by setting CUOPT_PRESOLVE=0. Previously, presolve was disabled automatically

Improvements (26.02)#

  • Improved primal/dual warm start for PDLP’s default solver mode Stable3

  • Quadratic objectives can now be constructed via a matrix in Python API

  • QP barrier now updates and solves augmented system on the GPU

  • Improved performance for LP folding

  • Probing implications and better variable ordering to strengthen presolve and branching

  • Replace deprecated cuDF Column/Buffer APIs with pylibcudf and public cuDF interfaces

  • Modernize dependency pinnings; make CUDA runtime linkage static for portability

  • Build/tooling: add --split-compile, --jobserver, Clang host build, ThreadSanitizer, improved container scripts, and branch/commit metadata in images

  • Use explicit cudaStream_t with cub::DeviceTransform and non-blocking streams for GPU control

  • Enable barrier LP tests, add regression testing, and add SonarQube static analysis

  • Added parameter for specifying the random seed used by the solver

Bug Fixes (26.02)#

  • Fixed an issue with incorrect signs of dual variables and reduced costs on maximization problems

  • Fix out-of-bounds in dense-column detection in barrier

  • Correct infeasible-list handling to avoid incorrect infeasibility reports in dual simplex

  • Fix race conditions found via Clang host build + ThreadSanitizer

  • Resolve CUDA–Numba version mismatches with cuDF

  • Fix device code to include required trailing return types

  • Fix issue in crossover after dualization in barrier

  • Repair container build and test failures

  • Miscellaneous additional fixes and stability improvements

Documentation (26.02)#

  • Update README and top-level docs for current build and usage

  • Document new repository branching strategies and release-cycle details in README and CONTRIBUTING

  • Add best practices for batch solving

Release Notes 25.12#

New Features (25.12)#

  • New quadratic programming solver using the barrier method (currently in beta).

  • Support for quadratic objectives added to the C and Python modeling APIs.

  • LP concurrent mode now supports multiple GPUs. PDLP and barrier can now be run on separate GPUs.

  • MIP root relaxation solves now use concurrent mode: PDLP, barrier, and dual simplex.

Improvements (25.12)#

  • RINS heuristic adds a new improvement strategy in the MIP solver.

  • Basis factorizations are now reused in the branch and bound tree.

  • Improvement in propagating bounds from parent to child nodes in the branch and bound tree.

  • GMRES with Cholesky/LDL preconditioning is now used for iterative refinement on QPs.

  • Improved numerical stability of dual simplex when the basis is ill-conditioned.

  • Improved robustness in barrier and PDLP: fixed cuSPARSE related leaks and added RAII-style wrappers for cuSPARSE structures.

  • Papilo-based presolve carries over implied integer information from reductions, improving consistency of integrality handling.

  • Build and CI workflows improved through assertion-default changes, better handling of git-hash rebuilds, and fixes to the nightly build matrix.

  • Reduced package sizes by adjusting build outputs and test-only library linkage, and the TSP dataset download logic disables unneeded downloads.

Bug Fixes (25.12)#

  • A crash in the incumbent test is resolved.

  • Fixed memory leaks in Barrier and PDLP’s cuSPARSE usage.

  • The explored nodes in the MIP log now correctly reflects the actual nodes examined.

  • A compilation issue in the solve_MIP benchmarking executable is fixed, restoring benchmark builds.

  • A logger bug when log_to_console is false is fixed.

  • Routing fixes improve TSP behavior when order locations are set.

  • Nightly container testing and CI handling fix issues in the nightly container test suite and build jobs.

  • A cuDF build_column deprecation issue fixed to keep compatibility with newer cuDF versions.

Documentation (25.12)#

  • Missing parameters added to the documentation for LP and MIP.

  • Release notes added to the main repository for easy access.

  • Examples in the documentation improved.

  • The openapi spec for the service showed the ‘status’ value for LP/MIP results as an int but it is actually a string.

Release Notes 25.10#

New Features (25.10)#

  • New barrier method for solving LPs. Uses cuDSS for sparse Cholesky / LDT.

  • Concurrent mode for LPs now uses PDLP, dual simplex, and barrier

  • New PDLP solver mode Stable3.

  • MIP presolve using Papilo (enabled by default). LP presolve using Papilo (optional).

  • Parallel branch and bound on the CPU: multiple best-first search and diving threads

Breaking Changes (25.10)#

  • New PDLP Solver mode Stable3 is the default

Improvements (25.10)#

  • Add setting “CUOPT_BARRIER_DUAL_INITIAL_POINT” to change the dual initial point used by barrier

  • CPUFJ for local search + simple rounding

  • FP as a local search

  • Sub-MIP recombiner and B&B global variable changes

  • Implement GF(2) presolve reduction

  • Implement node presolve

  • CUDA 13/12.9 support

  • Build and test with CUDA 13.0.0

  • Add read/write MPS and relaxation to python API

  • Decompression for .mps.gz and .mps.bz2 files

  • Enable parallelism for root node presolve

  • Enable singleton stuffing and use Papilo default params

  • Make infeasibility checks consistent between the main solver and presolver

  • Add maximization support for root node presolve

  • Performance improvement in dual simplex’s right-looking LU factorization

  • Fix high GPU memory usage

  • Print cuOpt version / machine info before solving

  • cuopt-server: update dependencies (drop httpx, add psutil)

  • Add nightly testing of cuOpt jump interface

  • Compression tests are not run when compression is disabled

  • Add sanitizer build option- Heuristic Improvements: balance between generation and improvement heuristics

  • Loosen presolve tolerance and update timers to report cumulative presolve/solve time

  • Warn in case a dependent library is not found in libcuopt load

  • Combined variable bounds

  • Add Commit Sha to container for reference

  • use GCC 14, consolidate dependency groups, update pre-commit hooks

  • Add support for nightly cuopt-examples notebook testing

  • Reduce hard-coded version usage in repo

  • Container to work on all different users including root

  • Changes to download LP and MIP datasets, and also disable cvxpy testing for 3.10

  • Faster engine compile time

  • Fix pre-commit for trailing whitespace and end of file

  • Merge update version and fix version format bugs

  • This library now supports the QPS format, which is an extension of the standard MPS format for representing quadratic programming problems.

Bug Fixes (25.10)#

  • Fix variables out of bounds caused by CPUFJ LP scratch thread

  • Fix the maybe-uninitialized compilation error

  • Fix linking errors in the test suite when disabling C adaptor

  • Compute relative gap with respect to user objectives

  • Add http timeout values for general, send, and receive to client

  • Fix bug in fixed_problem_computation

  • Remove limiting_resource_adaptor leftover

  • Add support for cuda13 container and fix cuda13 lib issues in wheel

  • Return Infeasible if the user problem contains crossing bounds

  • Fix out-of-bound access in clean_up_infeasibilities

  • Empty columns with infinite bounds are not removed

Documentation (25.10)#

  • Add tutorial video links to Decompression

  • Add warmstart, model update, update docs

  • add docs on CI workflow inputs

  • Add name to drop-down for video link

  • Add video link to the docs and to the Readme

  • Add documentation on nightly installation commands

  • Fix version in version tab, change log, and fix typos

  • Doc update for container version update, and add nvidia-cuda-runtime as a dependency

Release Notes 25.08#

New Features (25.08)#

  • Added Python API for LP and MIP (#223)

Breaking Changes (25.08)#

  • Fixed versioning for nightly and release package (#175)

Improvements (25.08)#

  • New heuristic improvements (#178)

  • Add helm chart for cuOpt service (#224)

  • Add nightly container support (#180)

  • Adding deb package support as a beta feature (#190)

  • Use cusparsespmv_preprocess() now that Raft implements it (#120)

  • Create a bash script to run MPS files in parallel (#87)

  • Several fixes needed to compile cuOpt with LLVM (#121)

  • Small fixes for corner cases (#130)

  • Small improvements on how paths are handled in tests (#129)

  • Update cxxopts to v3.3.1 (#128)

  • Bump actions/checkout in nightly.yaml to v4 (#230)

  • Remove CUDA 11 specific changes from repo (#222)

  • Heuristic improvements with solution hash, MAB and simplex root solution (#216)

  • Various typos in comments and strings, note on result dir (#200)

  • Split very large tests into smaller individual test cases (#152)

  • Fix compile error when using clang with C++20 (#145)

  • Relax pinnings on several dependencies, remove nvidia channel (#125)

  • Fix compile error when building with clang (#119)

  • cuOpt service add healthcheck for / (#114)

  • refactor(shellcheck): fix all remaining shellcheck errors/warnings (#99)

  • Add CTK 12.9 fatbin flags to maintain existing binary sizes (#58)

Bug Fixes (25.08)#

  • Fixed a segfault on bnatt500 due to small mu leading to inf/nan (#254)

  • Fixed a bug in basis repair. Recover from numerical issues in primal update (#249)

  • Unset NDEBUG in cmake in assert mode (#248)

  • Manual cuda graph creation in load balanced bounds presolve (#242)

  • Fixed bug on initial solution size in the check and cuda set device order (#226)

  • Disable cuda graph in batched PDLP (#225)

  • Fix logging levels format with timestamps (#201)

  • Fix bug in scaling of dual slacks and sign of dual variables for >= constraints (#191)

  • Fix inversion crossover bug with PDP and prize collection (#179)

  • Fix a bug in extract_best_per_route kernel (#156)

  • Fix several bugs appeared in unit testing of JuMP interface (#149)

  • Fix incorrect reported solving time (#131)

  • Fix max offset (#113)

  • Fix batch graph capture issue caused by pinned memory allocator (#110)

  • Fix bug in optimization_problem_solution_t::copy_from (#109)

  • Fix issue when problem has an empty problem in PDLP (#107)

  • Fix crash on models with variables but no constraints (#105)

  • Fix inversion of constraint bounds in conditional bounds presolve (#75)

  • Fix data initialization in create depot node for max travel time feature (#74)

Documentation (25.08)#

  • Added more pre-commit checks to ensure coding standards (#213)

  • Mention GAMS and GAMSPy in third-party modeling languages page in documentation (#206)

  • Enable doc build workflow and build script for PR and Nightly (#203)

  • Fix the link to Python docs in README (#118)

  • Add link checker for doc build and test (#229)

Release Notes 25.05#

New Features (25.05)#

  • Added concurrent mode that runs PDLP and Dual Simplex together

  • Added crossover from PDLP to Dual Simplex

  • Added a C API for LP and MIP

  • PDLP: Faster iterations and new more robust default PDLPSolverMode Stable2

  • Added support for writing out mps file containing user problem. Useful for debugging

Breaking Changes (25.05)#

  • NoTermination is now a NumericalError

  • Split cuOpt as libcuopt and cuopt wheel

Improvements (25.05)#

  • Hook up MIP Gap parameters and add info about number of nodes explored and simplex iterations

  • FJ bug fixes, tests and improvements

  • Allow no time limit in MIP

  • Refactor routing

  • Probing cache optimization

  • Diversity improvements for routing

  • Enable more compile warnings and faster compile by bypassing rapids fetch

  • Constraint prop based on load balanced bounds update

  • Logger file handling and bug fixes on MIP

  • Add shellcheck to pre-commit and fix warnings

Bug Fixes (25.05)#

  • In the solution, termination_status should be cast to correct enum.

  • Fixed a bug using vehicle IDs in construct feasible solution algorithm.

  • FP recombiner probing bug fix.

  • Fix concurrent LP crashes.

  • Fix print relative dual residual.

  • Handle empty problems gracefully.

  • Improve breaks to allow dimensions at arbitrary places in the route.

  • Free var elimination with a substitute variable for each free variable.

  • Fixed race condition when resetting vehicle IDs in heterogenous mode.

  • cuOpt self-hosted client, some MIPs do not have all fields in lp_stats.

  • Fixed RAPIDS logger usage.

  • Handle LP state more cleanly, per solution.

  • Fixed routing solver intermittent failures.

  • Gracefully exit when the problem is infeasible after presolve.

  • Fixed bug on dual resizing.

  • Fix occasional incorrect solution bound on maximization problems

  • Fix inversion of constraint bounds in conditional bounds presolve

  • Pdlp fix batch cuda graph

  • Fix obj constant on max. Fix undefined memory access at root

  • Allow long client version in service version check, this fixes the issue in case version is of the format 25.05.00.dev0

Documentation (25.05)#

  • Restructure documentation to accommodate new APIs