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).
Heimer is a cross-platform desktop mind map editor built with Qt (C++17). It provides a graphical interface for creating, editing, and organizing mind maps with features like adjustable grid, automatic layout optimization, undo/redo, copy/paste, image embedding, and export to PNG/SVG. The architecture follows a layered design: domain layer (Graph, MindMapData, LayoutOptimizer), application layer (services, state machine, settings proxy), view layer (Qt widgets, QGraphicsScene/View, dialogs), and infrastructure layer (file I/O, XML serialization). Key entry points include main.cpp, Application class, MainWindow, EditorView, and EditorService. Data flows from user interactions through EditorView to EditorService, which manipulates the MindMapData (graph) and triggers serialization via AlzFileIO. External dependencies are limited to Qt (5 or 6) and two bundled small libraries (SimpleLogger for logging, Argengine for CLI argument parsing). The layout optimizer uses simulated annealing to arrange nodes, and undo/redo is implemented via snapshot-based state capture. The codebase demonstrates solid engineering practices with unit tests, CI/CD pipelines, and multi-language support.
QElectroTech is a mature, open-source desktop CAD application for creating electrical schematics and diagrams. Built on Qt (C++) with a rich graphics view framework, it provides full interactive editing for folios, conductors, terminals, element symbols, title blocks, and terminal strips. The system manages project files via XML, supports auto-numbering of elements and conductors, cross-referencing, bill-of-materials export, and imports EPLAN EDZ archives using bundled LZMA decompression. It is purely a desktop application with no server or data-pipeline components, offering a comprehensive set of features for electrical documentation in industrial and domestic contexts. The architecture follows a monolithic desktop GUI pattern with extensive use of Qt's model/view and graphics view frameworks. Key entry points include the main window (QETMainWindow), diagram editor (QETDiagramEditor), element editor, and terminal strip editor. The codebase demonstrates strong use of the undo/redo command pattern (QUndoCommand), a generic QPropertyUndoCommand, and a custom DXF paint engine. The project has a large number of interdependent modules but maintains reasonable separation through abstract base classes (PropertiesInterface, DiagramEventInterface). The code is professionally written with moderate complexity and a clear focus on functional CAD features rather than framework novelty.
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.
Fritzing is an open-source electronic design automation (EDA) tool focused on maker and educational use. It provides three interconnected views (breadboard, schematic, PCB) for circuit design, with features including component placement, wiring, autorouting, ngspice simulation, microcontroller code editing/upload (Arduino, PICAXE), and export to Gerber, PDF, SVG, and other formats. The application is built as a monolithic Qt/C++ desktop app with a modular internal architecture: model layer (ModelPart, ModelBase), view layer (SketchWidget subclasses), command pattern for undo/redo, and dedicated subsystems for parts management, SVG rendering, and design rule checking. It relies on external libraries such as Boost (graph algorithms), Clipper (polygon operations), QuaZip (ZIP handling), libgit2 (parts repository updates), and ngspice (simulation). The codebase is actively maintained with ongoing Qt6 migration, though some legacy patterns and workarounds remain.
QMarkdownTextEdit is a mature C++ Qt library providing a feature-rich markdown text editor widget, QMarkdownTextEdit, which extends QPlainTextEdit with live markdown syntax highlighting, code block syntax highlighting (for dozens of languages via a large hand-curated keyword dataset), line numbers with bookmark indicators, block (rectangular) selection, clickable links, and an integrated search/replace widget. The library is designed to be embedded into larger Qt applications such as QOwnNotes, Notes, and CuteMarkEd-NG. It supports both widget-based (QWidget) and Qt Quick (QML) integration through a registered QML type. The architecture is a single-library module with optional demo and QML example applications. The core components include the main editor widget, the markdown highlighter (which can be used independently on any QTextDocument), a separate search/replace widget (QPlainTextEditSearchWidget), and a line number area (LineNumberArea). The language-specific syntax highlighting data is generated in a single massive C++ file (qownlanguagedata.cpp) using a consistent pattern of init/load functions grouped by language. The library is built and installed via qmake (.pro/.pri) and CMake, with continuous integration across multiple Qt versions (5.9 to 6.10) on Linux, macOS, and Windows. The codebase is well-organized and demonstrates solid engineering practices: clear separation of concerns (highlighter, search widget, editor), support for internationalization (translation files for German, Spanish, Urdu, Chinese), and compatibility with both widget and QML interfaces. While the library is primarily a UI component, it also includes utility patterns like debounced search and regex support. The main risk is the maintenance burden of the enormous hand-curated syntax data file, which contains some minor errors and duplicates, and the lack of automated tests for the highlighting logic. Overall, this is a practical, production-grade text editor component with broad applicability in Qt projects requiring markdown or code editing capabilities.
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.
KWIVER is a large C++/Python computer vision and video analytics toolkit. Its architecture is a plugin-driven algorithm library (vital/algo), a dataflow pipeline framework (sprokit), and many backend implementations (arrows) that wrap OpenCV, VXL, Ceres, FFmpeg, GDAL, VTK, and other dependencies. In production it performs video/image I/O, feature detection and matching, structure-from-motion, object detection/tracking, geospatial metadata parsing, and serialization. It exposes command-line applets, an embedded pipeline API, Qt-based viewers, and pybind11 Python bindings. The system is configuration-driven: algorithms and processes are registered through macros, configured via vital::config_block, and instantiated dynamically through a plugin registry. The sprokit subsystem provides a pipeline DSL, schedulers, process clusters, and adapter ports for external data injection, making the project both a reusable library and a runtime pipeline environment. Although dominated by application/library code, the repository also serves research and defense-oriented use cases. It contains extensive MISB/KLV metadata parsers for multiple standards, multi-view geometry algorithms, track-file format readers/writers (kw18, KPF, XGTF, etc.), and PyTorch-based feature extractors. The hybrid nature is visible in the tension between production-grade pipeline infrastructure and research-oriented algorithms that remain experimental or under-documented. The codebase is actively maintained with recent commits and substantial CI infrastructure, but technical drift is medium due to the enormous optional dependency footprint, vendored copies of cereal/rapidjson/DBoW2, legacy modules such as track_oracle, and some deprecated APIs.
PythonQt is a dynamic Python binding library for the Qt framework, focused on embedding CPython into C++ Qt applications. The runtime in src/ exposes Qt objects to Python through custom Python type objects, signal/slot bridging, automatic type conversion, property access, and ownership transfer. Key entry points are PythonQt::init(), the PythonQt_QtAll extension, PythonQtObjectPtr, and the PythonQtScriptingConsole widget. The project is a library and code-generation toolchain rather than a standalone application; it contains no data pipelines or research components. The repository also ships a complete binding generator under generator/, which parses Qt C++ headers with a custom lexer/parser/simplecpp preprocessor pipeline, applies type-system XML rules, and emits wrapper code. Pre-generated bindings for Qt 5.15 are checked in under generated_cpp_515/, following a consistent Shell/PublicPromoter/Wrapper pattern that enables Python subclassing of Qt classes and exposure of protected methods. The project includes numerous examples and a functional test suite, and CI workflows exercise builds against multiple Qt versions including Qt 6.x. The codebase is professionally maintained but carries significant legacy from the Nokia Qt Script Generator lineage. The custom C++ parser has known limitations, the generated code is voluminous and tied to specific Qt versions, and many modules use extensive #if QT_VERSION branches. Overall it is a competent, specialized binding framework with a few genuinely reusable building blocks, but it is not a modern, lightweight codebase.
Apollo is a self-hosted game streaming server, forked from Sunshine and rebranded for compatibility with Artemis (formerly Moonlight Noir) clients. In production, it captures the host's display (via DXGI, KMS, Wayland, or NvFBC), encodes video using hardware encoders (NVENC, AMD AMF, Intel QSV, VAAPI, VideoToolbox) and audio (Opus), then streams over the network using a combination of RTSP for session control and ENet for real-time transport. It also forwards keyboard, mouse, gamepad, and pen input back to the host, enabling low-latency remote gaming or desktop control. The architecture is a single-process C++ application with a multi-threaded design: separate threads for video capture, encoding, audio capture, network I/O, and control. It exposes a web-based configuration UI (Vue.js frontend served by an embedded HTTPS server) and implements the NVIDIA GameStream HTTPS API for client pairing and session management. Platform-specific code is isolated behind abstraction interfaces (e.g., platf::display_t, platf::input_t), with dedicated implementations for Windows, Linux, and macOS. External dependencies include Boost, FFmpeg, OpenSSL, ENet, and vendor-specific SDKs (NVENC, AMF, VAAPI, etc.). The codebase demonstrates solid engineering with a clear separation of concerns, a comprehensive build system (CMake with platform macros), and a growing test suite (Google Test). However, it carries technical debt from its forked nature—some code still references 'Sunshine' while branding leans toward 'Apollo'—and there are incomplete features on macOS (e.g., placeholder functions for clipboard) and fragile workarounds for driver bugs. Overall, it is a functional, well-maintained application with reusable patterns for inter-thread communication, resource management, and platform abstraction.
hMailServer is a production-grade, open-source email server for Microsoft Windows, implementing SMTP, POP3, and IMAP protocols with comprehensive anti-spam (SPF, DKIM, DMARC, DNSBL, SURBL, greylisting, SpamAssassin) and anti-virus (ClamAV, ClamWin, custom) capabilities. The server core is written in C++ using Boost.Asio for asynchronous I/O and exposes a COM automation API for administration. It is complemented by a .NET WinForms Administrator GUI, a PHP-based web admin, and a suite of database upgrade scripts supporting MySQL, MSSQL, PostgreSQL, and SQL Server Compact Edition. The architecture follows a layered pattern: business objects (e.g., Account, Domain, Rule) with a generic Collection/Persistence layer, a caching subsystem with TTL-based eviction, and a plugin-style spam test runner. Key data flows include message reception via SMTP, anti-spam scanning, local or external delivery, and optional virus scanning. External dependencies include OpenSSL, Boost, and database client libraries. The codebase is well-structured with reusable patterns but shows signs of age (manual memory management, COM, .NET Framework 4.5, PHP without modern framework).
This repository provides a header-only C++ library with Python bindings for solving partial differential equations (PDEs) using Monte Carlo methods, specifically Walk on Spheres (WoS) and Walk on Stars (WoS★) algorithms. It supports Laplace, Poisson, and screened Poisson equations with Dirichlet, Neumann, and Robin boundary conditions in 2D and 3D. The library includes variance reduction techniques (Boundary Value Caching, Reverse Walk on Stars) and handles exterior problems via the Kelvin transform. It is designed for grid-free PDE solving, relying on geometric queries (via FCPW BVH or SDF grids) rather than volume meshing. The codebase is research-oriented, with clear reference implementations and citations to foundational papers, but includes many TODO comments and incomplete optimizations. The architecture is modular with template-based dimension and value type abstraction, making it adaptable but also complex. Demo applications in C++ and Python illustrate usage on model problems with JSON configuration and image output.
AppImageLauncher is a Linux desktop integration utility for AppImage portable applications. It intercepts AppImage launches (via binfmt_misc and an LD_PRELOAD-based bypass), prompts users to move AppImages into a central applications directory, registers them with the system launcher by installing desktop files and icons, and provides context-menu actions to remove or update integrated AppImages. A background daemon watches watched directories via inotify and automatically integrates newly added AppImages and unintegrates removed ones. The project includes a main Qt GUI, a settings dialog, first-run wizard, CLI tool (`ail-cli`), daemon, and remove/update helper binaries.
QuickFIX is a production-grade FIX (Financial Information eXchange) protocol engine written in C++ with SWIG-generated bindings for Python and Ruby. It implements FIX session management (initiator/acceptor), message parsing/serialization, sequence number handling, heartbeats, resend requests, and message persistence (file, MySQL, PostgreSQL, ODBC). The library supports FIX versions 4.0 through 5.0 SP2 and FIXT 1.1, with auto-generated message classes from XML specification files. Architecturally, it is a library/framework—applications subclass the `Application` interface and use `Session::sendToTarget` to send messages. The network layer uses select()/poll()-based event loops (SocketMonitor) or threaded connections (ThreadedSocketConnection), with optional SSL/TLS support via OpenSSL. The codebase is mature and widely used in the financial trading industry, with extensive acceptance test definitions for each FIX version and language-specific unit tests. While the core abstractions (FieldMap, Session, DataDictionary) are well-designed, the repository suffers from significant code duplication across FIX versions, heavy conditional compilation, and some outdated patterns (auto_ptr, old-style platform detection). The code generation pipeline (Ruby scripts in spec/) is a notable reusable asset.
HailoRT is a production runtime SDK for Hailo AI accelerators. It provides a C/C++ library (libhailort) for loading compiled HEF models, configuring network groups, managing virtual streams (vstreams), and executing synchronous/asynchronous inference on Hailo-8/10/15 devices over PCIe, USB, or Ethernet. The repository also contains a command-line tool (hailortcli) for scanning, benchmarking, power measurement, logging, and firmware control; Python bindings (pyHailoRT); a GStreamer plugin suite (hailonet, hailosend/hailorecv, hailodevicestats); and an RPC-based client/server layer (HRPC) that allows a remote hailo service to own devices and GenAI sessions. It is a hybrid repo in the sense that it includes tutorial notebooks and algorithm modules (NMS, tracking, quantization) that resemble research code, but the dominant character is a software application/SDK. The architecture is layered: a common OS abstraction layer (files, sockets, mmap, events, threads), a VDMA/driver layer for hardware DMA and streams, a core-op/resource-manager layer for memory planning and context switching, a net-flow pipeline layer for pre/post-processing (NMS, YOLO, softmax, quantization), and high-level APIs for infer models and GenAI (LLM/VLM/speech2text). The code uses an Expected monad instead of exceptions, pimpl idioms for ABI stability, buffer pools for high-throughput transfers, and protobuf serialization for HRPC. The codebase is large and professional, with strong modularization, but also carries noticeable internal debt: many HRT-TODO markers, duplicated pipeline construction, hardcoded sysfs/tmp paths, deprecated API overloads, and partial Windows/QNX platform stubs. Maintenance is active; the repo is versioned (v5.4.0) and recently committed. Technical drift is medium because core dependencies are current and the project is clearly under active commercial development, yet some legacy/deprecated surfaces and platform-specific ifdefs remain. As a library, meaningful inference requires Hailo hardware; the build is CMake-driven with external dependencies managed via CMake scripts.
This repository is a collection of C++ sample programs for deploying deep learning models on AXERA AI SoCs (NPU chips). It provides ready-to-run inference examples for a wide range of computer vision tasks including object detection (YOLOv5/6/7/8/9/10/11/26, YOLOX, YOLO-World, PPYOLOE+, RT-DETR, SCRFD), instance segmentation, oriented object detection (OBB), pose estimation, depth estimation, semantic segmentation, stereo matching, and more. Each example is a standalone command-line executable that loads a pre-compiled .axmodel, runs inference via the AX_ENGINE API, post-processes the outputs, and saves a result image. The code is organized per target chip (ax650, ax637, ax620e, ax615) with near-identical copies of examples across platforms, differing only in system initialization and minor chip-specific logic. The architecture is not a library or framework but a set of reference implementations demonstrating the integration of AXERA's NPU SDK. The primary data flow is: load image → preprocess (letterbox resize, color conversion) → push to engine → run synchronous inference → decode model outputs (e.g., anchor-based proposals, DFL, NMS) → draw bounding boxes/keypoints/masks → save output. External dependencies include the AX_ENGINE runtime, OpenCV for image processing, and standard C++ libraries. The build system uses CMake with per-chip toolchain files and GitHub Actions CI for cross-compilation verification. While the code is functional and covers a broad model zoo, it exhibits significant duplication across chip directories and hardcoded configuration (thresholds, image sizes, class names). The monolithic detection.hpp (~3500 lines) bundles many model-specific post-processing functions, increasing maintenance burden. There are no automated tests, and manual memory management is prevalent. Despite these quality issues, the repository serves its purpose as a practical reference for developers integrating AXERA hardware, and it stays current with recent model releases (YOLOv13, YOLO26, Depth Anything V2).
pydegensac is a Python library for robust geometric estimation in computer vision, providing RANSAC-based estimation of fundamental matrices (F) and homographies (H). The core algorithms — DEGENSAC (degeneracy-aware sampling) and PROSAC (progressive sampling) — are implemented in C++ and exposed to Python via pybind11 with Eigen/numpy array interop. The primary deliverable is a pip-installable wheel (pydegensac), built for cp38–cp314 across manylinux2014, manylinux_2_28, macOS, and Windows via GitHub Actions and cibuildwheel. Entry points are the Python API (fundamental matrix and homography estimation) backed by the C++ core exposed through `bindings.cpp`. The codebase is research-grade: the C++ core uses conditional compilation flags (`__HASHING__`, `__D3__`, `__LSQ_BEFORE_LO__`), raw pointers, manual memory management, and commented-out code. Documentation is thin — `bindings.cpp` has placeholder docstrings, and usage examples live in `examples/how-to-use-detailed.ipynb` and benchmark scripts. The repo vendors a full copy of pybind11 (headers, tests, build helpers), which risks drift from upstream. Benchmark infrastructure (`benchmarks/run.py`, `benchmarks/methods.py`) compares against OpenCV RANSAC, MAGAC, Poselib, and Poselib-PROSAC on standard multi-view datasets (IMC/photo-tourism for F, EVD and HPatchesSeq for H), but requires downloading ~1.4 GB of external data from CMP, Hugging Face, and other URLs. Testing relies on golden data (`.npz` files under `tests/data/`) generated by `scripts/make_golden_data.py` from a known-good git HEAD with fixed seeds, plus the bundled pybind11 test suite. There are no unit tests for the C++ core itself. The repo is actively maintained (last commit 2026-09-18, 1 open issue) with wheels published to PyPI, though the publish workflow requires a manual trigger with a build run ID. Known issues include a PROSAC score-orientation bug (benchmark-only, indicating dataset-compatibility risk), platform-specific xfails in the bundled pybind11 tests, and compiler-specific workarounds for GCC/Clang/MSVC. Overall, this is a functional, well-packaged research library with solid CI/CD but notable technical debt: vendored pybind11, placeholder documentation, external data dependencies, and research-code cruft. It is best suited for users needing a fast, reference-quality RANSAC implementation for F/H estimation, or for researchers studying DEGENSAC/PROSAC variants. The hybrid nature is worth noting: while primarily a software library, it includes benchmark/data components (golden data, dataset downloaders, evaluation harnesses) that are integral to its testing story.
AndroidDrive is a Windows desktop application that mounts Android smartphone internal storage and SD cards as drive letters using the Dokan user-mode filesystem driver and ADB (Android Debug Bridge). It is built with Qt6 (C++20) and CMake, providing a system tray interface, device list window, and per-drive settings (drive letter, auto-mount, language, hide dot files). The application communicates with Android devices via ADB commands, caches remote files locally for read/write operations, and pushes changes back. It supports 10 languages via Qt translations and includes an update checker that queries GitHub releases. The architecture is a single-process Qt application with a Dokan callback implementation for filesystem operations. Key entry points are main.cpp (application startup), androiddrive.cpp (core mount logic), and dokanoperations.cpp (filesystem callbacks). External dependencies include Qt6, Dokan library (v2.3.1), and ADB binaries fetched from a third-party GitHub repo. The codebase is well-structured but has some hardcoded paths and is Windows-only.
This repository is a work-in-progress decompilation of The Legend of Zelda: Twilight Princess for GameCube and Wii. It reconstructs the original game's source code from its compiled binary, aiming for byte-perfect reproducibility. The codebase is a hybrid of reversed-engineered game logic, reimplemented Nintendo SDK libraries (JSystem, Dolphin, Revolution), and a massive collection of asset resource headers that define model, animation, and collision IDs for every in-game object. The architecture follows the original game's custom actor framework (f_op/f_pc) combined with middleware from JSystem and the Nintendo SDK. The project supports multiple region and platform variants (GameCube, Wii, Nvidia Shield), with resource headers duplicated across version-specific directories. The decompilation is incomplete; many source files are stubs or placeholders (marked NONMATCHING), and the asset headers are auto-generated or manually copied from the original game's data. The code is written in C++ with Metrowerks compiler conventions, and the build system uses Python and Ninja. While not a runnable application on its own (requires a copy of the game), it represents a comprehensive reverse-engineering effort with active development and community engagement.
Apache Cordova CLI is a command-line tool for creating, building, deploying, and managing Apache Cordova-based mobile applications. It serves as a thin orchestration layer over the `cordova-lib` and `cordova-create` libraries, parsing user commands and delegating to those libraries for project management, platform/plugin operations, building, and running. The architecture is straightforward: a single entry point (`bin/cordova`) invokes `src/cli.js`, which uses `nopt` for argument parsing, then dispatches to appropriate functions (e.g., `create`, `platform`, `plugin`, `build`, `run`, `info`). The codebase is mature, well-tested, and actively maintained with CI, CodeQL, and license auditing. However, the CLI is tightly coupled to the Cordova ecosystem and offers no reusable components outside that context. The implementation is solid but follows standard patterns without exceptional craftsmanship.