Marl is a high-performance, hybrid thread/fiber task scheduler library written in C++11. It provides a flexible and fluent API for scheduling asynchronous tasks across a configurable number of worker threads, while using fibers (cooperative lightweight threads) to allow tasks to block and yield without stalling hardware threads. The library includes a rich set of synchronization primitives (Event, WaitGroup, Ticket, ConditionVariable, mutex, and DAG for declarative task graphs). It emphasizes safe capture-by-value semantics for primitives to avoid dangling references. The implementation is platform-agnostic with hand-optimized assembly fiber context switching for x86/x64, ARM, RISC-V, LoongArch, MIPS64, and PowerPC64, plus Windows fibers and Emscripten support. The project includes extensive unit tests and benchmarks, a pluggable memory allocator interface, and a tracked allocator for debugging. It is designed as a library to be embedded into larger C++ applications that require fine-grained concurrency control. The codebase demonstrates strong engineering craftsmanship: clean separation of concerns, excellent use of C++ features, Thread Safety Analysis annotations, and thorough testing. Key reusable components include the custom containers (small-buffer optimized vector and efficient list), the pool abstraction (bounded and unbounded), and the flexible allocator framework.
This repository is a comprehensive C++ library and suite of command-line tools for mesh processing research, originally developed by Hugues Hoppe at Microsoft Research. It implements algorithms from several SIGGRAPH papers (1992–2003), including surface reconstruction from unorganized points, mesh optimization, progressive meshes, view-dependent refinement, subdivision surface fitting, spherical parameterization, and gradient-domain video looping. The core library, libHh, provides a rich set of reusable data structures (e.g., fixed-size vectors, D-dimensional grids, half-edge meshes, progressive mesh representations) and algorithms (spatial search, least-squares solvers, multigrid, image filtering, parallel patterns). The tools are designed as stream-oriented filters that read from stdin and write to stdout, enabling Unix-style pipelines for complex processing workflows. An interactive OpenGL viewer (G3dOGL) supports real-time rendering with level-of-detail and geomorph transitions. The build system supports multiple platforms (Windows, Linux, macOS via Cygwin/MinGW) using GNU make and Visual Studio, with optional dependencies on libpng, libjpeg, and ffmpeg for media I/O. The codebase is well-tested with a comprehensive suite of unit and integration tests, and includes numerous demo scripts that reproduce published research results.
ModSecurity v3 (libmodsecurity) is a C++17 Web Application Firewall (WAF) rule engine that parses SecLang configuration and rules, then evaluates them against HTTP transaction data. It is a library rather than a standalone server: connectors such as nginx or IIS feed requests through Transaction phase methods (processConnection, processURI, processRequestHeaders, processRequestBody, processResponseHeaders, processResponseBody, processLogging). The engine resolves ModSecurity variables (ARGS, REQUEST_HEADERS, FILES, TX, etc.), applies transformation pipelines (base64Decode, urlDecode, normalisePath, removeComments, htmlEntityDecode), evaluates operators (rx, pm, ipMatch, detectSQLi/detectXSS via libinjection, verifyCC, geoLookup), and executes actions (deny, allow, redirect, setvar, ctl:*). It supports multipart/JSON/XML/urlencoded request body parsing, audit logging through serial/parallel/HTTPS writers, and persistent collections on LMDB or in-memory backends. The code is organized around plugin-style base classes and factory instantiation for actions, operators, transformations, and variables, with a Bison/Flex generated parser for the SecLang grammar. Although the repository contains a rich JSON-based regression-test corpus, its character is overwhelmingly an application/library, not a data-research project. Architecture is modular but carries legacy baggage: autotools build system, extensive #ifdef feature gates (CURL, LMDB, Lua, libxml2, GeoIP/MaxMind, ssdeep, PCRE/PCRE2), manual memory management, and some stubbed operators. Duplicated CI workflows and long-standing TODOs indicate medium technical drift, but the project remains actively maintained and is a solid, widely deployed security library with several genuinely reusable low-level components.
libspatialaudio is a C++ library for immersive spatial audio rendering, implementing Higher Order Ambisonics (HOA) up to 3rd order, object-based audio, direct speakers, and binaural output. It follows the ITU-R BS.2127-1 Audio Definition Model (ADM) and AOM IAMF specifications. The library is used in production media players like VLC for 360° video and virtual reality audio. The architecture is modular: a central `Renderer` class orchestrates per-processing blocks for encoding, decoding, rotation, zoom, binauralization, and metadata-driven panning. The codebase is cross-platform (CMake/Meson) and includes unit tests, but some components (e.g., HRTF data, psychoacoustic filters) rely on precomputed data generated by Octave scripts. While not bleeding-edge, the library is solid, well-documented, and suitable for real-time audio applications.
The GoPro CineForm SDK is a production-grade, wavelet-based video codec library (SMPTE VC-5 super-set) implementing the full CineForm compression pipeline: recursive spatial/temporal wavelet transforms, quantization with rate control, run-length + Huffman entropy coding, and tag/value bitstream framing. It exposes a layered architecture: a C core codec engine (Codec/), high-level EncoderSDK (with asynchronous encoder pools) and DecoderSDK (with thumbnail fast-paths and output format negotiation), plus supporting libraries for color space conversion and scaling (ConvertLib/), geometric mesh warping for GoPro lens correction (WarpLib/), and an Active Metadata engine handling 3D LUTs, CDL color corrections, and timecode. Both encoder and decoder C APIs (CFHD_OpenEncoder/CFHD_EncodeSample, CFHD_OpenDecoder/CFHD_DecodeSample) are the primary integration points, with TestCFHD and WaveletDemo as example tools. The codec is cross-platform (Windows, macOS, Linux) and built with CMake, with a GitHub Actions CI workflow. The codebase is mature and battle-tested in commercial video production, with heavy SIMD (MMX/SSE2) hand-optimization in the wavelet and color conversion paths. However, it carries significant technical debt: large monolithic translation units (e.g., ImageScaler.cpp, DemoasicFrames.cpp with thousands of lines), extensive #ifdef platform conditionals, large blocks of disabled #if 0 code, hardcoded debug paths, and dated SIMD (Pentium 3 MMX) that underutilizes modern AVX-512 hardware. Several latent bugs exist (e.g., a copy-paste index error in ScaleB64ARow), and the FSM/Huffman entropy tables (Common/table17.inc, table18.inc) are checked-in generated artifacts that may silently drift from their generator. Overall it is a strong, working codec with cleanly separable infrastructure components, but the surrounding code style shows its commercial origins and accumulated debt.