This repository contains the source code and assets for ActionRoguelike, a roguelike action game built with Unreal Engine 5. The game features procedural enemy spawning, a variety of player actions (such as dashing, magic projectiles, and parrying), and performance-optimized systems for managing actors and significance. The codebase is organized into modular subsystems, including AI, action systems, core game mechanics, player controls, and UI. The architecture follows Unreal Engine best practices, with clear separation of concerns. Notable reusable systems include a custom action system that allows developers to define and manage player abilities, and an actor pooling subsystem that optimizes performance by reusing instances of frequently spawned objects. The project also implements a save system for persisting game state and a significance system to prioritize updates for important actors. While the project is tailored to a specific roguelike game, several of its systems are designed with reusability in mind. The ActionSystem and Performance modules, in particular, could be extracted and adapted for use in other Unreal Engine projects with minimal modification. The recent commit activity indicates active maintenance, and the use of a recent Unreal Engine version suggests low technical drift. Overall, the codebase demonstrates solid engineering practices and provides a foundation for learning and building similar action-oriented games in Unreal Engine.
fre:ac is a mature, cross-platform audio converter and CD ripper with a plugin-based component architecture. The system is built on the BoCA framework and smooth GUI library, providing both a graphical interface (freacGUI) and a command-line interface (freaccmd). In production it handles audio format conversion (MP3, AAC, FLAC, Opus, WMA, etc.), CD ripping with freedb/CDDB metadata lookup, AccurateRip verification, tag editing, and even YouTube/Vimeo video downloading via JavaScript-based site scripts. The codebase is extensive (906 files) with heavy use of the BoCA component system for decoders, encoders, DSP processors, verifiers, and extensions. Key entry points are src/loader/gui.cpp and src/loader/console.cpp. The architecture follows a job-based conversion pipeline with worker threads, progress reporting, and configuration persistence. Internationalization is comprehensive (40+ languages). While the code demonstrates solid engineering with signal/slot decoupling and reusable components, it carries technical debt from legacy V8 API usage, manual memory management, and platform-specific #ifdefs.
This repository provides **NEC2++**, a from-scratch C++ implementation of the Numerical Electromagnetics Code (NEC-2), a well-known Method of Moments (MoM) solver for wire and patch antenna simulation. The code is distributed as a standalone command-line tool (`nec2++`), a shared library (`libnecpp`) with a stable C API, and Python bindings (separate repository `python-necpp`). It reads standard NEC-2 input files (`.nec`) and produces output files with radiation patterns, impedances, near fields, and structure currents. The library is designed for embedding into optimization systems and GUI applications, supporting large models with tens of thousands of segments. Architecturally, the simulation is driven by a `nec_context` class that orchestrates geometry construction (via `c_geometry`), matrix assembly using Eigen's dense linear algebra, network solving, and result extraction. Input parsing uses an ANTLR 4 grammar to handle the free-format NEC card syntax, with a table-driven handler dispatch replacing a large switch statement. The ground model includes Sommerfeld/Norton integrals, implemented in both C (direct Fortran translation) and C++ wrappers. The codebase is well-tested, with a comprehensive test harness comparing outputs against the original Fortran NEC-2 and a C port (`nec2c`), plus unit tests using Catch2. The repository is actively maintained (last commit in 2026, recent PRs fixing bugs and adding features), uses C++17, and bundles a known version of Eigen (v3.4) for linear algebra, avoiding external BLAS/LAPACK dependencies. While the code has some legacy C sections and occasional commented-out dead code, the overall architecture is clean and extensible. Notable reusable components include the ANTLR grammar for parsing structured free-form input, the wire intersection algorithm in `nec_wire.h`, and the ground parameter abstraction in `nec_ground.h`.
RVO2-3D is a C++ library implementing Optimal Reciprocal Collision Avoidance (ORCA) for multi-agent simulation in three-dimensional workspaces. It provides a simulator that manages agents with configurable parameters (radius, max speed, time horizon, etc.) and computes collision-free velocities each time step using a linear programming approach over ORCA half-planes. The library uses a k-d tree for efficient neighbor queries and optionally leverages OpenMP for parallel agent updates. The public API is exposed through the RVOSimulator class, with supporting types Vector3 and Plane. The codebase is written in C++98 for maximum compatibility, is thoroughly documented with Doxygen, and includes a single example (Sphere) that serves as both a demonstration and a test. The repository is well-maintained with CI across multiple platforms and build systems (CMake, Bazel), static analysis, and a quality declaration targeting ROS 2 Quality Level 2.
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.
redis-plus-plus is a production-grade C++ Redis client library built on hiredis, providing synchronous, asynchronous (libuv), and experimental coroutine (C++20) APIs. It covers the full Redis command surface including strings, hashes, lists, sets, sorted sets, streams, geospatial, hyperloglog, pub/sub, scripting, transactions, pipelines, and server commands. The architecture separates low-level connection management (connection pools, shard pools for clusters, sentinel discovery) from high-level facade classes (Redis, RedisCluster, AsyncRedis, AsyncRedisCluster, QueuedRedis for pipelined/transactional usage). Key entry points include the main sync header `redis++.h`, async header `async_redis++.h`, and coroutine header `co_redis++.h`. Data flows involve constructing Redis commands via `CmdArgs` and `cmd_formatter.h`, sending them through `Connection` objects (optionally pooled), and parsing replies with `reply.h`. The library depends on hiredis for raw Redis protocol, libuv for async I/O, and optionally Boost or OpenSSL for advanced features. It includes a comprehensive test suite covering all commands, multi-threading, cluster, sentinel, and distributed locking patterns (Redlock).
This repository provides a cross-platform C++ tokenizer binding library that wraps HuggingFace tokenizers (via Rust), SentencePiece, and a custom RWKV world tokenizer. It exposes a common abstract interface (`Tokenizer`) with factory methods to create instances from in-memory blobs (JSON, SentencePiece model, BPE vocab/merges, RWKV model). The architecture is a static library with a C FFI layer (`tokenizers_c.h`) and a C++ wrapper (`tokenizers_cpp.h`). The Rust component (`rust/src/lib.rs`) implements the C bindings for the HuggingFace tokenizers crate, while the C++ source files (`src/`) provide implementations for SentencePiece and RWKV. The project also includes a JavaScript/WebAssembly binding via Emscripten (`web/`). Key entry points are the factory functions in `tokenizers_cpp.h` and the `example/example.cc` demonstrating usage. External dependencies include the `tokenizers` Rust crate (v0.21.2), `sentencepiece`, `msgpack-c`, and for the web build, Emscripten. The codebase is well-structured, with clean abstractions and support for multiple platforms (iOS, Android, Windows, Linux, Web).
pyGIMLi is a mature open-source geophysical modelling and inversion library, implemented as a C++ core with Python bindings. It provides mesh generation, finite-element solvers, data containers, and high-level manager classes for methods such as electrical resistivity tomography (ERT), vertical electrical sounding (VES), frequency-domain electromagnetics (FDEM), magnetics, gravity, traveltime, and spectral induced polarization. The library is not a GUI application; it is a programmatic toolkit with Python entry points, example scripts, and a console-app pattern in some managers.
Galera is a synchronous multi-master replication middleware for transactional databases, primarily MySQL and MariaDB, implemented as a wsrep provider shared library (libgalera_smm.so). The codebase provides total-order multicast group communication via a layered protocol stack (GCS/gcomm), conflict detection through certification of write-sets, incremental state transfer (IST) with a multi-tier cache (gcache), and an arbitrator daemon (garbd) for quorum maintenance. Architecturally, it is structured as a set of cooperating C++ libraries: galerautils (memory allocators, configuration, threading, hashing), gcs (group communication service with membership and flow control), gcomm (transport abstraction with EVS/PC/GMCast protocols), galera (replication engine with certification and write-set handling), and gcache (write-set caching in memory, ring buffer, and memory-mapped pages). The code is well-tested with unit tests (Check framework), regression tests, and integration test scripts. While the core replication logic and utility libraries are well-crafted and modular, the project bundles an older version of the ASIO networking library and retains C++03 compatibility shims, contributing to moderate technical drift. The repository is actively maintained with regular commits and issue triage.
lib3mf is a production-grade C++ library that implements the 3D Manufacturing Format (3MF) standard, providing read, write, validation, and conversion capabilities for 3MF files. It supports the full 3MF specification including mesh objects, beam lattices, textures, materials, colors, slice stacks, volumetric data, implicit modeling via computation node graphs, and encryption (key store, AES-GCM, RSA-OAEP). The library is cross-platform (Windows, Linux, macOS) and exposes a C++ API with auto-generated bindings for Java, Python, C#, Go, and NodeJS via the Automatic Component Toolkit (ACT). Architecture is layered: platform abstraction (streams, XML readers/writers), OPC (Open Packaging Conventions) ZIP-based package handling, version-specific XML readers/writers (v093, v100, extensions), in-memory model classes, and a public API wrapper. Key entry points are CModelReader_3MF_Native for reading and CModelWriter_3MF for writing. External dependencies include libzip (ZIP), zlib (compression), libressl (encryption), fast_float (float parsing), and cpp-base64. The codebase is well-structured with extensive use of design patterns (factory, decorator, iterator, reader node hierarchy) and includes a comprehensive test suite using Google Test.
Conky is a free, lightweight system monitor for X11, Wayland, and macOS that displays system information on the desktop or in alternative output modes (console, file, HTTP). It collects data from /proc, /sys, sysctl, and various APIs to report CPU, memory, disk, network, processes, sensors, audio players, mail, RSS, and more. The architecture is modular: data sources are registered as text objects with scan/print/free callbacks, output backends are selected at runtime (X11, Wayland, ncurses, console, file, HTTP), and Lua scripting provides configuration and extensibility via tolua++ generated bindings. A callback system handles periodic data fetching with deduplication and thread safety, and a priority queue supports top process sorting. The codebase is written in C++ with some C, uses CMake build system, and includes a comprehensive test suite using Catch2. It supports Linux, BSDs, Haiku, Solaris, and macOS with platform-specific backends. The project demonstrates several well-crafted reusable components: a generic priority queue, a callback system for periodic tasks, a typed configuration settings framework with Lua integration, a structured logging wrapper around spdlog, and a macro-generated X11 event variant pattern. These components exhibit non-obvious skill and can be extracted for use in other C++ projects. However, the codebase also shows signs of technical drift with bundled third-party libraries (Vc, tolua++, spdlog) that may lag behind upstream, and some platform-specific backends have incomplete implementations.
Kaitai Struct is an umbrella project that provides a declarative language for describing binary data structures and a compiler to generate parser code in multiple target languages. The repository coordinates submodules for the compiler, runtimes for various languages (Java, Python, Ruby, etc.), format definitions, visualizer, tests, benchmarks, and documentation. Users describe a format in a .ksy file, compile it with the kaitai-struct-compiler to generate language-specific parser code, and use the corresponding runtime to parse binary data. The project includes CI workflows for building the compiler and publishing artifacts, and maintains a collection of ready-to-use format descriptions.
Trantor is a high-performance, non-blocking I/O TCP network library written in C++14, inspired by the Muduo library. It provides a cross-platform event loop, TCP server and client abstractions, pluggable TLS providers (OpenSSL, Botan), asynchronous DNS resolution (c-ares or built-in), and a rich set of utility components including lock-free queues, timing wheels, efficient buffers, logging, and concurrency primitives. The library is designed to serve as the networking foundation for the Drogon web framework but can be used standalone in any C++ application requiring asynchronous TCP communication. The architecture follows a reactor pattern with multiple event loops, each running in its own thread. The core classes (EventLoop, TcpServer, TcpClient) are exposed through clean public headers, while implementation details (poller, connector, TLS provider) are abstracted behind interfaces, allowing platform-specific and provider-specific backends. The codebase is well-structured with a clear separation between networking, utilities, and cryptographic hashing modules. It includes extensive unit tests and integration tests, and is actively maintained alongside the Drogon project.
vlc-bittorrent is a VLC media player plugin that enables direct streaming of .torrent files and magnet links. It integrates libtorrent-rasterbar to handle the BitTorrent protocol, providing three VLC submodules: a stream_directory module to list torrent contents as a virtual directory, a stream_extractor module to stream individual files with on-demand piece downloading and priority-based piece selection, and an access module to resolve magnet URIs by downloading metadata from peers. The plugin manages a single libtorrent session shared across multiple torrents, handles asynchronous alerts via a dedicated thread, and supports interruptible I/O compatible with VLC's blocking read model. It includes a comprehensive test suite with TAP output and deterministic expected results.
Dublin Traceroute is a NAT-aware multipath traceroute tool that extends the Paris-traceroute technique to enumerate ECMP load-balanced paths and detect NATs. It forges UDP packets with custom payloads to control the UDP checksum, which is used as a per-flow identifier and embedded in the IP ID field for NAT correlation. The system listens for ICMP Time Exceeded and Destination Unreachable responses, matches them to sent probes using IP ID (IPv4) or payload length (IPv6), and computes a NAT ID from checksum differences. Output is provided in JSON or DOT format for visualization. The repository contains two independent implementations: a primary C++ library/CLI using libtins and jsoncpp, and an experimental Go implementation with IPv6 support and additional tooling (routest for integration testing). The Go implementation demonstrates cleaner separation of concerns with reusable network protocol modules (ICMP, UDP, IPv6) and a layered protocol abstraction.
Cocos Creator engine runtime is a cross-platform 2D/3D game engine framework written in TypeScript and C++. It provides a component-entity architecture with scene graph, rendering pipelines (forward/deferred/custom), physics (PhysX, Bullet, Box2D, builtin), animation (marionette state machine, pose graph, Spine, DragonBones), audio, UI, particle systems, and asset management. The engine is designed to be used with the Cocos Creator editor but can run standalone. It abstracts platform-specific APIs (graphics, input, audio, system) behind a common interface, supporting Web, iOS, Android, Windows, macOS, Linux, and various mini-game platforms. Key entry points include the Director, Scene, Node, Component, and the rendering pipeline. External dependencies include graphics APIs (Vulkan, Metal, GLES, WebGPU), physics libraries (PhysX, Bullet, Box2D), and scripting engines (V8, SpiderMonkey, JavaScriptCore).
simplewall is a native Windows desktop application that functions as a personal firewall using the Windows Filtering Platform (WFP). It controls per-application network access via user-defined rules and blocklists, including built-in Microsoft spy/telemetry lists. The application provides a full GUI with tabs for applications, services, UWP packages, rules, network connections, and logs, along with a tray icon, notification popups, and a rule editor. It logs allowed/blocked connections to a CSV file and supports real-time network monitoring via TCP/UDP statistics (including ETW-based UDP accounting). Profiles are stored in XML format with optional compression and AES encryption, and filters can be installed permanently, temporarily, or at boot time. The architecture is a monolithic C/C++ Win32 application with a custom utility library ("routine") as a submodule. Key modules handle WFP filter lifecycle, WFP net event subscription, network connection enumeration, security descriptor management, and UI controls (listview, search bar, notifications). The code demonstrates deep Windows internals knowledge, including WFP version-specific callbacks, ETW session management, cryptographic hashing, and digital signature verification. While the application is actively maintained (latest beta v3.9.1 as of July 2026), it is tightly coupled to Windows APIs and contains workarounds for historical Microsoft bugs, leading to moderate technical drift risk. Strengths include comprehensive WFP integration, robust logging, and a well-organized codebase with reusable patterns for WFP security (ACL management) and ETW-based UDP monitoring. Weaknesses include reliance on a private library submodule, hardcoded service/port lookup tables, and Windows version-specific branches that may need adjustment for future releases. The project is suitable for developers seeking a reference implementation for WFP firewall development or a reliable Windows filtering tool.
This is a full-stack SaaS application for cron job monitoring (cron-job.org). It consists of a React frontend (Material-UI, Redux, i18n), a PHP REST API, a C++ execution daemon named 'Chronos', a WAF validator, and a public status page SPA. The system uses Apache Thrift for inter-service RPC, MySQL for job definitions and user data, per-user SQLite databases for historical execution logs, and Redis for rate limiting. The Chronos daemon implements an efficient async HTTP executor using libcurl, libev, and c-ares, with Prometheus metrics exposure. The codebase is production-grade with features like MFA (TOTP/Yubico), API keys, subscription billing (Stripe/Paddle), status pages with custom domains, and comprehensive i18n. However, it shows signs of technical drift: the frontend uses the deprecated Material-UI v4, password hashing is weak (SHA1+MD5), and the Thrift auto-generated code is fragile. The architecture is well-documented and the core execution engine is highly optimized, but the overall codebase would benefit from modernization of the frontend and authentication layers.
Fityk is a cross-platform scientific data fitting program focused on nonlinear curve fitting, particularly peak fitting in spectroscopy and crystallography. It provides a core library (libfityk) with multiple fitting algorithms (Levenberg-Marquardt, MPFIT, Nelder-Mead, Genetic Algorithm, NLopt), a rich set of built-in peak functions (Gaussian, Lorentzian, Voigt, Pearson VII, etc.), symbolic derivatives via AST, and a bytecode VM for expression evaluation. The architecture is modular: a core library, a CLI with readline and gnuplot integration, a wxWidgets GUI, and scripting support via Lua and SWIG bindings for Python, Perl, Ruby, and Java. Key entry points include the Fityk class API, the command parser (cparser.cpp), the runner (runner.cpp), and the GUI main frame (frame.cpp). Data flows involve loading data from files (via xylib), defining models as sums of functions, fitting using least-squares optimization, and outputting parameters and statistics. External dependencies include wxWidgets, Boost, Lua, NLopt, xylib, readline, gnuplot, zlib, and SWIG. The codebase is well-structured with extensive documentation and tests, though it shows some age with pre-C++11 idioms and platform-specific workarounds.
This repository provides a reusable, interactive node editor library built on top of Dear ImGui. It is a pure C++ library with a public API that enables embedding a visual node/graph editor into any ImGui-based application. The core implementation handles node and link creation, dragging, selection, zoom/pan, context menus, cut/copy/paste, flow animations, and state serialization via a bundled JSON library. It is not a standalone application but ships with several examples and an application framework (Win32/DirectX11, GLFW/OpenGL) to demonstrate usage. The architecture is modular, with separate components for canvas rendering, bezier math, and JSON serialization, making individual parts reusable in other projects. The repository is well-maintained with active issue triage and recent commits, though it has medium technical drift due to heavy version-conditional code for Dear ImGui compatibility and reliance on some outdated dependencies (DirectX SDK, older stb versions).