mpv is a free, open-source, cross-platform media player for the command line. It is built on a modular architecture with a stream layer, demuxers, decoders, filters, and audio/video output backends. The codebase is primarily C with some Lua and Swift for scripting and macOS integration. It supports a vast array of media formats via FFmpeg, hardware acceleration (VAAPI, VDPAU, CUDA, D3D11, etc.), and advanced rendering with libplacebo. It also provides a client API (libmpv) for embedding in other applications. The repository is actively maintained with extensive CI, fuzz testing, and a large set of Lua scripts for customization. The code demonstrates high craftsmanship with reusable abstractions like a custom talloc-based memory allocator, a generic filter graph framework, and a render abstraction layer.
IINA is a modern macOS media player built on the mpv framework. It provides a native macOS interface for playing local and online media, with features including subtitle support, playlist management, Touch Bar integration, picture-in-picture mode, and a JavaScript-based plugin system for extensibility. The application follows a modular architecture separating playback core (PlayerCore), UI components, preference management, plugin system, and utilities. Key strengths include a well-crafted threading system (Atomic/ReadWriteAtomic property wrappers), structured logging, and a preference observation pattern. While the core PlayerCore class exhibits some complexity, the overall codebase demonstrates professional macOS development practices with clean abstractions in utility modules and extensibility points.
This repository is an Android TV application (影視TV) that provides a comprehensive media center experience for streaming Video-on-Demand (VOD) and live television. It features a plugin-based content aggregation system using spiders written in Java, Python (via Chaquopy), and JavaScript (via QuickJS), allowing users to browse and play content from multiple external sources. The application supports multiple player engines (ExoPlayer and mpv), hardware/software decoding, subtitle and danmaku (bullet comment) overlays, DLNA casting (both sender and renderer), and a local HTTP server for remote control and file sharing. Architecturally, the project is a multi-module Gradle build with a shared core library (catvod) providing network utilities, cryptography, and data models. The main app module contains two UI tracks: 'leanback' for TV remote control navigation and 'mobile' for touch-based phone interaction, both sharing common logic under app/src/main. The system uses an event-driven architecture with EventBus, a Room-based SQLite database for persistence, and a ViewModel pattern for reactive UI updates. External content sources are integrated through a standardized Spider interface, with loaders for JAR, Python, and JavaScript plugins. Key features include a sophisticated playback controller with fallback policies, preloading, and history management; extensive audio/video effect pipelines (equalizer, loudness normalization, color adjustment); danmaku search and display; EPG (Electronic Program Guide) with timezone-aware parsing; and a comprehensive settings system covering player, decoding, subtitles, and network configuration. The project also includes a documentation website built with Next.js, providing developer guides for the spider API and local HTTP API.
yewtube is a terminal-based YouTube player and downloader, forked from mps-youtube. It provides a full-featured CLI for searching, streaming, downloading, and managing YouTube content without requiring a YouTube API key. The application uses yt-dlp and youtube-search-python as backends for video extraction and search. It supports multiple media players (mpv, mplayer, VLC), MPRIS integration for desktop media control, Last.fm scrobbling, playlist management (local and YouTube), and various download/transcoding options. The architecture is a monolithic Python application with a command-loop pattern, global state management via a dedicated module, and a plugin-like player abstraction. While the codebase shows its age with some tightly coupled modules and global variables, it contains well-designed components such as a config system with validation, an abstract player interface, and a command registration decorator. The project is actively maintained with recent commits and releases.
Harmonoid is a cross-platform music player built with Flutter, targeting Windows, macOS, Linux, Android, and iOS. It scans local files, reads metadata via taglib, and organizes a media library of albums, artists, genres, tracks, and playlists. Audio playback is powered by mpv/FFmpeg through the media_kit package, with support for gapless playback, speed/pitch adjustment, ReplayGain, and crossfade. The app integrates Last.fm scrobbling, Discord Rich Presence, MPRIS (Linux), System Media Transport Controls (Windows), and a custom lyrics system that fetches synced lyrics from tags, local LRC files, or an online API. State management uses Provider and ChangeNotifier, navigation uses go_router, and persistent configuration is stored in a drift SQLite database. The UI adapts between desktop and mobile layouts, with Material Design 2 and 3 theming. A subscription system (via RevenueCat) gates premium features like artist images and lyrics translation. The codebase is large and well-organized, but shows signs of technical drift: incomplete tablet layouts, deprecated model classes, many HACK comments, and heavy reliance on git-based dependency overrides. Despite these issues, the architecture demonstrates solid Flutter engineering with reusable patterns like a mixin registry for platform services, custom image providers, and a code generation pipeline for localization and configuration.
MPC-QT is a desktop media player application that replicates the interface and functionality of Media Player Classic (MPC-HC) using Qt6 and libmpv. It supports local files, discs, network streams, and web videos (via yt-dlp), with advanced playback controls, playlist management, subtitle handling, hardware decoding, and HDR tone mapping. The architecture is a monolithic Qt Widgets GUI with a separation between the UI (MainWindow, SettingsWindow, PlaylistWindow), playback orchestration (PlaybackManager), mpv integration (MpvObject), and cross-platform abstractions (screensaver, device manager). IPC mechanisms include a JSON socket, HTTP server (MPC-HC compatible), and MPRIS D-Bus. The codebase is feature-rich but shows signs of technical debt: large files, manual memory management, hardcoded indices in settings, and incomplete localization. It is actively maintained with CI/CD pipelines for Linux and Windows, but translation files have many unfinished or vanished strings.
ytsurf is a single-file Bash script that turns the terminal into a YouTube frontend. It scrapes YouTube search results and channel pages via curl and perl, parses the embedded JSON with jq, and presents results in a fuzzy-finder (fzf, rofi, sentaku, or tv) with thumbnail previews rendered via chafa. Once a video is selected, the script delegates playback to mpv (or iina/syncplay) and downloading to yt-dlp. The tool supports audio-only mode, format selection, subscription management with a personalized feed, watch history, playlists, and queueing. It caches search results and feed data to avoid redundant network calls, uses a config file for persistent settings, and offers multi-selector support. While functionally rich and well‑structured for a shell script, the codebase is tightly coupled into a single file (∼1400 lines), lacks unit tests beyond basic CI sanity checks, and relies on scraping fragile YouTube HTML. The packaging (Nix, Homebrew, AUR) and CI (ShellCheck on Linux/macOS) demonstrate good distribution and quality assurance.