FluxDown

Downloads, Supercharged.

A blazing fast, multi-protocol download manager — the free & open-source IDM alternative.

Website · Download · Changelog · FAQ · Feedback

English | 简体中文

Highlights

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, Flutter Android app, 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

Features

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
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
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

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 vs. IDM

	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	—

Installation

Grab the latest build from GitHub Releases or fluxdown.zerx.dev:

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 `.ipk` · Unraid CA template · CasaOS / ZimaOS app store

Browser Extension

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.

NAS / Server

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 -d

Open 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.

Server mode listens on 0.0.0.0:17800 by default; override it with FLUXDOWN_BIND.
For unattended setup, supply FLUXDOWN_TOKEN through your deployment environment or secret manager, not a committed file. It initializes the key only if one has not already been set.
Persist /data for the database, logs and access key, and /root/Downloads for downloads. The supplied Compose file uses a named data volume and docker/downloads/ on the host.
Prefer SSD/cache storage for /data if download disks need to sleep.
Native deployments must keep fluxdown-agent and fluxdownd in the same directory. The old native/server crate is frozen and is not the deployment entry point.

CLI & HTTP APIs

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.

MCP Server (Model Context Protocol)

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/mcp for the default desktop configuration; use your server address for headless deployments
Auth: Bearer token (Authorization: Bearer <token> or X-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

Tools (12)

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

Client configuration

{
  "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.

Architecture

One Rust download engine, multiple hosts and clients. Desktop releases use GPUI, not Flutter. The desktop chain is fluxdown-desktop → fluxdown-agent → fluxdownd; headless deployments reuse the agent and daemon with a React Web UI. Flutter remains the mobile client, connected to its hub host through Rinf.

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["Flutter mobile"] -->|"Rinf signals"| HUB["hub — mobile host"]
    HUB --> ENGINE["fluxdown_engine"]
    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/protocol defines transport-independent DTOs, methods and events; native/api exposes REST, aria2 and MCP through ApiHost, without depending on the engine.
Engine independence: EventSink and HostSelection connect 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 / host	Flutter + shadcn_ui / Rinf	`lib/`, `native/hub/`
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/` is the legacy archive	`website-v2/`

Building from Source

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; Flutter and Rinf are needed only for mobile, not GPUI desktop.

# Clone the development branch (main = active development, stable = stable releases)
git clone -b main https://github.com/zerx-lab/FluxDown.git
cd FluxDown

Desktop (GPUI)

# 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-only

The 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.

Headless server & Web UI

# 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 -- --server

The 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.

CLI

cargo build -p fluxdown_cli
cargo run -p fluxdown_cli -- ping

Mobile (Flutter)

Install the Flutter SDK and the Android SDK (or Xcode for iOS development).

cargo install rinf_cli
flutter pub get
rinf gen
flutter run -d "<mobile-device-id>"
flutter build apk --release

Android APKs are published by CI. iOS source is present, but there is no current iOS release job. Flutter desktop runners are no longer part of the desktop build.

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
flutter test                        # Mobile Dart tests

Contributing & Community

Bug reports / feature requests — GitHub Issues or the in-app feedback dialog
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 --exclude fluxdown_server --all-targets -- -D warnings
flutter analyze                     # When changing mobile Dart code

See CONTRIBUTING.md for the full workflow.

License

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

Name		Name	Last commit message	Last commit date
.cargo		.cargo
.github		.github
.omp		.omp
android		android
assets		assets
crates		crates
docker		docker
examples/plugins		examples/plugins
fluxDown		fluxDown
installer/windows		installer/windows
ios		ios
lib		lib
mobile		mobile
native		native
packaging		packaging
promotion		promotion
scripts		scripts
test		test
third_party/librqbit-dualstack-sockets		third_party/librqbit-dualstack-sockets
userscript		userscript
web		web
website-v2		website-v2
website		website
.dockerignore		.dockerignore
.editorconfig		.editorconfig
.env.example		.env.example
.git-blame-ignore-revs		.git-blame-ignore-revs
.gitattributes		.gitattributes
.gitignore		.gitignore
.opencommit-commitlint		.opencommit-commitlint
AGENTS.md		AGENTS.md
CONTRIBUTING.md		CONTRIBUTING.md
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
LICENSE		LICENSE
README.md		README.md
README.zh-CN.md		README.zh-CN.md
analysis_options.yaml		analysis_options.yaml
bun.lock		bun.lock
cliff.toml		cliff.toml
clippy.toml		clippy.toml
glama.json		glama.json
logo.png		logo.png
package.json		package.json
pubspec.lock		pubspec.lock
pubspec.yaml		pubspec.yaml

Navigation Menu

Repository files navigation

FluxDown

Downloads, Supercharged.

Highlights

Features

FluxDown vs. IDM

Installation

Browser Extension

NAS / Server

CLI & HTTP APIs

MCP Server (Model Context Protocol)

Tools (12)

Client configuration

Architecture

Building from Source

Desktop (GPUI)

Headless server & Web UI

CLI

Mobile (Flutter)

Contributing & Community

License

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

FluxDown

Downloads, Supercharged.

Highlights

Features

FluxDown vs. IDM

Installation

Browser Extension

NAS / Server

CLI & HTTP APIs

MCP Server (Model Context Protocol)

Tools (12)

Client configuration

Architecture

Building from Source

Desktop (GPUI)

Headless server & Web UI

CLI

Mobile (Flutter)

Contributing & Community

License

About

Resources

Contributing

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages