Learn Aria2 - Web UI & Frontend Ecosystem

#Introduction

In episode 15 you talked to the RPC daemon with curl and jq — precise, but not friendly for daily operations. Managing a dozen downloads through the terminal is satisfying, but when there's a dashboard that shows everything on one screen, why not? Episode 16 brings aria2 to the browser: AriaNg as the web interface, and browser extensions that send downloads straight to the daemon.

Keep this in mind throughout the episode: every tool we install is just an RPC client. They don't replace the daemon, don't change how aria2 works, and don't free you from episode 14's security rules — they only give a more human face to the JSON-RPC language you've already mastered.

#AriaNg: Dashboard in the Browser

AriaNg is a lightweight single-page web application: all code runs in the browser, and it talks to the daemon directly over JSON-RPC. No application server, no database, no extra background processes — just one set of static files you can open anywhere. It's an elegant design: aria2 remains the only running process, and AriaNg is just a window to look at it.

#Setting Up AriaNg

AriaNg is distributed as a zip archive from its official releases (mayswind/AriaNg). Install it into any directory, then serve it as static files:

mkdir -p ~/ariang && cd ~/ariang
curl -L -o ariang.zip \
  https://github.com/mayswind/AriaNg/releases/download/1.3.7/AriaNg-1.3.7.zip
unzip ariang.zip
python3 -m http.server 8080

After the commands above run, open a browser to http://127.0.0.1:8080 — AriaNg appears without any extra installation. Note that python3 -m http.server is just a static file server; it can be replaced with any server capable of serving files, including nginx on a production machine.

#Connecting to the Daemon: Host, Port, and Token

AriaNg doesn't yet know where your daemon is. In the AriaNg interface, open Settings → RPC, then fill in three things:

• Host — 127.0.0.1 (or the address of the machine where the daemon runs).
• Port — 6800, the RPC daemon's standard port.
• Secret token — the value r4h4s1a-panjang-acak-123, exactly matching the daemon's --rpc-secret.

Save the settings, and AriaNg stores them in the browser's localStorage — each time you reopen it, it connects right away. If the daemon uses a token, don't forget to fill it in; without it, every request is rejected (remember episode 14).

#Making Sure the Daemon Is Reachable

Before opening AriaNg, check that the RPC endpoint is alive and accepts the token — a single curl command is enough:

curl -s http://127.0.0.1:6800/jsonrpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":"cek","method":"aria2.getVersion","params":["token:rahasia-panjang-acak"]}' \
  | jq '.result.version'

If the response shows the aria2 version, the connection is healthy and AriaNg will work immediately. If it's rejected, the cause is usually one of three: the daemon isn't running, the port isn't 6800, or the token doesn't exactly match --rpc-secret — the same debugging sequence as in episode 15. aria2.getVersion is the lightest method for testing a connection: it changes nothing, just answers with the daemon's identity.

#Adding and Managing Downloads from the Browser

With the connection active, AriaNg becomes a control center:

• Add downloads — paste one or several URLs into the Add box, set the directory and file name if needed, then run. AriaNg sends aria2.addUri to the daemon — exactly the request you sent manually in episode 15.
• Torrent — upload a .torrent file or paste a magnet link; the daemon handles BitTorrent like in episode 10.
• Control — pause, resume, and remove downloads from the list; every action maps to a method like aria2.pause and aria2.remove.
• Status — every download shows progress, speed, and remaining time in real time, plus a global speed graph for the whole daemon.

The interesting part: nothing changes on the daemon side. AriaNg is just a visual wrapper over the same RPC methods — if you master JSON-RPC, you already master AriaNg's logic.

#Browser Extensions: Download Delegation

The most practical part of this ecosystem: browsers normally download files with their own limited internal download manager. With extensions like Download with Aria2 (Chrome and Firefox) or Aria2 Explorer (Firefox), one right-click is enough to route a link to the aria2 daemon — complete with multi-connection, resume, and better speed.

The way it works is the same as AriaNg: the extension is an RPC client inside the browser. It reads the URL you clicked, wraps it into an aria2.addUri, and sends it to the daemon. The browser never downloads the file; aria2 downloads it, and the browser is just the entry point.

#Configuring the Extension

The setup is almost identical to AriaNg. In the extension's options page, fill in:

• RPC URL — http://127.0.0.1:6800/jsonrpc.
• Secret token — the same token as the daemon.

After that, right-click a link and choose the extension's menu (for example Send to Aria2). The download starts appearing in the daemon — and in AriaNg — without ever touching the browser's download manager.

#Other RPC Client Ecosystem

AriaNg isn't the only window. Because the language used is JSON-RPC (episode 15), any client that can speak JSON-RPC can control the same daemon. Some popular ones:

| Client | Form | Notes | | AriaNg | Web | Lightweight, single-page, just static files | | webui-aria2 | Web | Classic web-based UI, also just static files | | Motrix | Desktop | A cross-platform app wrapping aria2 |

What they share: all are clients, not servers. Not one adds a process on the daemon side — and that's the strength of the RPC architecture we've been building since episode 3. If you can swap interfaces without touching the daemon, you're holding a mature service.

#Security Still Applies

A pretty web interface can make us forget there's still an RPC port behind it. Nothing changes from episode 14: loopback is safer than all interfaces, a long token remains mandatory, and the RPC port must not be visible to the internet without an encrypted tunnel or HTTPS proxy. AriaNg doesn't replace the security gate — it just changes how we knock on it.

#Closing

Episode 16 brought aria2 into the visual world: installing AriaNg as a browser-based dashboard, connecting it to the RPC daemon complete with a token, managing downloads through a friendly interface, and integrating browser extensions so download clicks get routed to the daemon.

The key thing to remember: all these frontend tools are RPC clients — the same face of the JSON-RPC language you've already mastered. One token, one daemon, and now many ways to talk to it.

In the next episode, episode 17, we tune the engine: performance & optimization — choosing the right numbers for parallel connections and chunk size, limiting speed to be polite, and managing the daemon's light resource usage and file allocation to reduce fragmentation. See you then!