Gopeed: a Go and Flutter download manager for HTTP, BitTorrent, magnet and ed2k

What Gopeed replaces, and for whom

Most download tools pick one side of a line. HTTP accelerators handle direct links and stop there. BitTorrent clients handle torrents and magnets but treat a plain URL as an afterthought. Gopeed sits on both sides: the README lists HTTP, HTTPS, BitTorrent, magnet links and ed2k as supported protocols in a single application, on desktop, mobile and the web.

The intended user is someone who moves files from several kinds of source and does not want three programs open. The README also lists browser integration, JavaScript extensions, a REST API, a CLI and a self-hosted web UI, which points at a second audience: people who want downloads to run on a server or a NAS and be driven by scripts rather than by clicking. The docker-compose.yml file in the repository is written for exactly that case, with a mounted download path and an optional username and password on the command line.

The project is GPL-3.0. That matters more for anyone embedding or redistributing it than for someone installing a desktop client, but it is worth reading before you build it into a product.

The Go core, the Flutter shell, and how they talk

The repository is split into a Go back end and a Flutter front end. The README states that the front-end source lives in the ui/flutter directory, and that the two halves communicate over HTTP, using Unix sockets on Unix-like systems and TCP on Windows. That is the architecture in one sentence: the download engine is a Go process, and the interface is a client of it.

The dependency list in go.mod shows what the engine is built from. BitTorrent comes from github.com/anacrolix/torrent, ed2k from github.com/monkeyWie/goed2k, and the MCP server side from github.com/modelcontextprotocol/go-sdk. Task state is stored with go.etcd.io/bbolt, a key-value store, which is consistent with the README's claim that tasks recover after a restart. JavaScript extensions run on github.com/dop251/goja, a Go implementation of JavaScript, with goja_nodejs alongside it. HTTP work uses github.com/imroc/req/v3, and archive extraction uses github.com/mholt/archives together with github.com/bodgit/sevenzip.

The 2.0.0 beta changes the transport. The README describes the beta as introducing a native communication architecture that connects desktop and mobile clients directly to the Go core through FFI, rather than over HTTP. That is a real shift in how the pieces are wired, and it is the kind of change that explains why the beta line exists at all.

Installing Gopeed and running a first download

There is no single install command that covers every platform. The README points at gopeed.com for the official download and at GitHub Releases for the latest stable build, and it lists Windows, macOS, Linux, Android, iOS and the web as targets. The 2.0.0 beta is distributed separately: the README links to the v2.0.0-beta.3 release and notes that beta users can upgrade directly to the final release, while existing stable users will not be moved onto the beta channel automatically.

If you want the command-line tool, the README gives one command. It requires Go 1.25 or later, which the README states as the first environment requirement:

 go install github.com/GopeedLab/gopeed/cmd/gopeed@latest

After that, the gopeed binary is on your Go bin path. The README does not document its flags, so treat the CLI as something to inspect with its own help output rather than something the documentation walks you through.

For a server or NAS, the repository ships a docker-compose.yml. The service maps port 9999 from host to container, mounts ~/gopeed/Downloads at /app/Downloads, and sets PUID, PGID and UMASK:

services:
    gopeed:
      container_name: gopeed
      ports:
        - 9999:9999 # HTTP port (host:container)
      environment:
        - PUID=0
        - PGID=0
        - UMASK=022
      volumes:
        - ~/gopeed/Downloads:/app/Downloads # mount download path
      restart: unless-stopped
      image: liwei2633/gopeed
      # command: -u Username -p Password # optional authentication

Bring it up with docker compose up, then open port 9999 in a browser. The commented command line is the authentication switch; if you expose the port beyond your own network, that comment is the line to uncomment. The Dockerfile behind the image exposes 9999 as well, declares /app/storage as a volume, and runs the build with the nosqlite and web tags, so the container serves the web UI rather than a desktop shell.

Extensions, MCP and the automation surface

Gopeed's extension system is JavaScript, executed by goja inside the Go process. The README describes extensions as a way to add support for video platforms, AI model hubs, cloud storage services and other download sources. That is a broader claim than a typical browser-download shim: an extension is code that resolves a URL into something the engine can fetch.

The same idea appears in the MCP integration, but with a schema. The README lists nine tools exposed to compatible AI agents: resolve_task, create_task, list_tasks, get_task, get_task_status, get_task_stats, pause_task, continue_task and delete_task. The split is deliberate. resolve_task returns resource metadata and files before anything is created, which lets an agent inspect a link before committing to it. get_task_status is described as lightweight runtime status with per-file progress, while get_task_stats returns protocol-specific numbers such as HTTP connections or BitTorrent peers and seeding data. The README's example instruction is to download the latest Gopeed client for Windows.

For anything that is not an AI agent, the README lists a REST API, a CLI, webhooks and post-download scripts. The README does not document the REST endpoints or the webhook payload shape, so those are things you discover from the running server rather than from the front page.

Where Gopeed is the wrong tool

The most concrete limitation is stated by the project itself. Gopeed 2.0.0 is in public beta, and the README says plainly that some features may still be incomplete or unstable and asks users to report issues. If your requirement is a download client that does not change under you, the beta channel is not it, and the stable release is the one to install.

The second limitation is packaging. The README does not describe apt, Homebrew, winget or Play Store installation paths. It points at gopeed.com, GitHub Releases, Docker and go install. On a managed fleet where software must come from a distribution repository, that is friction you have to solve yourself, and the README does not solve it for you.

The third is documentation depth. The CLI is introduced with a single install command and no flag reference. The REST API, webhooks and post-download scripts are named but not specified in the README. The AI tool table is the most detailed interface documentation in the file, which is an odd distribution of effort: the newest surface is described best.

Finally, if all you download is a handful of direct HTTP links, a download manager with a BitTorrent stack, an ed2k implementation and a JavaScript runtime is a lot of moving parts for the job. The README does not document a way to build a stripped-down variant.

Gopeed against qBittorrent and Free Download Manager

The comparison that matters depends on which half of Gopeed you actually need. Against qBittorrent, the difference is scope. qBittorrent is a BitTorrent client; Gopeed treats torrents as one of several protocols and puts HTTP, magnet and ed2k in the same task list. If your work is seeding and ratio management, that focus is a feature, not a gap. Gopeed does list DHT peer discovery, uTP transport, Web Seeds, selective file downloads, tracker management, peer and piece statistics, and ratio- or time-based seeding limits, so the BitTorrent side is not a stub, but the product's centre of gravity is elsewhere.

Against Free Download Manager, the difference is the interface stack and the licence. Gopeed renders its interface with Flutter and the README makes a point of the absence of Electron and a WebView shell, describing a smaller footprint and lower overhead. Free Download Manager is not open source in the same way, and Gopeed is GPL-3.0. If you need to audit or modify the client, that distinction decides the choice before any feature comparison does.

There is also a self-hosting axis. Gopeed ships a Dockerfile, a docker-compose.yml and a web build, so the same engine can run headless on a server with the Flutter UI served in a browser. A desktop-only download manager does not give you that option at all.

Maintenance, upgrade cost and the GPL-3.0 terms

The repository is not archived, and the last push was on 2026-09-20, one day before this writing. Releases are frequent: v2.0.0-beta.1 on 2026-09-05, beta.2 on 2026-09-11 and beta.3 on 2026-09-18. That cadence tells you the beta line is moving quickly, and it also tells you the upgrade cost: if you track the beta, expect to re-test after each one.

The README addresses one upgrade path directly. Beta users will be able to upgrade to the final 2.0.0 release, and stable users will not be moved onto the beta channel automatically. So the two channels are separate by design, and choosing the beta is a deliberate opt-in rather than a default.

Licence-wise, the repository carries GPL-3.0. That is a copyleft licence, and it applies to the whole project rather than to individual files. If you plan to redistribute a modified Gopeed, or to link it into a product you ship, the terms are the thing to read before you write code, not after. Nothing here is legal advice; the LICENSE file in the repository root is the authoritative text.

The build requirements are worth noting as a cost. The README lists Go 1.25+ and Flutter 3.41+ for development, and go.mod pins Go 1.25.4. Building the desktop or mobile clients means keeping a Flutter toolchain current alongside a Go toolchain, which is two upgrade tracks rather than one.

Editorial conclusion

Adopt Gopeed if you want one client for HTTP, BitTorrent, magnet and ed2k across desktop, mobile and a self-hosted web UI, and you are willing to file bugs against a beta. Do not adopt it if you need a long-term-stable release channel or a headless package from your distribution's own repositories, because the README points at gopeed.com, GitHub Releases, Docker and go install instead. Verify first that the 2.0.0 beta covers the protocols and platforms you need, and that the GPL-3.0 terms fit how you plan to redistribute it.

Frequently asked questions

Official sources

1. GopeedLab/gopeed on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases