yt-dlp is a feature-rich command-line video/audio downloader, forked from youtube-dl. It extracts media URLs from over a thousand websites using site-specific extractors, downloads via HTTP, HLS, DASH, RTMP, and other protocols, and supports extensive post-processing (FFmpeg transcoding, metadata embedding, chapter manipulation, etc.). The architecture is modular: a core engine (YoutubeDL) orchestrates extractors, downloaders, and postprocessors, all of which can be extended via a plugin system. Networking is abstracted behind a handler interface with support for requests, curl-cffi, and websockets. The codebase is well-structured, with clear patterns for authentication, geo-restriction handling, and format selection. It includes a sophisticated JavaScript challenge solver and Proof-of-Origin token system for YouTube. Despite its size, the project maintains good code organization and extensive test coverage.
Cobalt is a privacy-focused media downloader web application with a SvelteKit frontend and Node.js/Express API backend. Users paste a URL from supported platforms (YouTube, TikTok, Instagram, Twitter/X, Vimeo, Reddit, SoundCloud, Twitch, Bilibili, and 15+ others) and receive a downloadable media file. The architecture is a monorepo with three packages: @imput/cobalt-web (static frontend), @imput/cobalt-api (processing backend), and @imput/version-info (build-time version helper). The API acts as a fancy proxy - it fetches media streams from source platforms, optionally remuxes/transcodes via FFmpeg (server-side or client-side via libav.js WebAssembly), and streams results back without ever writing to disk. The frontend handles URL input, settings management (localStorage with migration), a processing queue with Web Workers for client-side FFmpeg, i18n (EN/RU), and PWA features. Key data flows: user submits URL → API validates/matches service → extracts stream URLs → returns tunnel/redirect/picker response → frontend either streams directly, proxies via API, or processes locally via Web Workers. External dependencies: FFmpeg (via ffmpeg-static), youtubei.js for YouTube, hls-parser, undici for HTTP, Redis (optional for rate limiting), Cloudflare Turnstile (optional bot protection).
TubeArchivist is a self-hosted YouTube media server that downloads, indexes, and serves YouTube video content. In production, it runs as a Docker-based stack with a Django REST API backend, React/TypeScript frontend, Celery task queue, Redis broker, and Elasticsearch for metadata storage and full-text search. The system subscribes to YouTube channels and playlists via yt-dlp, extracts comprehensive metadata (including subtitles, comments, SponsorBlock segments, and thumbnails), and provides a web UI for browsing, searching, streaming video, and managing downloads. It supports multiple authentication modes (single user, LDAP, forward proxy), scheduled tasks for rescanning subscriptions and backups, and integrates with Apprise for notifications and a membership/SponsorBlock API for ad-skipping. The architecture follows a modular Django app pattern (video, channel, playlist, download, task, appsettings, user, stats) with consistent use of base views, serializers, and search processors. The frontend uses Zustand for state management and a custom API client with CSRF handling. The codebase is actively maintained with comprehensive test coverage and CI/CD pipelines.
Lux is a fast and simple video downloader CLI tool written in Go. It supports downloading videos, images, and audio from over 40 websites including YouTube, Bilibili, TikTok, Instagram, Twitter, and many Chinese streaming platforms. The tool operates as a single binary with a rich set of command-line options for selecting quality, downloading playlists, resuming interrupted downloads, multi-threaded downloading, and integration with aria2 for RPC-based downloads. Architecturally, Lux follows a plugin-based extractor pattern. Each supported website has its own extractor module under `extractors/`, registered via `init()` functions into a global map keyed by domain. The main entry point is `main.go`, which parses CLI flags via `urfave/cli` and dispatches to the appropriate extractor. Extracted video metadata (streams, quality, size) is passed to the downloader, which handles HTTP requests, progress bars, file merging via ffmpeg, and optional subtitle embedding. Key data flows: URL input → domain detection → extractor selection → HTML/API scraping → stream metadata extraction → downloader (single or multi-threaded) → file output. External dependencies include ffmpeg for merging and subtitle embedding, and various third-party Go libraries for HTTP requests, HTML parsing, JavaScript execution (for TikTok signing), and progress bars. The codebase is well-organized with clear separation of concerns, extensive test coverage for individual extractors, and CI workflows that run weekly to verify extractor functionality. While many extractors rely on fragile regex-based scraping of HTML pages, the overall architecture is solid and the downloader implements robust features like resume support and configurable retry logic.
FluentYTDL is a Windows desktop application built with PySide6 and qfluentwidgets that provides a modern Fluent Design GUI for downloading videos and audio from YouTube and X (Twitter). It wraps yt-dlp as the core download engine and adds a rich layer of task management, error diagnostics, cookie-based authentication, subtitle handling, metadata embedding, and VR/360 video support. The application features a persistent SQLite task database, structured observability with JSONL event tracing, rule-based error classification, and a self-update mechanism with component version management. It is heavily internationalized (English and Simplified Chinese) and includes a comprehensive test suite covering UI, download pipeline, diagnostics, and observability contracts. Architecturally, the codebase is organized into distinct modules: core (config, dependency, update), auth (cookie sentinel, WebView2 provider), download (executor, workers, staging, quality guard), processing (metadata, subtitles, sponsorblock), diagnostics (rule engine, line collector), observability (events, traces, artifacts), and UI (pages, dialogs, delegates, components). The download pipeline is transactional with staging areas and manifests, ensuring atomicity and recovery. The observability layer is best-effort and never blocks business logic, emitting structured events for debugging and bug bundle export. The code demonstrates strong engineering practices: immutable dataclasses for plans, singleton managers with explicit initialization guards, strategy patterns for subtitle selection, and extensive use of signals for async UI updates. Key reusable components include the container compatibility resolver (deterministic output container decision), BCP-47 language matching with tiered resolution, the quality guard pattern for pre/post-download verification, the transactional staging pattern for file management, and the cookie runfile isolation pattern to prevent yt-dlp from corrupting truth-source cookies. The diagnostics rule engine and observability event system are also well-isolated and could be extracted for other yt-dlp wrapper projects.
YTDLnis is a feature-rich Android application that serves as a graphical frontend for yt-dlp, enabling users to download video and audio from over 1000 websites. The app follows the MVVM architecture with Room database for local persistence, WorkManager for background download tasks, and a repository pattern for data access. It provides a comprehensive download management system including queue management, scheduling, format selection, metadata embedding, chapter splitting, SponsorBlock integration, and support for custom yt-dlp commands. The application also includes a built-in terminal emulator for advanced users, cookie management, YouTube PoToken generation, and an observe-sources feature for monitoring channels or playlists for new content. The codebase is well-organized into UI fragments, viewmodels, repositories, and utility classes, with extensive use of Kotlin coroutines and Android Jetpack components. While the app is actively maintained and demonstrates solid engineering practices, some modules like UiUtil.kt are monolithic and tightly coupled, and the heavy reliance on external tools (yt-dlp, FFmpeg, Python) introduces ongoing maintenance risks.
This repository provides the data pipeline for the Sekai dataset, a large-scale egocentric video dataset for world exploration and generation research. It contains two main toolchains: dataset_downloading (extracting YouTube URLs from CSV annotations and downloading videos via yt-dlp) and clip_extracting (a multi-step GPU-accelerated pipeline to split raw videos into annotated clips, transcode them to H.265, and remux with audio). The pipeline is designed for the Sekai-Real subset and requires NVIDIA GPUs with NVENC support, CUDA 11.8, and specific Python dependencies. The code is well-structured with clear separation of steps, logging, and multiprocessing support. While tightly coupled to the Sekai dataset and hardware requirements, the utility modules for GPU video decoding/encoding and frame sampling are reusable in other video processing projects.
Seal is an Android application that serves as a graphical frontend for yt-dlp, enabling users to download videos and audio from a wide range of websites. Built with Kotlin and Jetpack Compose, it features a Material Design 3 interface with dynamic color theming. The app manages download tasks through a state machine, supports playlists, custom command templates, cookies, SponsorBlock integration, and extensive format selection. It relies on yt-dlp (via youtubedl-android), FFmpeg, and aria2c as external engines, and uses Room for local database storage, MMKV for preferences, and Koin for dependency injection. The architecture is a single-activity Compose Navigation app with a foreground download service. While the codebase is well-organized and actively maintained, it exhibits some technical drift (e.g., deprecated Accompanist WebView, minimal test coverage) and contains a few monolithic modules. Notable reusable components include a standalone color science library implementing CAM16/HCT, a backup/restore utility for database objects, and a custom motion system for Material Shared Axis transitions.
ytDownloader is a cross-platform desktop application built with Electron that provides a graphical interface for downloading videos and audio from YouTube and hundreds of other sites using yt-dlp as the backend download engine. It features a comprehensive download manager supporting single downloads, playlists, and YouTube search, with options for format selection, quality, subtitles, compression, and output templates. The application manages its own yt-dlp and ffmpeg binaries, supports auto-updates, and includes a download history with JSON/CSV export, theming, internationalization (23+ languages), system tray integration, and a global hotkey for quick URL pasting. Architecture: The application follows a standard Electron architecture with a main process (main.js) handling window management, IPC handlers, auto-updater, system tray, and global hotkey. A preload script (preload.js) sets up a context bridge (electronAPI) that exposes filesystem operations, process spawning, clipboard access, and other OS services to the renderer. The renderer process consists of several JavaScript modules (src/index.js, src/playlist.js, src/compressor.js, src/preferences.js, src/history_ui.js, src/common.js) that handle specific views. Communication between renderer and main process occurs via Electron's IPC mechanism (ipcRenderer/ipcMain). User preferences are stored in localStorage and a JSON config file, while download history is persisted as JSON. Key entry points: main.js (Electron main process), preload.js (context bridge), html/index.html (single-page UI shell), src/renderer.js (main renderer logic with YtDownloaderApp class), src/index.js (homepage downloader), src/playlist.js (playlist downloader), src/compressor.js (video compressor), src/preferences.js (settings), src/history_ui.js (history view). External dependencies include yt-dlp (download engine), ffmpeg/ffprobe (media processing), Electron (framework), electron-builder (packaging), electron-updater (auto-updates), systeminformation (GPU detection), and SlimSelect (custom dropdowns). The application bundles these binaries or uses system-installed versions, with fallback mechanisms.
HomeTube is a Streamlit-based web application for downloading and managing media from YouTube and 1800+ other platforms via yt-dlp. It provides a rich UI for URL analysis, quality profile selection (AV1/VP9/H.264), subtitle embedding, video cutting (keyframe/precise), SponsorBlock ad removal, and playlist synchronization with full diff-based state management. The architecture is a monolithic Streamlit app with heavy subprocess orchestration of yt-dlp and ffmpeg, backed by a typed configuration system, JSON-based workspace state files, and a comprehensive test suite with mocked Streamlit dependencies. Designed for homelab deployment, it includes Docker multi-arch builds, Nginx reverse proxy config, and daily automated rebuilds to stay current with yt-dlp updates. Core data flows: URLs are analyzed via yt-dlp (with client fallback chain default → ios → web), metadata is cached in url_info.json, download strategies are computed using format profile matching (codec priorities, audio language detection), and final files are moved to a configurable destination with optional hardlinking. Playlists are handled via a dedicated sync module that computes rename/archive/delete plans and applies them with dry-run support. The system emphasizes resilience through generic file naming, temporary workspace preservation, and intelligent caching that refuses to overwrite premium AV1/VP9 metadata with lower-quality data. The application is not a data research project; it is a production-ready media downloader and manager with no ML or analytical components. Its complexity lies in data integrity patterns (metadata caching, state machines, filesystem mutations) rather than data science.
This repository implements a comprehensive CLI tool and library for downloading content from Patreon. It supports posts, products, media (images, videos, audio, attachments), and metadata like campaign info, comments, and collections. The downloader uses cookie-based authentication to access patron-only content and handles various embedded media providers (YouTube, Vimeo, SproutVideo) via internal tasks or external downloader hooks. The architecture is event-driven and modular: a base Downloader class orchestrates fetchers, parsers, and download task batches, with typed entities and extensive configuration options (proxy, concurrency, file existence actions, naming formats). A built-in web server with a React frontend allows browsing downloaded content via a local SQLite database with full-text search. The code demonstrates strong engineering practices: class mixins for database and API layers, a task hierarchy with retry and abort support, a chainable logger abstraction, and a utility-heavy core that is largely decoupled from the Patreon-specific logic. However, the tight coupling to Patreon's undocumented API structure, lack of automated tests, and some deprecated options are notable weaknesses.
YTConverter is a terminal-based YouTube video and audio downloader built with Python. It leverages yt-dlp for downloading and ffmpeg for format conversion and merging, offering features like single and batch downloads, playlist support, and quality selection. The application provides an interactive menu and command-line interface for ease of use, with cross-platform path handling and filename sanitization utilities.
You-Get is a command-line media downloader that scrapes web pages to extract and download video, audio, and image files from over 100 websites including YouTube, Bilibili, and Youku. The architecture is a monolithic Python package with a modular extractor system: each supported site has a dedicated module under `src/you_get/extractors/` that implements a consistent interface (module-level `download` and `download_playlist` functions). The core engine in `common.py` handles URL resolution, HTTP requests with retry, proxy support, cookie loading, and download orchestration via external tools like ffmpeg or rtmpdump. The CLI entry point in `__main__.py` provides options for format selection, playlist handling, JSON output, and streaming to media players. While the project is functionally complete and has sustained community interest for over a decade, the codebase shows signs of organic growth: heavy reliance on fragile regex-based scraping, global state management, and embedded API keys. The most technically notable component is the standalone MP4 merger in `join_mp4.py` that implements ISO BMFF atom parsing without external dependencies.