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.

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.