Wireshark is a world-class network protocol analyzer application. It captures live traffic or reads saved capture files (pcap, pcapng, etc.) and dissects them into a structured, hierarchical view of hundreds of network protocols. The application is built on a modular architecture: `libwsutil` (utilities), `libwiretap` (capture file I/O), and `libwireshark` (dissection engine). It provides a rich Qt-based graphical user interface (Wireshark) and a powerful command-line interface (TShark). Key features include a custom domain-specific language for display filtering (with its own compiler and virtual machine), a Lua scripting API for extensibility, a plugin system for protocol dissectors, and support for decrypting various protocols (TLS, IPsec, 802.11). The codebase is exceptionally well-engineered, with clean abstractions and highly reusable components like its scope-based memory manager (`wmem`) and its file format abstraction layer (`wiretap`). It is under very active maintenance and is the de-facto standard tool for network analysis.
Vicinae is a cross-platform desktop launcher and productivity tool written in modern C++20/23 with Qt6 and QML, inspired by Raycast. It provides a single keyboard-driven interface for launching applications, searching files, managing clipboard history, switching windows and workspaces, controlling media, running script commands, browsing fonts, picking emoji, and more. The system runs as a background server process with a CLI client, a file indexing subprocess, and a browser extension for tab management. It features a first-class extension system using TypeScript and Node.js, a custom fuzzy search library, an XDG desktop entry parser, encrypted clipboard storage, and deep platform integration for Linux (Wayland/X11, GNOME, KDE, Hyprland), macOS, and Windows. The architecture is modular with abstract service backends and a service registry for dependency injection.
Sioyek is a cross-platform PDF viewer optimized for reading research papers and technical books. Built with Qt, OpenGL, and MuPDF, it provides a rich set of features including multi-threaded rendering, annotation management (highlights, bookmarks, portals, freehand drawings), SyncTeX integration for LaTeX forward/inverse search, fuzzy text search, and a customizable command-driven interface. The architecture follows a modular design with a central MainWidget orchestrating UI state, a Document model for PDF handling, a PdfRenderer for threaded rendering, and a DatabaseManager for persistent annotation storage. The application supports both desktop and touch-optimized interfaces, with platform-specific code for Windows, macOS, Linux, and Android. While primarily an application, Sioyek incorporates data-oriented features such as SQLite-based annotation persistence, checksum-based document identification, and integration with external research tools (Google Scholar, arXiv). The repository also includes scripts for paper downloading, text-to-speech, and embedding annotations, as well as precomputed embedding data files (embedding.npy, linear.npy) likely used for text summarization or search enhancement. The codebase demonstrates strong engineering practices with reusable components like a fuzzy matching library (fzf), a SyncTeX parser, a type-safe configuration system, and a set of QML touch UI widgets. However, it also exhibits some technical debt in the form of global state, large monolithic files (main_widget.h), and platform-specific conditionals scattered throughout.
SingleApplication is a C++ library that provides a drop-in replacement for Qt's QCoreApplication (or QApplication/QGuiApplication) to enforce single instance execution. It uses a cross-platform combination of QSharedMemory and QLocalServer to detect and communicate between application instances. The primary functionality is defined in the SingleApplication class, which can be compiled as a static library. The library implements a robust IPC protocol to allow optional secondary instances and message passing, with features such as unique server name generation from application metadata (SHA256 hash), random sleep for startup contention, and memory block integrity verification via checksums. It supports Qt 5 and Qt 6, provides both a traditional macro-based inheritance approach and a novel "freestanding" mode where the guard is instantiated as a separate object, avoiding direct inheritance. CI tests cover build and integration on Windows, macOS, and Linux. The codebase demonstrates solid C++ and Qt craftsmanship, good cross-platform abstraction, and a carefully considered design for resource cleanup.
OBS Studio is a cross-platform live streaming and recording application. Its architecture is modular: a core library (`libobs`) provides the runtime for sources, encoders, outputs, services, and filters, all registered via a plugin system. The frontend is a Qt-based desktop GUI (`frontend/`) that manages scenes, sources, audio mixing, and output controls. Graphics rendering is abstracted across Direct3D 11, Metal, and OpenGL backends. The system ingests video/audio from capture sources (screen, window, game, camera, hardware I/O like DeckLink), processes them through filters and encoders (x264, NVENC, QSV, AMF, FFmpeg), and outputs to streaming protocols (RTMP, WHIP, SRT) or local files (FLV, MP4, MOV). External dependencies include FFmpeg, Qt, libcurl, and various hardware SDKs. The codebase demonstrates strong engineering with reusable utility libraries (dynamic arrays, strings, config files, profilers) and a well-defined plugin API, though platform-specific code and bundled third-party SDKs introduce some technical drift.
KeePassXC is a cross-platform password manager (Qt Widgets GUI plus CLI) written in C++/Qt. In production it creates, stores, and retrieves credentials in KeePass 2 (KDBX 3/4) database files encrypted with AES, ChaCha20, or Twofish and keyed by Argon2/AES-KDF through the Botan crypto library. It is entirely local-file based — no hosted backend — and adds local integrations: Auto-Type keystroke injection (X11/Wayland/Windows/macOS), YubiKey challenge-response, RFC 6238 TOTP generation, an SSH agent implementing the ssh-agent wire protocol, a FreeDesktop.org Secret Service D-Bus daemon so Linux desktop apps can read stored secrets, browser-extension access via native messaging (including passkey/WebAuthn registration and authentication), and KeeShare encrypted group sharing. The CLI (keepassxc-cli, entry point src/cli/keepassxc-cli.cpp plus src/main.cpp for the GUI) exposes the same core model for scripting: create/edit/show/search/merge databases, generate passwords, analyze HIBP breach exposure, import/export, and dump to CSV/HTML. Architecture is a modular desktop monolith: a core domain layer (src/core: Database/Entry/Group, config, clock, search, password generation, password health), a crypto layer (src/crypto: ciphers, hashes, KDFs), a stream layer (src/streams: hashed/HMAC block streams that give the KDBX format tamper-evident framing), a format layer (src/format: KDBX3/4 readers and writers, CSV parser/exporter, HTML exporter, importers for 1Password OPVault/1PUX, Bitwarden, Proton Pass, KeePass 1), and feature modules (browser, fdosecrets, sshagent, keeshare, autotype, quickunlock) that feed both GUI and CLI surfaces. Platform abstraction lives in OSUtilsBase plus per-OS AutoType/device-listener/screen-lock implementations; background work uses AsyncTask (QtConcurrent) wrappers; several plugin-like interfaces (IReportsPage, IEditGroupPage, ISettingsPage, KeyComponentWidget) allow modular extension. External dependencies: Qt 6, Botan, libsodium, zxcvbn, libusb/PCSC for YubiKey, QuaZip/minizip, and vendored ykcore C code. The test suite is extensive (~100 unit/GUI test files covering format round-trips, crypto known-answer tests, streams, merge, CLI, and browser). Notable weaknesses: heavy conditional compilation (#ifdef for KPXC_FEATURE_BROWSER/NETWORK/SSHAGENT/FDOSECRETS plus platform), near-duplicate report widgets, and a suspected early-return bug in EditGroupWidget::apply() under the browser-feature #ifdef that can skip group save logic, all of which add maintenance friction.
Fincept Terminal is a native C++20/Qt6 desktop financial intelligence platform, open-sourced under AGPL-3.0, with a proprietary Enterprise edition. It functions as a comprehensive trading, research, and analytics terminal supporting equities, options, futures, crypto, forex, and prediction markets. The architecture is a modular monolith: a single Qt Widgets process with embedded Python 3.11 for scripting, SQLite for persistence, and a DataHub pub/sub system for real-time data flows. Key entry points are the main window (WindowFrame) and screen router (DockScreenRouter), with over 100 data connectors, 20+ broker integrations, backtesting engines (QuantConnect/LEAN compatibility), AI agents (LangGraph/Agno-based), and extensive analytics (corporate finance, portfolio optimization, options pricing, economic indicators). The repository is actively maintained with a monthly release cycle, but contains a very large codebase with some boilerplate and incomplete features, making it powerful but complex to reuse partially.
OpenSCAD is a mature, script-based 3D CAD modeler. It provides a declarative language for defining solid geometry through Constructive Solid Geometry (CSG) operations, extrusions, and transformations. The application consists of a C++ core that parses the custom scripting language, builds an AST, and evaluates geometry using either the CGAL or Manifold library for boolean operations. Rendering is handled via OpenGL with both preview (OpenCSG) and final render modes. The GUI, built on Qt, includes a code editor with syntax highlighting, a 3D viewport, parameter customizer, and an integrated AI assistant for code generation. Exports to STL, OBJ, SVG, 3MF, PDF, and other formats. The codebase demonstrates strong engineering with clear module separation (core, geometry, glview, gui, io, utils), extensive regression tests, and reusable patterns such as visitors, builders, and self-contained geometry utilities.
QGroundControl (QGC) is a professional-grade, cross-platform ground control station for MAVLink-enabled unmanned aerial vehicles (UAVs), supporting both PX4 and ArduPilot autopilots. It provides full flight control, real-time telemetry monitoring, mission planning with complex survey/scan patterns, video streaming with hardware-accelerated decoding (D3D, Vulkan, DMABuf), log analysis (ULog, DataFlash), and vehicle configuration wizards. The architecture is a monolithic Qt/C++17 application with a QML-based UI, organized around a plugin system for firmware-specific features, a custom state machine framework for async workflows, and a type-safe Fact system for parameter management. It also includes extensive CI/CD infrastructure, a comprehensive test suite, and support for Android, iOS, macOS, Windows, and Linux. The repository is hybrid in that it contains documentation (vitepress), Python tooling for CI/code generation, and data-oriented log parsers, but its dominant character is a complex desktop/mobile application.
Cutelyst is a C++ web application framework built on the Qt library, designed for creating scalable web applications. It follows a MVC-inspired architecture with a strong emphasis on extensibility through a plugin system. The framework provides core components such as application bootstrapping, request/response handling, routing via dispatchers, and controller-based action definition. It supports multiple communication protocols including HTTP/1.1, HTTP/2, WebSocket, and FastCGI, allowing deployment in various server environments. The framework's architecture centers around the Application class, which manages the lifecycle and configuration of the application. Controllers, derived from the base Controller class, define application logic through methods marked with attributes that map to specific routes. The Context object serves as a central hub for request-specific data, enabling sharing of state between controllers, plugins, and views. Views handle response rendering, supporting formats such as HTML (via template engines like Cutelee), JSON, and email. A comprehensive plugin system allows for the addition of features like authentication, session management, input validation, CSRF protection, and static file serving, all adhering to a common plugin interface. Key reusable components include the validator system, which provides a base ValidatorRule class and numerous specific validators (e.g., for email, integers, URLs) that demonstrate robust input validation practices using the PIMPL idiom. The plugin architecture itself is a notable pattern, allowing developers to encapsulate cross-cutting concerns as modular extensions. The framework also utilizes Qt's meta-object system for runtime introspection of controller actions, enabling dynamic route registration. While the codebase exhibits modern C++ practices and Qt integration, it shows minor technical debt in areas such as legacy null pointer usage and direct copying of external code (e.g., HPACK implementation), requiring ongoing maintenance to stay aligned with upstream projects.
DB Browser for SQLite is a desktop GUI application written in C++/Qt for creating, browsing, editing, and querying SQLite databases. The core is a QMainWindow (src/MainWindow.cpp) with dockable table browsing, a schema tree, an SQL editor, plot dock, and many modal dialogs for table/index design, CSV/SQL/JSON import/export, encryption, preferences, and conditional formatting. SQLite is accessed through a custom DBBrowserDB wrapper (src/sqlitedb.cpp), with threaded execution via RunSql and RowLoader, and a custom flex/bison SQL parser feeds the sqlb object model (src/sql/sqlitetypes.cpp) for schema introspection and SQL generation. Data flows center on files: a user opens an SQLite database or project, schema is introspected into sqlb::Table/View/Index objects, rows are fetched asynchronously into a SqliteTableModel backed by RowCache, edits are applied with SQL savepoints, and exports stream via the SQLite C API to CSV/JSON/SQL. The SQL editor is QScintilla with a project-specific SqlUiLexer for SQLite keyword completion. The repository vendors large third-party libraries (QScintilla/Scintilla 2.14.1, QCustomPlot, QHexEdit, nlohmann/json), bundled for portability but adding maintenance overhead. Engineering quality is solid: a modular CMake build, unit tests under src/tests, GitHub Actions CI for Windows/macOS/Linux, and a clean separation between the database layer, SQL object model, Qt models, and dialogs. Several components are self-contained enough for reuse, including ObjectIdentifier, RowCache, CSVParser, and the Data helper utilities. Technical drift is medium: the bundled QScintilla is old, some Qt5-era APIs remain, and the custom parser plus checked-in generated lexer files are fragile, but the project remains actively maintained.
PrismLauncher is a sophisticated Minecraft launcher application built with C++ and Qt that enables users to manage multiple Minecraft instances, mods, resource packs, and authentication. It features a modular architecture with clear separation between core application logic, instance management, UI components, mod platform integrations, networking, task-based asynchronous operations, and settings management. The application supports launching Minecraft with custom configurations, handles Mojang/Microsoft authentication, integrates with various mod platforms (Modrinth, CurseForge/Flame, FTB, Technic), and provides extensive customization options for gameplay experience.
GammaRay is a mature runtime introspection and manipulation tool for Qt applications, not a data or research project. In production it injects a probe into a target Qt process via a launcher that supports preload, GDB/LLDB, and Windows DLL injection, then connects a Qt Widgets client either in-process or over TCP. The probe tracks QObjects, exposes their properties, signals/slots, object trees, widget hierarchies, QML scene graphs, model/view contents, state machines, network activity, and even records and replays QPainter command streams. The core machinery uses a custom client-server protocol built around Endpoint, ObjectBroker, remote models, and network-synchronized selection models, with lazy-loading proxy models on the client side. The architecture is modular: a shared protocol layer in common/, a server-side core with property adaptors, tool managers, and remote model servers, a client UI layer, and dozens of plugin-based inspectors. Each plugin follows a consistent pattern - a server-side tool, a client-side widget, and interface classes registered through the ObjectBroker. The codebase shows strong engineering discipline: consistent abstractions, extensive Qt Test based tests, CI workflows for multiple Qt versions and sanitizers, and careful handling of cross-process model synchronization. The main technical risk is heavy use of Qt private APIs (e.g., QPaintBuffer, QQuickItemPrivate, QObjectPrivate) and vendored third-party code, which creates fragility across Qt releases and platform-specific maintenance overhead. Overall this is a well-crafted, complex desktop application. It is not a general-purpose library; most of its value for reuse lies in its plugin patterns and a few isolated Qt utility components. The generic, low-coupling pieces like PropertyBinder, SearchLineController, DeferredTreeView, and UIStateManager can be lifted into other Qt projects with minimal modification.
Deskflow is a free and open-source keyboard and mouse sharing utility (software KVM without video) that allows one computer's keyboard, mouse, and trackpad to control multiple computers over a network. It uses a client-server architecture with a core process handling input forwarding and network protocol, a daemon for Windows service/UAC support, and a Qt-based GUI for configuration. The system supports TLS encryption, clipboard sharing, and multiple platforms including Windows, macOS, Linux (X11 and Wayland). It implements a custom binary protocol with version negotiation (1.0-1.8) and provides platform-specific backends for input capture and injection. The codebase is well-structured with clean abstractions, extensive unit tests, and CI/CD pipelines, though it carries some legacy code from its Synergy/Barrier origins.
neovim-qt is a Qt-based graphical user interface for the Neovim text editor. It provides a full-featured GUI frontend that communicates with Neovim via the msgpack-RPC protocol, supporting all standard editing operations, multiple windows, tabs, popup menus, scrollbars, and a file tree view. The application is cross-platform (Windows, macOS, Linux) and integrates deeply with Neovim's extended UI features, including external popup menus, tablines, and grid-based rendering. The architecture is modular: the core library (neovim-qt) handles RPC communication via MsgpackIODevice and NeovimConnector, while the GUI layer (neovim-qt-gui) provides the main window, shell widget, input handling, and UI extensions. The ShellWidget is a standalone, reusable Qt widget that renders a terminal-like grid of cells with full color, font attributes, cursor blinking, and ligature support. Input events are converted to Neovim's key notation through platform-specific modules. The application also includes a VimL plugin (nvim_gui_shim.vim) that exposes GUI commands like GuiFont, GuiTabline, and GuiScrollBar. Key entry points include main.cpp (application startup), App class (command-line parsing and window management), MainWindow (orchestrates shell, tabline, scrollbar, treeview), and Shell (manages Neovim attachment and redraw notifications). External dependencies are Qt6, msgpack-c, and Neovim itself. The build system uses CMake with support for various package managers and CI pipelines (GitHub Actions, CircleCI, Azure Pipelines).
Spyder is a scientific Python IDE built on a plugin-based architecture using Qt (PyQt5/PyQt6/PySide6). It provides a multi-language code editor with Language Server Protocol (LSP) integration for completions, diagnostics, and formatting, an IPython/Jupyter console with custom kernel management, a variable explorer for inspecting NumPy/Pandas objects, a debugger, profiler, and a help system that renders documentation with MathJax for mathematical notation. The main entry point is `spyder.app.start:main`, which initializes the main window and loads plugins discovered via setuptools entry points under the `spyder.plugins` group. Each plugin (e.g., Editor, IPythonConsole, VariableExplorer) is a self-contained module with its own configuration page, container widget, and status bar integration. External dependencies include `spyder-kernels` (custom Jupyter kernels), `python-lsp-server` (LSP backend), `qtconsole` (Qt-based console widget), and `spyder-remote-services` (remote kernel execution via JupyterHub). Data flows: user edits code in the editor, which communicates with the LSP server for completions and diagnostics; running code sends it to the IPython kernel, which executes and returns results displayed in the console and variable explorer. The architecture is a monolith with a formal plugin API that supports lifecycle hooks, dependency management, and configuration observers.
This repository implements an OBS Studio plugin that enables simultaneous streaming to multiple RTMP servers. The plugin adds a dockable widget to OBS where users can configure independent streaming targets, each with its own encoder settings, scene selection, resolution, and audio tracks. The architecture follows the OBS plugin template with a CMake-based build system supporting Windows, macOS, Linux, and Flatpak. Key entry points are the module load function in `obs-multi-rtmp.cpp` which registers the dock widget and event callbacks, and the push widget (`push-widget.cpp`) that manages output lifecycle. Configuration is persisted as JSON in the OBS profile directory. External dependencies include OBS Studio (libobs, obs-frontend-api), Qt6, and nlohmann-json. The codebase demonstrates solid C++17 practices, clean separation of concerns, and comprehensive CI/CD pipelines for multi-platform distribution.
dpScreenOCR is a cross-platform desktop application for recognizing text from a selected screen region. It is built in C++ using the Tesseract OCR engine and Qt 5/6 for the graphical interface. The application runs as a system-tray utility: the user triggers a screen selection via a global hotkey, captures a portion of the screen, processes the image (grayscale conversion, upscaling, unsharp masking), and feeds it to Tesseract. Recognized text can be copied to the clipboard, added to a persistent history, or passed to an external executable. The architecture is modular, with separate libraries for OCR (dpso_ocr), system interaction (dpso_sys), image processing (dpso_img), network requests (dpso_net), sound playback (dpso_sound), configuration and history (dpso_ext), and a suite of cross-platform utilities (dpso_utils). Each module exposes a C API for C/C++ interoperability and includes platform-specific backends for X11 and Windows. The Qt UI provides a main window with recognition controls, a language manager for installing/updating Tesseract language packs, and export functionality for history. The project also packages a built-in gettext-compatible internationalization library (dp_intl) and supports 16 languages through Weblate. This is a pure application repository with no data analysis or machine learning training components. The code demonstrates solid engineering practices: clear separation of concerns, RAII resource management, comprehensive error handling, and an extensive CMake-based build system supporting multiple packaging formats (Unix bundle, Windows MSIX, Inno Setup). The test suite covers utility functions, geometry, SHA-256, version comparison, and platform-specific components, though the OCR pipeline itself has limited direct unit tests.
BallonsTranslator is a mature, feature-rich desktop application for translating manga and comic images. It provides a complete pipeline: text detection (CTD, YOLO, DBNet), OCR (MangaOCR, MIT48px, PaddleOCR, cloud APIs), inpainting (AOT, LaMa, PatchMatch, LLM), machine/LLM translation (Google, DeepL, Sakura, OpenAI-compatible, etc.), and a sophisticated WYSIWYG text editor with effects (stroke, shadow, glow, gradient, filters, transforms). The architecture is monolithic with a plugin-like module registry for extensible backends. It uses PyQt5/PyQt6 for the GUI, supports project-based workflows, undo/redo, and headless batch processing. While primarily an application, it incorporates significant data engineering and ML model integration, making it a hybrid tool with strong research components. The codebase demonstrates high craftsmanship in areas like custom Qt widgets, frameless windows, text rendering engine, and LLM context management, but also carries technical debt from platform-specific code and a large dependency surface.
PCem is a vintage IBM PC/XT/AT/386/486/Pentium emulator that prioritizes hardware-level accuracy over performance. It emulates a vast range of CPUs (8088 through Pentium II, K6, Cyrix), chipsets (Intel 430/440 series, VIA, SiS, OPTi, etc.), video cards (CGA, EGA, VGA, SVGA, Voodoo 1-3, ATI Mach64, S3 Virge, and many more), sound cards (AdLib, Sound Blaster, Gravis Ultrasound, AWE32, OPL, reSID, etc.), storage controllers (IDE, SCSI, MFM, floppy), and networking (NE2000, SLiRP). The emulator uses a dynamic recompiler (codegen) with host backends for x86, x86-64, ARM, and ARM64 to achieve usable performance on modern hardware. It provides two parallel GUI frontends (wxWidgets and Qt), both using SDL2 for video and input, and supports a plugin system for extending emulated hardware. The codebase is written primarily in C with some C++ components, built with CMake and Clang, and targets Windows, Linux, and macOS.