Mopidy is an extensible, headless music server written in Python. In production it runs as a daemon, plays audio through GStreamer, pulls local files and streaming radio via pluggable backends, and exposes control to clients over HTTP JSON-RPC and WebSockets, with MPD protocol support provided by an external extension. The architecture is modular: a Pykka actor-based core orchestrates library, tracklist, playback, mixer, and history controllers; separate backend, audio, and media layers isolate concerns; and an entry-point-driven extension system lets third parties register backends, frontends, mixers, and CLI commands. Bundled extensions provide local file playback, M3U playlists, HTTP control, a software mixer, and stream handling. The codebase is a modern, typed Python application requiring Python 3.13+, with Pydantic domain models, asyncio/Tornado HTTP handling, a reusable config schema system, and a GStreamer-based media reader that probes metadata and parses playlists. The test suite is extensive (pytest, dummy actors, fixture audio files), and CI covers multiple Python versions. Some legacy APIs are marked deprecated for removal in Mopidy 5.0, but overall the project is actively maintained and structurally coherent. It is not a data/research repository; its only data-heavy aspects are media metadata extraction and playlist parsing.
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.
GirCore is a comprehensive C# binding generator and runtime library for GObject-based native libraries (GTK, GStreamer, WebKit, Cairo, etc.). It reads GObject Introspection (GIR) XML files and produces strongly-typed C# bindings with P/Invoke declarations, SafeHandle memory management, and high-level managed APIs. The architecture consists of a generation pipeline (GirLoader parses GIR, GirModel defines an interface-based intermediate representation, Generator applies fixers and renders C# code via a modular converter system) and a set of runtime libraries (GLib, GObject, Gtk, etc.) that provide safe wrappers, signal handling, subclassing support, and platform abstraction. Key entry points include the GirTool CLI for regeneration, Module.Initialize() for library initialization, and Roslyn source generators/analyzers for GObject subclassing and GTK composite templates. The project is pre-1.0 but actively used by several desktop applications and the .NET MAUI Linux backend.
Wolf is a production-grade game streaming server that implements the Moonlight (NVIDIA GameStream) protocol. It allows multiple remote clients to play games or run applications on a single Linux host, sharing a GPU and input devices. The system runs games in isolated Docker containers, captures their output via a custom headless Wayland compositor, encodes video/audio using hardware-accelerated GStreamer pipelines (NVIDIA NVENC, Intel QSV, AMD VA-API), and streams the result over RTP with forward error correction (Reed-Solomon) and AES encryption. Input from Moonlight clients is injected into containers via virtual uinput devices, and audio is routed through PulseAudio virtual sinks. The server provides a REST API for Moonlight client pairing/control, a Unix socket management API for a companion web UI, and supports multi-session lobbies. The architecture is monolithic but modular, using an event bus for decoupling, immutable state with `immer`, and a plugin system for GStreamer video/audio payloaders. The codebase demonstrates strong C++20 practices, portability across Linux distributions, and deep integration with kernel and GPU subsystems. It is not a data research project; it is a low-latency streaming application.
Clapper is a modern media player application designed for the GNOME desktop, built with GTK 4 and powered by GStreamer. It features a queue-based playback system supporting sequential, repeat, carousel, and shuffle modes, along with standard media controls like play/pause, seeking, volume adjustment, and fullscreen toggling. The application emphasizes usability with an adaptive interface, subtitle/audio track selection, playback speed control, and media information display showing technical details such as codecs and bitrates. The architecture consists of three main layers: a core library (`clapper`) handling playback logic, queue management, and extensibility via plugins; a GTK library (`clapper-gtk`) providing reusable widgets like video display, buffering indicators, and custom layouts; and the main application (`clapper-app`) assembling the user interface and integrating with the core. Extensibility is achieved through a libpeas-based plugin system for metadata extraction, playlist parsing, and reactive components, while optional features like MPRIS and a built-in web server for remote control are marked as deprecated in favor of the external enhancer ecosystem. Clapper demonstrates strong engineering practices with proper GObject encapsulation, thread-safe design using a custom `ClapperThreadedObject` base class, and adherence to GTK 4 patterns such as template-based widgets and action-driven UI. The project maintains active development with recent commits, comprehensive internationalization support, and integration with modern GNOME technologies like libadwaita, though it relies on evolving dependencies (GStreamer, GTK) and contains some deprecated components requiring ongoing maintenance.
Live Photo Converter is a cross-platform application for processing Android Live Photos (MVIMG files). It provides a modern GTK4/LibAdwaita graphical interface, a set of command-line tools, and a shared library (`liblivephototools`) for creating, extracting, and repairing these files. The core operation involves appending an MP4 video to a JPEG image and managing the associated XMP metadata (Google's GCamera and Container namespaces). It also supports generating long exposure photos from video frames and copying metadata between images. The architecture is a well-structured monolith written in Vala and built with Meson. The core logic resides in a shared library, with CLI and GUI frontends linking against it. Video processing is handled by a clean strategy pattern, defaulting to an in-process GStreamer pipeline with an FFmpeg subprocess fallback. The build system is highly sophisticated, supporting Linux (Flatpak, Arch), Windows (MSYS2), macOS (Homebrew), and Android (experimental, via pixiewood). The codebase demonstrates strong software craftsmanship. It features clean abstractions (abstract base classes `LivePhoto`/`LiveMaker`), meticulous thread safety (GOnce, AtomicInt, AsyncQueue, Mutex), and well-encapsulated utility components. The `PipelineWatch` class for GStreamer error handling and the `Reporter` class for CLI output are particularly well-crafted and reusable. The primary weakness is the absence of a formal unit test suite, which prevents a higher quality score.