ArcDLP

Open-source desktop video downloader powered by yt-dlp. Paste a URL, pick a quality, download.

Supports YouTube, Vimeo, Twitter/X, SoundCloud, and thousands of other sites.

Everything runs locally on your machine - no cloud, no accounts, no tracking.

</div> <br/> <p align="center"> <img src="screenshots/Screenshot1.png" width="48%" alt="ArcDLP video download" />    <img src="screenshots/Screenshot2.png" width="48%" alt="ArcDLP playlist" /> </p>

Download & Install

Download the latest release

Go to the Releases page, scroll down to Assets, and click the file for your system:

macOS: ArcDLP-x.x.x.dmg
Windows: ArcDLP-Setup-x.x.x.exe
Linux: ArcDLP-x.x.x.AppImage

No dependencies to install. yt-dlp and ffmpeg are bundled inside the app.

macOS

Download the .dmg file
Open it and drag ArcDLP to your Applications folder
Open ArcDLP

macOS will show a security warning the first time because the app is not code-signed yet. This is normal.

To fix it:

Click Done
Open System Settings
Go to Privacy & Security
Scroll down and click Open Anyway next to ArcDLP
Enter your password

You only need to do this once.

Windows

Download and run the .exe installer
Click More info, then click Run anyway
The installer will set up ArcDLP and create a shortcut automatically

ArcDLP installs per-user (no admin required) and can be uninstalled from Settings > Apps.

Linux

Download the .AppImage file
Make it executable: right-click → Properties → Permissions → check Allow executing file as program
Double-click to run

Features

Single video downloads - Fetch video info, preview metadata, choose quality (4K/2K/1080p/720p/480p/360p/240p), and download as MP4 or extract audio as MP3
Playlist support - Paste a playlist URL, select which items to download, pick a format, and queue them all at once
Download queue - Sequential processing with per-item progress, retry, cancel, and skip. One failure never stops the rest
YouTube sign-in - Access age-restricted, private, and members-only content through a built-in browser login window. Credentials go directly to Google
Download history - Quick access to previously fetched videos with cached metadata
Multi-site compatibility - Works with any site yt-dlp supports. Format detection adapts automatically to different streaming approaches across sites
Update notifications - The app checks for new releases on startup and lets you know when an update is available
Light and dark mode - Follows your system preference. macOS vibrancy supported

Usage

Paste a video or playlist URL and click Fetch
Pick a quality (or choose MP3 for audio extraction)
Click Add to Queue
Downloads are saved to ~/Downloads/ArcDLP by default (changeable in Settings)

For playlists, you can select/deselect individual items and choose a format for the whole batch before queueing.

To access private or age-restricted YouTube videos, sign in via Settings > YouTube Account. Your credentials go directly to Google through their standard login page.

Support the Project

If ArcDLP is useful to you, consider supporting development:

For Developers

Everything below is for people who want to build from source, modify the app, or contribute.

Contributing

Contributions are welcome. The codebase is intentionally simple - no frameworks, no build tools, vanilla JS throughout.

Before making changes, read through the code and match existing patterns. A few principles the project follows:

Keep it simple. If something can be done in 30 lines, don't use a library.
Resilience first. One failure should never kill the queue. Users should always know what's happening.
Explicit actions only. No auto-fetching, no auto-retrying. Every action traces to a button click.
Let yt-dlp do the work. Don't reimplement what yt-dlp already handles. The app is a GUI wrapper, not a competing tool.
Multi-site compatibility. Never assume YouTube-specific behavior unless explicitly scoped. Format detection, error handling, and UI labels should work for any site yt-dlp supports.

Getting Started

Fork and clone the repo
npm install (downloads yt-dlp + ffmpeg automatically) - See details below for Windows and Linux install
npm run dev to launch with DevTools - See more details below
Make your changes, test across a few different sites
Open a PR with a clear description of what changed and why

Build from Source

git clone https://github.com/archisvaze/arcdlp.git
cd arcdlp
npm install

Cross-platform builds

To build for a different platform's ffmpeg binary:

ffmpeg-static Platform Setup

ffmpeg-static downloads a platform-specific binary during npm install. On macOS, this works automatically, no setup needed.

On Windows and Linux, set environment variables before npm install to ensure the correct binary is downloaded:

Windows (x64):

$env:npm_config_platform = "win32"
$env:npm_config_arch = "x64"
rm -r -Force node_modules
npm install

Linux (x64):

export npm_config_platform=linux
export npm_config_arch=x64

ffmpeg-static only downloads one binary per install, matched to the configured arch. This means you can't build both x64 and arm64 Linux AppImages from a single npm install

Development

npm run dev          # macOS / Linux
npm run dev:win      # Windows

This launches the app with DevTools enabled and verbose logging.

Production Builds

npm run build:mac      # macOS - produces .dmg and .zip
npm run build:win      # Windows - produces NSIS installer
npm run build:linux    # Linux - produces AppImage
npm run build:all      # All platforms

Both yt-dlp and ffmpeg binaries are bundled into the built app via extraResources in package.json.

Project Structure

arcdlp/
├── src/
│   ├── main/
│   │   ├── main.js          # Electron main process, IPC, window, history
│   │   ├── preload.js        # Context bridge (window.api)
│   │   ├── ytdlp.js          # yt-dlp integration: spawn, parse, download
│   │   ├── queue.js          # Sequential download queue with per-item state
│   │   ├── cookies.js        # YouTube cookie auth and Netscape format export
│   │   ├── updater.js        # Update checker via GitHub Releases API
│   │   └── utils.js          # Dev mode flag, logging helpers
│   └── renderer/
│       ├── index.html        # UI structure
│       ├── renderer.js       # UI logic, state, rendering
│       └── index.css         # All styles
├── scripts/
│   ├── postinstall.js        # Downloads yt-dlp binary on npm install
│   └── fix-ffmpeg-win.js     # Renames ffmpeg for Windows builds
├── bin/                      # yt-dlp binary (auto-populated by postinstall)
├── build/                    # App icons (icon.icns, icon.ico, icon.png)
├── package.json
├── LICENSE
└── README.md

How It Works

User pastes a URL and clicks Fetch
App spawns yt-dlp --dump-json to get video metadata and available formats
User picks a quality preset or audio extraction
Click "Add to Queue" - the download is queued and processed sequentially
yt-dlp handles the actual download with --progress-template for structured progress output
Completed files are saved to the configured download folder

For playlists, the app uses --flat-playlist --dump-json to stream items one at a time, then queues selected items for download.

Dependencies

Only two runtime dependencies:

electron-store - Persistent settings and history
ffmpeg-static - Bundled ffmpeg binary for audio extraction and format merging

Dev dependencies: electron, electron-builder.

yt-dlp handles all downloading, format selection, and ffmpeg orchestration internally. The app is a GUI wrapper around it.

Roadmap

ArcDLP covers the core download workflow, but yt-dlp has a huge feature set that could be surfaced in the GUI. Here's what's planned and where contributors can help.

Quality of Life

Thumbnails in playlist items - The data is already fetched, just not rendered yet
File size estimates - Show approximate size on quality presets when available
Download complete notification - System notification when the queue finishes (only if window is not focused)
Playlist fetch cancellation - Currently can't cancel a playlist fetch mid-way through
Verbose log toggle - Clean messages by default, raw yt-dlp output when debugging

Advanced yt-dlp Features

yt-dlp supports a lot more than basic downloading. These features would make great contributions:

Subtitle downloads - --write-subs, --sub-langs, language selection UI
Embed metadata - --embed-thumbnail, --embed-metadata for tagging files
SponsorBlock integration - --sponsorblock-remove, --sponsorblock-mark to skip or mark sponsored segments
Additional audio formats - AAC, FLAC, WAV, Opus extraction (currently MP3 only)
Format filtering - Expose yt-dlp's format selection syntax for advanced users
Download archive - --download-archive to skip already-downloaded videos
Rate limiting - --limit-rate for bandwidth control
Proxy support - --proxy for users behind restrictive networks
Custom output templates - --output template configuration in s

Arcdlp

Install / Use

README