A blazing fast, multi-protocol download manager — the free & open-source IDM alternative.
- Dynamic download acceleration — Rust + Tokio engine with adaptive segmentation and slow-segment rescue
- Multi-protocol — HTTP/HTTPS, FTP, BitTorrent, eD2K, HLS & DASH streaming
- One engine, multiple clients — native GPUI desktop, Kotlin Android and SwiftUI iOS apps, React Web UI and CLI
- Browser integration — Chrome / Edge / Firefox extension with a 3-layer interception engine, plus a userscript
- AI-agent ready — built-in MCP (Model Context Protocol) server: let Claude, Cursor & other AI clients manage your downloads
- Automation & remote management — RSS subscriptions, scheduled queues, webhooks, plugins and optional FluxCloud device collaboration
- Local-first — free and open source, no ads, no account required for local downloads; resumable state stored locally by default
In Desktop or Web, group downloads by Series title to fold individual episodes together without moving files. Names like Show.S01E100 and 剧名第05话 are recognised. A trailing - 05 also works for extensionless names, videos, common subtitle files and .nfo files. Release suffixes like v2, END and [1080p] are supported. Subtitles can include language tags, flags and the video extension, as in Show - 05.mkv.pt_BR.forced.srt. Existing task groups and torrent bundles keep their own structure.
For a single local download in Desktop, Use a named subfolder reuses or creates a folder under the displayed save location. Recognised episodes use the series title; other downloads use the file or magnet name. Folder names follow the filesystem's case rules: Show and show group together in the view but can be separate folders on case-sensitive storage. A manually entered or picked directory takes precedence.
Desktop RSS only collects history on the first fetch. Download all eligible queues new and initially collected items matching the current search after confirmation. If the eligible items change, review the new results and confirm again.
| Feature | Description |
|---|---|
| Rust-Powered Engine | Shared Rust + Tokio engine, independent of UI and FFI, used by desktop, mobile, server and standalone CLI hosts |
| Smart Segmentation | Segments split dynamically at runtime; idle workers take over slow segments |
| Multi-Protocol | Dedicated engines for HTTP/HTTPS, FTP, BitTorrent (DHT/UPnP/magnet), eD2K (server + Kad DHT source finding, MD4 verification), HLS (AES-decrypt) and DASH |
| BitTorrent Web Seeds | On desktop and Web, right-click a torrent to add a BEP 19 source: a direct HTTP(S) file URL for a single-file torrent, or the root of a mirror that preserves the original torrent folder and file paths for a multi-file torrent. The server must support HTTP range requests. The address is saved with the task. |
| Queues & Speed Control | Named queues, scheduling and token-bucket global rate limiting |
| Persistence & Resume | SQLite with WAL by default; server deployments can use PostgreSQL; recover downloads from persisted state |
| Browser Integration | Download interception, streaming media sniffing, Alt+Click bypass, right-click send and connection diagnostics |
| Desktop & Web UI | GPUI desktop and React Web management, light/dark themes, custom themes, task details and segment visualization; desktop tray keeps the service available after the UI closes |
| Batch TXT Export | Select tasks or select all in the download list, or use Export task information (.txt) from the new-download batch or resolved file list. Available in desktop, Web, Android, and iOS; resolved plugin lists are available in desktop, Web, and full iOS. |
| RSS & Automation | Feed filters, unattended downloads, JavaScript plugins, managed FFmpeg/yt-dlp components and task-event webhooks |
| Remote Devices | Optional FluxCloud account, settings sync and remote task management, plus LAN device pairing and direct connections |
| APIs & CLI | REST/OpenAPI, aria2-compatible JSON-RPC, MCP with 12 tools, and a CLI for scripts or standalone downloads |
Download-list exports include selected tasks from the current host and selected FluxCloud remote tasks, even when only remote tasks are selected. The URL column for a FluxCloud remote task is available only if its source device shares download URLs.
Task exports are UTF-8 text with Name, URL, and Size (bytes) columns separated by tabs. Decode \\, \t, \r, and \n as a backslash, tab, carriage return, and line feed respectively, in a single pass after splitting fields. Unknown values are blank; resolved plugin lists do not expose direct per-file URLs. The desktop and Web clipboard action additionally prefixes text starting with spreadsheet formula markers or a quote (after leading whitespace) with an apostrophe; TXT files do not add that prefix.
New-download batches use explicit out= names first, then available names from the link itself (HTTP(S)/FTP file paths, magnet dn, or eD2k file names). Links without a known name leave that field blank.
A new-download batch exports the byte size declared by an eD2k file link, including 0 for a valid empty file. Links without known size metadata leave the size blank.
Resolved plugin lists export only checked files, including checked files hidden by the current search or filter. The name column contains each file's relative path. Where variant selection is available, an explicitly chosen variant with unknown size leaves the size blank, even if the default item size is known.
Privacy: local downloads do not require a FluxCloud account. Cloud features are optional. Anonymous installation and daily-active statistics are controlled by analytics_enabled and can be disabled; they do not collect download/task information. This is not a zero-telemetry application.
| FluxDown | IDM | |
|---|---|---|
| Price | Free & open source | $24.95 + renewals |
| Open source | Yes (AGPL-3.0) | No |
| Platforms | Windows / macOS / Linux / NAS / Android | Windows only |
| BitTorrent & magnet | Yes | No |
| eD2K / eMule links | Yes | No |
| HLS / DASH streaming | Yes | Partial |
| Dynamic segmentation | Yes | Yes |
| Browser extension | Chrome / Edge / Firefox | Yes |
| Ads | None | — |
Grab the latest build from GitHub Releases or fluxdown.com:
| Platform | Packages |
|---|---|
| Windows (x64 / ARM64) | setup.exe installer · portable .zip |
| macOS (Intel / Apple Silicon) | .dmg · portable .tar.gz |
| Linux (x64) | .AppImage · .deb · Arch .pkg.tar.zst · portable .tar.gz |
| Android (arm64-v8a / armeabi-v7a / x86_64) | per-ABI .apk · universal .apk |
| NAS / Server (headless, x64 / ARM64) | Docker · Synology DSM 6/7 .spk · QNAP .qpkg · OpenWrt .apk (25.12+) / .ipk · Unraid CA template · CasaOS / ZimaOS app store |
Install the extension so FluxDown takes over browser downloads automatically:
The extension connects to the desktop agent through Native Messaging. A Tampermonkey userscript is also available.
The current headless service is fluxdown-agent --server + fluxdownd, with an embedded Web UI. The Docker image retains the name ghcr.io/zerx-lab/fluxdown-server.
From a checkout, use the supplied Compose configuration:
docker compose -f docker/docker-compose.yml up -dOpen http://<server>:17800/ and set an access key in the first-run wizard. The key must contain 8–128 visible ASCII characters, including both a letter and a digit. Set it up on a trusted network before exposing the service; use an HTTPS reverse proxy for remote access.
Browser extension: Viewing remote progress and removing tasks requires the host’s Management API. If an existing Docker deployment can accept downloads but cannot list tasks, open the server’s Web UI, enable Settings → API Service → Management API, then test the connection again in the extension. If you use a reverse proxy, make sure it forwards /api/v1/ requests. Remote Only shows the server automatically; in Desktop First, select Remote server in the task panel. Removing tasks does not delete downloaded files.
iOS: In FluxDown, go to Devices → Add Host switch the mode to Access key (the default is LAN pairing), then enter the server address and access key. Switch to that host, then use Downloads to add tasks, check progress, or remove tasks.
- Server mode listens on
[::]:17800(IPv4 + IPv6, falling back to0.0.0.0without IPv6) by default; override it withFLUXDOWN_BIND. - For unattended setup, supply
FLUXDOWN_TOKENthrough your deployment environment or secret manager, not a committed file. It initializes the key only if one has not already been set. - Persist
/datafor the database, logs and access key, and/root/Downloadsfor downloads. The supplied Compose file uses a named data volume anddocker/downloads/on the host. - Prefer SSD/cache storage for
/dataif download disks need to sleep. - Native deployments must keep
fluxdown-agentandfluxdowndin the same directory.
The fluxdown CLI connects to the running desktop or server HTTP API by default. On desktop, enable the management API in Settings → API Service first. Supply the access key via FLUXDOWN_TOKEN; use FLUXDOWN_URL or --url to select a remote server.
fluxdown ping
fluxdown add "https://example.com/file.zip"
fluxdown --json list
# Standalone mode: embed the engine instead of connecting to a service
fluxdown add --local "https://example.com/file.zip"Standalone mode cannot share a data directory with a running engine: stop the service using that directory first.
| Interface | Endpoint | Purpose |
|---|---|---|
| REST management API | /api/v1/* |
Tasks, queues, RSS and other management operations |
| OpenAPI | /api/v1/openapi.json |
Machine-readable API schema |
| aria2-compatible JSON-RPC | /jsonrpc (HTTP / WebSocket) |
Integration with aria2-compatible clients |
| MCP | /mcp |
AI-agent tools |
| Official UI protocol | /rpc (WebSocket) |
GPUI/Web gateway; distinct from the aria2 API |
Desktop defaults to 127.0.0.1:17800, with management API and MCP disabled until enabled. Server mode enables both by default and requires an access key. See the OpenAPI specification for the REST contract.
FluxDown ships a built-in MCP server so AI agents (Claude Desktop, Cursor, Cline, …) can manage downloads via the Model Context Protocol. It implements a stateless Streamable HTTP subset (JSON-RPC 2.0 over POST /mcp) on the same API port — no separate MCP process needed.
- Endpoint:
http://127.0.0.1:17800/mcpfor the default desktop configuration; use your server address for headless deployments - Auth: Bearer token (
Authorization: Bearer <token>orX-FluxDown-Token), shared with the management API - Enable: Settings → API Service → toggle MCP endpoint (a token is generated automatically); the headless server enables it by default
| Tool | Description |
|---|---|
download_add |
Create a download task (HTTP/HTTPS, FTP, magnet, BitTorrent) |
download_list |
List tasks with progress/speed/status, optional status filter |
download_get |
Get a single task by ID |
download_pause / download_resume |
Pause / resume one task |
download_pause_all / download_resume_all |
Pause / resume all tasks |
download_remove |
Remove a task, optionally deleting downloaded files |
queue_list |
List named queues and their configuration |
rss_list |
List RSS subscriptions with their configuration and runtime state |
rss_add |
Subscribe to an RSS feed and start polling it on a schedule |
rss_remove |
Delete an RSS subscription and the items it collected |
{
"mcpServers": {
"fluxdown": {
"url": "http://127.0.0.1:17800/mcp",
"headers": { "Authorization": "Bearer <your-token>" }
}
}
}The MCP layer is implemented in native/api/src/mcp.rs on top of the same ApiHost trait that powers the REST management API and aria2-compatible JSON-RPC.
One Rust download engine, multiple hosts and clients. Desktop uses fluxdown-desktop → fluxdown-agent → fluxdownd; headless deployments reuse the agent and daemon with a React Web UI. Native Android and iOS clients connect through UniFFI (native/mobile), using an embedded agent and daemon for local downloads or /rpc for remote hosts.
flowchart TD
UI["GPUI desktop"] -->|"WebSocket /rpc"| AGENT["fluxdown-agent — UI gateway and desktop shell"]
WEB["React Web UI"] -->|"WebSocket /rpc"| AGENT
EXT["Browser Extension (WXT)"] -->|Native Messaging| NMH["fluxdown_nmh"]
NMH --> AGENT
CLI["fluxdown CLI"] -->|"HTTP API"| AGENT
AGENT -->|"Authenticated JSON-RPC"| DAEMON["fluxdownd — download core"]
DAEMON --> ENGINE["fluxdown_engine"]
MOBILE["Native Android / iOS"] -->|"UniFFI"| CORE["fluxdown_mobile"]
CORE -->|"embedded or remote"| AGENT
LOCAL["fluxdown add --local"] --> ENGINE
ENGINE --> PROTOCOLS["HTTP/HTTPS, FTP, BitTorrent, eD2K, HLS, DASH"]
ENGINE --> DB[("SQLite / PostgreSQL")]
- Daemon owns downloads: engine, download database, queues, RSS, plugins and webhooks.
- Agent owns integration: UI gateway, FluxCloud account/sync, device collaboration, browser capture and desktop tray/lifecycle.
- Shared contracts:
native/protocoldefines transport-independent DTOs, methods and events;native/apiexposes REST, aria2 and MCP throughApiHost, without depending on the engine. - Engine independence:
EventSinkandHostSelectionconnect the engine to hosts. Only one engine may write to a data directory at a time; the diagram shows alternative hosts, not concurrent writers.
| Layer | Tech | Path |
|---|---|---|
| Desktop UI | Rust + GPUI; app composition and capability crates | crates/, crates/app/ |
| Agent / daemon | UI gateway and headless host / download core | native/agent/, native/daemon/ |
| Shared protocol / HTTP API | JSON-RPC DTOs / REST, aria2, MCP adapters | native/protocol/, native/api/ |
| Download engine | Rust + Tokio, no UI or FFI dependencies | native/engine/ |
| Mobile UI / bridge | Kotlin + Jetpack Compose / SwiftUI + UniFFI | mobile/Android/, mobile/FluxDown/, native/mobile/ |
| Web management UI | React + TypeScript + Vite | web/ |
| CLI | HTTP client or embedded engine | native/cli/ |
| Browser integration | WXT + TypeScript, Native Messaging, userscript | fluxDown/, native/nmh/, userscript/ |
| Website | Astro + React | website-v2/ |
Start with the Rust toolchain and your platform's native build tools (MSVC on Windows, Xcode command-line tools on macOS). Linux desktop builds also need graphics, audio and tray development libraries; the maintained Ubuntu package list is in CI. Bun is needed for the Web UI. Android uses Android Studio's JBR, Android SDK/NDK and cargo-ndk; iOS uses Xcode.
# Clone the development branch (main = active development, stable = stable releases)
git clone -b main https://github.com/zerx-lab/FluxDown.git
cd FluxDown# Build desktop UI, agent, daemon and browser relay, then launch
cargo desktop-dev
# Build only (also stages a signed development .app on macOS)
cargo desktop-dev --build-onlyThe launcher reuses an existing desktop/service instance rather than forcibly restarting it. Quit the UI and stop its services before testing changes to running code.
# Build the Web UI BEFORE building the agent
cd web
bun install --frozen-lockfile
bun run build
cd ..
cargo build -p fluxdown_daemon
cargo run -p fluxdown_agent --features web-ui -- --serverThe web-ui feature embeds web/dist into the agent binary at compile time. After changing the frontend, rebuild the Web UI and then the agent. FLUXDOWN_WEBROOT optionally serves a directory from disk instead.
For frontend development, run cd web && bun run dev in a second terminal while the server is running: Vite listens on port 5173 and proxies backend requests to port 17800.
cargo build -p fluxdown_cli
cargo run -p fluxdown_cli -- pingAndroid lives in mobile/Android; iOS lives in mobile/FluxDown. Both use the shared Rust core in native/mobile and shared translations in assets/i18n.
# Android: use Android Studio's JBR as JAVA_HOME
(cd mobile/Android && ./gradlew :core:testDebugUnitTest :bridge:testDebugUnitTest :app:assembleDebug)
# iOS: from repository root
mobile/FluxDown/scripts/build-core.sh
(cd mobile/FluxDown && xcodebuild build -project FluxDown.xcodeproj -scheme FluxDown -destination 'generic/platform=iOS Simulator')Official Android releases use the native project's ANDROID_NATIVE_* signing credentials. They cannot be installed over the old Flutter APK; back up needed data before uninstalling the old app. The retired Flutter SDK, Rinf and hub are no longer build prerequisites. Shared assets, legacy desktop data/theme upgrade compatibility and the website's legacy theme editor remain supported.
Running tests
cargo test -p fluxdown_engine # Engine tests
cargo test -p fluxdown_api # HTTP / aria2 / MCP contracts
cargo test -p fluxdown_agent # Gateway / server
cargo test -p fluxdown_cli # CLI
cd web && bun test && cd .. # Web UI
cargo test -p fluxdown_mobile # Shared native mobile core- Bug reports / feature requests — GitHub Issues or the website feedback page
- QQ Group — 832143651
Pull requests are welcome! Branch off main and target main — it is the development branch, while stable only tracks stable releases (maintainers advance it from main). Before submitting, please make sure:
cargo fmt --check
cargo clippy --workspace --all-targets -- -D warningsSee CONTRIBUTING.md for the full workflow.
Distributed under the GNU Affero General Public License v3.0.
If FluxDown saves you time, consider giving it a Star — it helps more people discover the project.
Made by zerx-lab