MeTube

MeTube is a lightweight, self‑hosted media manager that exposes a web UI for the powerful yt-dlp downloader. From a developer standpoint, it functions as a thin wrapper around yt‑dlp, translating user requests into command‑line invocations while exposing a REST‑like API for programmatic control. The application is written in Go, leveraging the standard library’s net/http for routing and a small set of third‑party packages for configuration, templating, and concurrency control. This choice gives MeTube a minimal binary footprint (~15 MB for the Docker image) and eliminates runtime dependencies, making it ideal for containerized deployments.

• Language & Runtime: Go 1.22+, compiled to a single static binary.
• Web Framework: The built‑in net/http package with a minimal router (gorilla/mux) for clean URL handling.
• Templating: html/template renders the UI; assets are embedded via Go’s embed package.
• Concurrency: A semaphore pattern (bounded channel) implements the DOWNLOAD_MODE limits, ensuring safe parallel execution of yt‑dlp processes.
• Configuration: All settings are exposed through environment variables, enabling declarative Docker or Kubernetes manifests.
• Persistence: No database is required; MeTube stores state in the filesystem (download queue, logs) under the configured DOWNLOAD_DIR.

• Playlist Support: MeTube can fetch entire playlists from YouTube and dozens of other sites, with optional strict mode and item limits.
• Concurrent & Limited Downloads: Developers can tune throughput via DOWNLOAD_MODE and MAX_CONCURRENT_DOWNLOADS.
• Custom Directories: The UI offers a dropdown for per‑task directory selection, backed by CUSTOM_DIRS and CREATE_CUSTOM_DIRS.
• API Exposure: While the primary interface is a browser UI, MeTube exposes JSON endpoints for adding tasks, querying status, and deleting completed items. These can be consumed by CI/CD pipelines or other automation tools.
• Webhooks: Optional webhook hooks (not yet documented) can be wired to trigger downstream actions once a download completes.

MeTube ships as an Alpine‑based Docker image (ghcr.io/alexta69/metube), making it trivial to run in any OCI‑compatible environment. The Dockerfile exposes port 8081 and mounts a host directory for persistent storage, ensuring that downloads survive container restarts. For Kubernetes, the provided docker‑compose snippet can be translated into a Deployment + PersistentVolumeClaim. Because MeTube has no external dependencies, it scales horizontally by running multiple replicas behind a load balancer; each instance will independently schedule downloads based on its own semaphore limits.

• Plugin Hooks: The Go code defines a DownloadHook interface that can be implemented in future releases to inject custom logic before or after a download.
• Extensible CLI: Since MeTube internally calls yt‑dlp, any flag supported by yt‑dlp can be passed through the UI or API (e.g., --format, --proxy).
• Webhooks & Callbacks: Developers can register HTTP callbacks to be notified on task completion, enabling integration with monitoring or alerting systems.
• Community Scripts: The open‑source repository encourages community contributions; a small footprint makes it straightforward to fork and add bespoke features.

Configuration is intentionally declarative: environment variables cover every toggle, and the UI exposes most of them as toggles or dropdowns. Documentation is concise but comprehensive, with clear sections for Docker, environment variables, and feature flags. The GitHub repo hosts an active issue tracker and a small but responsive community; pull requests are merged quickly, reflecting a healthy open‑source workflow. Because MeTube is written in Go, developers can compile custom binaries for platforms that lack Docker support.

1. Automated Media Archival – A media server (e.g., Jellyfin) can host MeTube to queue bulk downloads of YouTube playlists for offline consumption.
2. CI/CD Artifact Retrieval – Continuous integration pipelines can trigger MeTube via its API to fetch video assets required for automated testing or documentation.
3. Educational Content Curation – Teachers can deploy MeTube on a campus server to batch‑download lecture videos from various platforms, ensuring consistent local copies.
4. Content Moderation – Security teams can schedule downloads of suspect URLs to a sandbox environment for offline analysis.

• Zero Runtime Footprint – No database, no external services; a single binary is all that’s needed.
• Fine‑grained Concurrency Control – The semaphore pattern gives developers precise control over resource usage.
• Native yt‑dlp Integration – By leveraging the latest yt‑dlp fork, MeTube stays current with new site support and format handling without additional maintenance.
• Open‑Source & MIT Licensed – No licensing hurdles for internal or commercial deployments.
• Docker‑Ready Out of the Box – Simplifies CI/CD and cloud deployment; the image is already optimized for minimal size.

In sum, MeTube offers a developer‑friendly, lightweight platform to orchestrate large‑scale media downloads with minimal operational overhead. Its Go foundation, coupled with robust configuration and API hooks, makes it a compelling choice for any project that