Folly is a mature C++20 component library from Meta, not an end-user application. It provides high-performance primitives for systems programming: containers (F14 hash maps, small_vector, sorted_vector_types), string and JSON handling, concurrency (MPMCQueue, AtomicHashMap, Synchronized), async I/O (EventBase, AsyncSocket, AsyncServerSocket, SSLContext, io_uring integration), multiple async programming models (futures, fibers, coroutines), logging, settings, memory allocation, debugging/symbolization, hashing, compression, and statistics. Consumers embed the library via CMake or Buck2 and link libfolly; there is no standalone service or primary CLI except tools, tests, and examples. Internally, the architecture is strongly modular and header-first: most components are templates in header files with optional .cpp implementations, heavily gated on platform feature macros. Data flows are data-structure and callback oriented: events from sockets/timers are dispatched through EventBase, async results move through Future/SemiFuture/coro::Task continuations, fibers perform cooperative context switches, and the logging framework routes formatted log messages through configurable handlers. External dependencies include Boost, OpenSSL, libevent, fmt, zstd/lz4/zlib, and googletest for testing; the repo includes a dependency builder (getdeps.py) and CI for Linux/macOS/Windows. Folly is actively maintained with frequent commits, broad CI, and extensive test/benchmark suites. Some parts are experimental (folly::result, channels), but core components are production-tested. Technical drift is low: it tracks modern C++, supports current compilers and kernels, and adapts to new CPU features (AVX-512, SVE2, io_uring). A small internal Python-based agent backtesting kit exists under folly/agents/, but it is peripheral; the dominant character of the repository is a high-performance C++ library.
Proxygen is a production-grade C++ HTTP library developed by Meta, providing comprehensive support for HTTP/1.1, HTTP/2, HTTP/3 (QUIC), and WebTransport. It offers both a classic callback-based server/client framework and a modern coroutine-based API using folly::coro. The architecture is layered: low-level codecs for wire protocol parsing, session management with flow control and rate limiting, transport abstraction (TCP, TLS, QUIC), and high-level handler/filter chains. The library includes extensive utilities for DNS resolution, consistent hashing, stream compression, structured headers, and connection pooling. It is heavily tested and designed for high-performance, multi-threaded production environments. While primarily a server framework, it also provides a full client stack and sample applications (echo, proxy, push, WebSocket, H3). The codebase is well-structured with many reusable components, though it remains tightly coupled to Meta's ecosystem (folly, wangle, fizz, mvfst).
Lagrange is a comprehensive C++ geometry processing library focused on 3D mesh manipulation, analysis, and visualization. It provides a robust core mesh data structure (SurfaceMesh) with extensive algorithms for mesh processing including subdivision, simplification, cleaning, remeshing, and parameterization. The library features specialized modules for geodesic computation, texture processing, volume conversion, boolean operations, and more, along with UI/viewer components for interactive visualization and Python bindings for scripting. Built with a modular architecture using modern C++ template metaprogramming, it emphasizes algorithmic correctness through exact predicates and supports multiple mesh formats via Assimp integration.
JsonCpp is a C++ library for parsing, manipulating, and generating JSON data. It distinguishes itself by preserving comments during both parsing and serialization, making it suitable for configuration files and user-editable JSON where comments are important. The library is designed for stability and reliability, prioritizing security and compatibility over performance or new features, and maintains support for pre-C++11 toolchains. The architecture is that of a classic C++ library, providing header-only or separately compiled components. The core is the `Json::Value` class, which acts as a discriminated union for JSON types and includes iterator support for traversing objects and arrays. Configuration of parsing and writing behavior is handled via the builder pattern (`StreamWriterBuilder`, `CharReaderBuilder`) and feature toggles (`Json::Features`). The library minimizes external dependencies, relying only on the C++ standard library, and provides amalgamation scripts for easy integration. Key entry points include the main header `include/json/json.h` which aggregates the core components, and the library is built from source in `src/lib_json/`. Data flows involve parsing JSON input (from strings or streams) into a `Json::Value` DOM tree, manipulating the tree as needed, and serializing it back to JSON output. The library is actively maintained, with a focus on long-term stability and security, and exhibits low technical drift due to its intentional avoidance of unnecessary changes.
SocketIOClient-Unreal is a Socket.IO client plugin for Unreal Engine that enables real-time bidirectional communication between Unreal applications and Socket.IO servers. The plugin features a modular architecture with separate modules for core client functionality (SocketIOClient), low-level Socket.IO implementation (SocketIOLib), JSON handling (SIOJson), and utility functions (CoreUtility). It provides both Blueprint-accessible components (USocketIOClientComponent) and native C++ interfaces (FSocketIONative) for flexible integration. The plugin handles connection management, event emission/reception, namespaces, rooms, and includes sophisticated JSON-UStruct conversion utilities with Blueprint compatibility.
This repository is a curated list (awesome list) of C++ frameworks, libraries, resources, and tools. It is not a software application or data pipeline; it is a reference document (primarily README.md) that organizes hundreds of links to external C++ projects by category (e.g., AI, Audio, CLI, Compression, Concurrency, Database, GUI, Machine Learning, Networking, etc.). The repository also includes supplementary files (books.md, videos.md) and a contribution guide. There is no executable code, no build system, and no data processing logic. The value lies in the curation and organization of the C++ ecosystem for developers seeking libraries or tools.
Fazen2d is a C++ library for creating 2D graphics and handling input in the Windows console. It provides geometric primitives (points, lines, boxes, circles, text), a rendering system with double buffering to prevent flicker, input handlers for keyboard and mouse, and utility classes for timing and color management. The architecture is modular, with clear separation between rendering, geometry, input, and state management. The main entry point is in main.cpp, which demonstrates a simple animation loop. The library relies solely on the Windows API and C++ standard library.
The C++ REST SDK (cpprestsdk) is a cross-platform, asynchronous C++ library for building cloud-based client-server applications. It provides a comprehensive set of APIs for HTTP client and server communication, JSON parsing and serialization, URI manipulation, WebSocket client support, OAuth 1.0 and 2.0 authentication, and asynchronous stream I/O. The library is built on a custom task-based concurrency model (PPLX) that abstracts platform-specific threading and synchronization, enabling portable async operations across Windows, Linux, macOS, iOS, and Android. The architecture is modular: HTTP client and server implementations use a pipeline stage pattern for middleware (e.g., compression, authentication), and the stream buffer abstraction decouples data sources from I/O operations. The codebase includes extensive functional tests using a bundled UnitTest++ framework, along with sample applications demonstrating real-world usage (BlackJack game, OAuth flows, file search). However, the repository is officially archived and no longer maintained; it exhibits significant technical drift, including deprecated APIs, platform-specific conditional compilation, and dependencies on older library versions (Boost, OpenSSL). Despite this, many components—such as the PPLX task system, URI builder, JSON value, and stream buffers—are well-crafted and could be extracted for reuse in new projects with minimal adaptation.