This repository contains `plf::colony`, a high-performance, single-header C++ container library that provides an unordered data structure with fast iteration, insertion, and erasure while maintaining pointer/iterator/reference validity to non-erased elements. It is implemented as a template class in `plf_colony.h`, supported by `plf_tools.h` which provides compiler feature detection macros, utility functions, and allocator-aware helpers. The container uses a novel skipfield-based memory management technique (low-complexity jump-counting pattern) to achieve O(1) amortized insertion and erasure, and O(n) iteration with minimal overhead. It supports C++98 through C++23, with extensive compile-time feature detection and conditional compilation. The codebase is exceptionally well-crafted, demonstrating advanced template metaprogramming, low-level memory optimization, and careful handling of allocator traits, exception safety, and trivial type optimizations. The test suite (`plf_colony_test_suite.cpp`) is comprehensive, covering correctness, edge cases, fuzz testing, and exception recovery. The repository is a standalone library intended for reuse in any C++ project requiring a flexible, high-performance container with stable iterators.
PROJ is a generic coordinate transformation library that converts coordinates between different coordinate reference systems (CRS). It includes a comprehensive catalog of map projections (over 190), datum shifts (grid-based, Helmert, TIN), and time-dependent deformation models. The library provides both a C API and a C++ ISO19111-compliant object model, along with command-line tools (proj, cs2cs, cct, projinfo, geod, gie, projsync). The architecture is a core transformation engine that dispatches through function pointers, with a pipeline system for chaining operations. The library relies on a bundled SQLite database (proj.db) containing EPSG definitions, and supports grid files for high-accuracy transformations. It is heavily used in geospatial software (e.g., GDAL, QGIS) and compiles on Linux, macOS, Windows, and WebAssembly through Emscripten.
mockturtle is a header-only C++17 library for logic network synthesis and optimization. It provides a generic framework for multiple logic network representations (AIG, MIG, XAG, XMG, k-LUT, etc.) and a wide range of algorithms including cut enumeration, rewriting, balancing, resubstitution, decomposition, technology mapping, and equivalence checking. The library uses template metaprogramming and static polymorphism to achieve flexibility and performance, with a decorator pattern for views that add functionality (depth, fanout, mapping) without modifying base networks. Bundled external libraries (kitty, lorina, percy, bill) handle truth tables, file parsing, exact synthesis, and SAT solving. The codebase is well-tested (Catch2) and includes experimental research flows for emerging technologies like AQFP superconducting logic.
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.
Partio is a C++ library and toolkit for particle input/output and manipulation, primarily used in visual effects and simulation pipelines. It provides an abstraction layer for particle data (position, velocity, ID, etc.) with support for multiple file formats (BGEO, GEO, PDC, PDB, etc.) through a plugin-based I/O system. The repository includes core library code, command-line tools (partconvert, partinfo, partview), a Qt-based GUI editor (partedit.py), Python bindings via SWIG, and test suites. The architecture separates core data structures, format-specific handlers, and utilities like caching and KD-trees, enabling both direct library use and standalone tools for data inspection and conversion.