Feishin is a feature-complete self-hosted music player client, delivered as an Electron desktop application and a standalone web build. In production it connects to Subsonic/OpenSubsonic, Navidrome, or Jellyfin servers and presents their libraries (albums, artists, playlists, folders, genres, radio) through a React 19 + Mantine 9 UI. Playback is performed client-side through multiple engines: MPV via an IPC bridge, an HTML5/web-audio engine with gapless transition and crossfade curve math, and DLNA speaker casting via SSDP discovery and SOAP control. It also ships a companion mobile remote web app (src/remote) that controls the desktop player over a WebSocket-based protocol, including queue, playlists, and radio. The repository is purely an application; its only data-related surfaces are integrations with external music-server APIs and client-side caching/validation logic. Architecturally, the app is split into an Electron main process (src/main) housing platform features — lyrics providers (Genius, NetEase, Lrclib, SimpMusic), DLNA, Discord RPC, MPRIS, custom-theme file watching, and a taglib-wasm tag editor — a typed preload IPC bridge (src/preload), and a feature-foldered React renderer (src/renderer). Data flows through TanStack React Query with structured per-server query keys and optimistic mutations; Zustand stores (with persistence and migration logic) manage player/settings/auth/app state; a typed event emitter decouples list, queue, and player components. Additional subsystems include a smart-playlist query builder, word-level synchronized karaoke lyrics with furigana/romaji conversion, scrobbling, Auto-DJ, internet radio, audio visualizers (Butterchurn, AudioMotion), and an extensive theming/i18n surface (30+ themes, 40+ locales). The codebase is very actively maintained with CI covering build/release on all desktop platforms, Docker, and updates. The strongest, most reusable craftsmanship sits in self-contained subsystems: the dual-player web audio engine, the lyrics animation engine, hand-rolled ThumbHash/BlurHash placeholder decoders, a Zod-based response-validation layer, and generic polymorphic component utilities. The tradeoff is breadth over polish: near-identical list/filter/grid/table variants are copy-pasted per entity, virtual-table hooks are tightly coupled to DOM structure, isElectron() guards are scattered throughout, and visible unit tests are minimal. It is a solid reference for Electron + React music-player architecture, but extracting individual features requires care due to internal coupling.
Spotube is a cross-platform, open-source Spotify client built with Flutter. It provides a full-featured music player experience without requiring a Spotify Premium subscription by leveraging plugin-based metadata providers and audio sources (YouTube, Piped, Invidious, JioSaavn, etc.). The application supports local playback, playlist management, lyrics (synced and plain), downloads, scrobbling (Last.fm), remote device control via WebSocket, and extensive customization (themes, layouts, audio quality). It uses Riverpod for state management, auto_route for navigation, drift for local SQLite storage, and media_kit for audio playback. The architecture is modular with a plugin system for metadata and audio sources, making it extensible. The codebase is well-structured with reusable patterns like pagination mixins, universal image loading, and type converters. It is actively maintained with nightly builds and a large community.
A browser-based tool for testing and configuring PlayStation DualSense, DualSense Edge, and DualShock 4 controllers via the WebHID API. It provides real-time visualization of all inputs (joysticks, buttons, triggers, gyroscope, accelerometer, touchpad), output control (lightbar, player LEDs, rumble, adaptive triggers, audio), and diagnostics (battery, telemetry, firmware info). For DualSense Edge, it offers profile editing including button remapping, joystick sensitivity curves, trigger deadzones, and vibration intensity. Built as a single-page application with Vue 3, TypeScript, and Pinia, it uses a custom device-based routing architecture that dynamically loads controller-specific views based on the HID device type. Communication with controllers is handled entirely in the browser through raw HID report parsing and construction, with audio streaming over USB (quadraphonic PCM) and Bluetooth (Opus via WebCodecs). The codebase is heavily modularized with composables for media playback, microphone capture, and state management. While primarily an application, the repository includes significant reverse-engineering work of the HID communication protocols for these controllers, making it a valuable reference for implementing controller support. The code is organized for extensibility, with a clean pattern for adding new controller types.
Psst is a native desktop Spotify client written in Rust, designed as a fast, lightweight alternative to the official Electron-based client. It implements the proprietary Spotify session protocol (Shannon cipher, Diffie-Hellman key exchange, Mercury messaging) to stream audio directly, bypassing the Web API for playback. The application is structured as a workspace with three crates: `psst-core` (session management, audio pipeline, caching, Last.fm scrobbling), `psst-gui` (Druid-based GUI with controllers, widgets, and Web API integration), and `psst-cli` (simple command-line player). The GUI features a full browsing experience (home, search, library, artist/album/playlist/show details, lyrics, recommendations, credits) with async data loading via a Promise pattern and remote image caching. The audio pipeline includes decryption, decoding (symphonia), resampling, normalization, and output via cpal or cubeb. Authentication uses OAuth2 with PKCE and supports user-provided Spotify Client IDs. The project is actively developed with rolling releases and cross-platform builds (Windows, macOS, Linux).
DistroAV is an OBS Studio plugin that enables real-time network audio/video transmission using NDI technology. It implements both NDI sources (receiving streams) and NDI outputs (transmitting the main scene, preview, or per-source filters) within OBS. The architecture is a standard OBS plugin: it registers custom source, output, and filter types using the OBS API, provides a Qt-based settings dialog for configuration, and includes an automatic update checker. Key data flows involve capturing OBS video/audio frames, converting them to NDI frames using the NDI SDK (v6.3+), and sending/receiving over the network. External dependencies include the NDI runtime library, OBS Studio 31.1.1+, Qt6, and libcurl for updates. The codebase is well-structured with cross-platform CMake build system, CI/CD pipelines, and internationalization support, though it relies on a proprietary SDK and contains some legacy code paths.
BlueALSA is a Bluetooth audio ALSA backend for Linux systems that integrates with BlueZ to provide A2DP, HFP/HSP, ASHA, and BLE-MIDI profiles. It operates as a daemon (bluealsad) managing Bluetooth connections and exposing audio streams via ALSA PCM plugins and D-Bus interfaces. The architecture is modular, separating transport management, codec handling, D-Bus communication, and ALSA plugin layers. Key entry points include the daemon (src/main.c), ALSA PCM plugin (src/asound/bluealsa-pcm.c), ALSA mixer plugin (src/asound/bluealsa-ctl.c), and control utility (src/bluealsactl/main.c). Data flows from ALSA applications through the PCM plugin to Bluetooth transports, with control signaling via D-Bus. External dependencies include BlueZ, ALSA, GLib, and various codec libraries (SBC, aptX, LDAC, etc.).
Squeezelite is a lightweight, headless Squeezebox emulator that acts as a network audio player for Lyrion Music Server (formerly Logitech Media Server). It receives audio streams via the Slimproto protocol, decodes a wide range of codecs (MP3, FLAC, AAC, Ogg Vorbis, WMA, ALAC, DSD, Opus), and outputs to local audio hardware through ALSA, PortAudio, PulseAudio, or stdout. The application is written in C with a modular, multi-threaded architecture: separate threads for network streaming, decoding, resampling, and output, all communicating via circular buffers with mutex protection. It supports high-resolution audio, DSD (DoP and native), resampling with libsoxr, visualizer export to shared memory, IR remote control, and GPIO amplifier control. The codebase is highly portable, with dedicated Makefiles for Linux, macOS, Windows, Solaris, and various ARM architectures, as well as Visual Studio project files. Build-time options (LINKALL, DSD, RESAMPLE, etc.) allow static or dynamic linking of codec libraries. The project is actively maintained with a responsive community and is widely used in embedded audio players and home automation systems.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
Edzelf/ESP32Radio-V2 is an internet radio receiver firmware for the ESP32 microcontroller. It streams audio from Shoutcast/Icecast servers and plays local MP3 files from an SD card. The system supports both hardware (VS1053) and software (Helix MP3/AAC) audio decoding, with output via I2S DAC, internal DAC, or Toslink optical. It offers a web-based interface for station selection, volume control, and configuration, as well as MQTT, IR remote, and rotary encoder inputs. The firmware is built with PlatformIO and the Arduino framework, and it is designed to be highly configurable through compile-time defines in a central `config.h` file. Architecturally, the application is monolithic, with all main logic concentrated in a single `main.cpp` file. It uses multiple FreeRTOS tasks for networking (HTTP streaming), audio decoding/output, and SD card operations, communicating via FreeRTOS queues. A custom state machine handles HTTP streaming and metadata extraction. The system abstracts display hardware (various TFT, OLED, and LCD types) through a set of driver libraries with consistent interface macros, allowing the same firmware to be compiled for different display modules with minimal code changes. Audio decoders are also abstracted via macros, enabling compile-time selection between VS1053 and Helix software decoding. The codebase is actively maintained (last commit Feb 2026), but shows some signs of technical drift: it uses the deprecated SPIFFS filesystem, has version-guarded but older I2S API calls, and relies heavily on conditional compilation which complicates testing and maintenance. The library includes several well-crafted standalone components, such as the display drivers and hardware codec driver (VS1053), which can be reused in other ESP32 audio projects. The Helix MP3 and AAC decoders are large monolithic files with global state, limiting their reusability outside this specific project context.
This repository is a collection of Kodi/XBMC addons focused on media streaming, playback, and extended functionality. It contains numerous plugin.video.* and plugin.audio.* addons that scrape or API-fetch content from various online sources (e.g., MEGOGO.NET, Kinozal.tv, YouTube, torrent sites) and integrate with Kodi's media player. The repository also includes utility modules for HTML parsing (html5lib, BeautifulSoup), JSON handling (simplejson), downloading, caching, and framework components (xbmcswift2). The architecture is a collection of largely independent addons, each with its own default.py entry point, shared libraries, and resource files. Data flows involve fetching metadata from external sources, parsing it into Kodi-compatible formats, and passing media URLs to Kodi's player. External dependencies include Kodi/XBMC APIs, vendored Python libraries (html5lib, beautifulsoup4, simplejson), and external web services/APIs.