PySCIPOpt is a Python interface to the SCIP optimization solver, providing a comprehensive modeling environment for linear, mixed-integer, nonlinear, and constraint programming. The library wraps SCIP's C API through Cython, allowing users to formulate optimization problems using Python objects (variables, constraints, expressions) and to solve them with SCIP's state-of-the-art algorithms. The core architecture revolves around the `Model` class, which exposes all solver functionality, and a suite of plugin base classes (branching rules, heuristics, separators, constraint handlers, etc.) that enable users to customize the solution process. The expression system (`Expr`, `GenExpr`, `MatrixExpr`) supports algebraic formulation with operator overloading, while the recipes subpackage provides higher-level modeling helpers for common tasks such as piecewise linear constraints, infeasibility diagnosis, and convergence tracking. The repository is actively maintained and closely tracks SCIP releases, but also explicitly seeks new maintainers to sustain long-term development.
NVIDIA cuOpt is a GPU-accelerated optimization solver library covering linear programming (LP), mixed-integer programming (MIP), quadratic programming (QP), second-order cone programming (SOCP), and vehicle routing problems (VRP, PDP, TSP). The codebase is predominantly an application: it provides multiple deployment forms—a C++ shared library, Python bindings (Cython), a Java JNI interface, a CLI tool (`cuopt_cli`), a gRPC server for remote solves, and a FastAPI-based HTTP server (`cuopt_server`). It also includes comprehensive CI/CD pipelines, benchmarks, and documentation. However, it exhibits a hybrid nature due to its strong research character: advanced algorithmic innovations (e.g., primal-dual hybrid gradient with adaptive step sizing, novel MIP presolve techniques, lattice propagation, deterministic parallel branch-and-bound, SIMD-accelerated MPS parsing, and diversity-based routing heuristics) are deeply embedded in the core solvers. The system is architected as a layered monolith: common utilities and linear algebra form the base, solver-specific modules (PDLP, dual simplex, barrier, branch-and-bound, routing heuristics) sit above, and language bindings and server endpoints wrap the C++ core. Key data flows include parsing MPS/LP files or building problems programmatically, dispatching to the appropriate GPU solver, and retrieving solutions via C structs, Python objects, or protobuf messages. External dependencies include CUDA, cuSPARSE, RMM, NCCL, gRPC, Protobuf, and optionally PaPILO for presolve. The repository is actively maintained with frequent commits and nightly CI, though the presence of deprecated modules and experimental features indicates moderate technical drift.
COIN-OR CLP is a production-grade linear programming (LP) solver library written in C++. It serves as the LP engine within the COIN-OR optimization ecosystem, consumed by CBC (branch-and-cut MIP framework) and integrating with external applications via the OSI (Open Solver Interface) standard adapter. The code (not the README) shows three complementary solution pathways: primal simplex, dual simplex (both with pluggable pivot rules — Dantzig, steepest edge, Devex, positive edge), and an interior-point barrier method with pluggable Cholesky backends (native dense/sparse, MUMPS, Pardiso, WSMP, CHOLMOD). It also implements a sophisticated modular presolve system (CoinPresolveAction stack), crash heuristics (Idiot, Sprint), a network-simplex specialization with tree-based basis factorization, and dynamic column generation for GUB-structured problems via ClpGubDynamicMatrix. The architecture is genuinely component-based: abstract base classes for matrix representation (ClpMatrixBase), pivot selection (ClpPrimalColumnPivot/ClpDualRowPivot), and factorization (ClpFactorization, CoinAbcTypeFactorization) allow users to substitute custom implementations. Entry points include the ClpSimplex C++ API, a C interface (Clp_C_Interface.h), a standalone executable (ClpMain.cpp), and the OsiClpSolverInterface wrapper. However, the codebase carries substantial research lineage and technical debt. An accelerated 'ABC' (FasterCoin) simplex variant coexists with the standard Clp implementation as largely parallel code paths, ~dozens of compile-time macros gate experimental features, and significant historical code dates to 2002 IBM contributions with mixed vintage updates through 2026. Heavy conditional compilation (Cilk, pthreads, AVX2, external Cholesky libraries), manual memory management, dead '#if 0' blocks, and duplicated pricing/factorization logic (Clp vs Abc) make the code difficult to maintain and test comprehensively. Despite this, the core algorithms are numerically careful and battle-tested at industrial scale, with active CI (Linux/Windows), release automation, and a maintained unit test suite. This is a library you'd embed, not fork — the craftsmanship is in the algorithmic component interfaces (pivot selection, factorization, matrix abstraction) rather than in the overall code cleanliness.
This repository is the COIN-OR Branch and Cut (Cbc) solver, a mature, production-grade mixed-integer linear programming (MIP) solver written in C++. The core engine implements branch-and-cut using LP relaxations, cut generation (via Cgl library), branching rules, and heuristics. The architecture is object-oriented with well-defined abstractions for branching objects, heuristics, cut generators, node selection, and tree management. Key entry points include the CbcModel class for programmatic use, the CbcMain0/CbcMain1 functions for command-line execution, and a comprehensive C API (Cbc_C_Interface.h) for embedding in other languages. The codebase is large (hundreds of source files) and includes numerous specialized heuristics (dive variants, RINS, DINS, feasibility pump, local search, etc.), branching strategies (pseudo-cost, SOS, clique, N-way, orbital), and preprocessing techniques. It integrates with the broader COIN-OR ecosystem (Clp, Osi, CoinUtils, Cgl) and supports parallel execution via threads. Despite its age, the code shows active development with recent additions (conflict graph features, branching ranker, configurable dive heuristics) and a new output framework. However, it carries legacy artifacts: autotools build system, an Attic/ directory with deprecated code, extensive conditional compilation (#ifdef blocks), and some experimental or unfinished features.