dango is a lightweight, self-hosted Node.js application built for querying anime metadata, managing personal watchlists, and logging viewing progress through a fast local interface.
- Hardware Efficient: Engineered with a minimal footprint to run effortlessly on low-spec hardware, SBCs, and mobile environments.
- Metadata & Discovery: Browse trending titles, search catalog entries, and view release schedules locally.
- Multi-Provider Playback: Switch seamlessly between multiple third-party streaming providers directly within the player interface.
- Watch Along: Create a room below a direct HLS anime, TV, or movie player and share the invite. Each viewer uses their own Dango; the host controls playback. No port forwarding needed. End the room when finished, or it expires after six hours.
- Watchlist Tracking: Categorize titles (Watching, Completed, Plan to Watch) with fine-grained progress states.
- Library Insights: Built-in dashboard tracking viewing habits, personal stats, and completion ratios.
- Trackers & Sync: Bi-directional AniList and MyAnimeList sync for anime and manga, plus username and XML list imports.
- Expanded Media Hub: Dedicated interfaces for Manga, ASMR, and TV/Movies.
- LAN Security: Optional LAN authentication with password enforcement for multi-device local network deployments.
- Profiles: Separate libraries, tracker/cloud connections and preferences, with optional profile passwords and custom images.
Be part of the dango community where you can connect with fellow users, ask questions, and share your experiences:
| Requirement | Supported Version | Notes |
|---|---|---|
| Node.js | >= 22.12.0 |
Required runtime (Download) |
| npm | Bundled with Node | Global install (npm install -g @serifpersia/dango) |
| pnpm | 11 (npm i -g pnpm) |
Only needed for source development (run.bat / run.sh) |
Install the global CLI binary via npm:
npm install -g @serifpersia/dangoLaunch the interface from anywhere:
dangoImportant
Once the server initializes, navigate to http://localhost:3000 in your browser (or whatever PORT you set, see Manual Setup). The background process runs locally until terminated (Ctrl + C or q key press as well as window X button closing action).
No npm install needed - dependencies ship inside the zip, client is prebuilt:
- Download and extract
dango.zipfrom Releases. - Install Node.js 22.12+ (
node --versionto check). - Launch using
run.bat(Windows) or./run.sh(Linux/macOS), then openhttp://localhost:3000(http://localhost:$PORTif you changed it).
Option 1: Termux Environment
Run standard dango via Termux:
Option 2: Standalone APK
A standalone bundle packaging Node.js, dango, and a local WebView container.
- From Releases, download the APK matching your device:
-arm64-v8a.apkfor almost all modern phones, or-armeabi-v7a.apkfor older 32-bit devices. - Install the APK (allow Install from Unknown Sources when prompted).
- Open the app. Core runtimes auto-provision on first launch.
Updating from the old universal APK requires one manual install of the matching per-ABI APK. In-app updates work normally after that.
Compiling from Source:
cd android-app
python fetch-termux-node.py
# Windows
build-debug.bat
# Linux / macOS
chmod +x build-debug.sh && ./build-debug.shBuild requirements: Python 3, JDK 17+, Android SDK (Platform 36, Build-Tools 36.0.0).
The project is structured as a pnpm workspace (client and server) managed by a unified lockfile. You need Node.js 22.12+ and pnpm 11 (npm install -g pnpm).
# Clone the repository
git clone https://github.com/serifpersia/dango.git
cd dango
# Install dependencies (root + workspaces)
pnpm install
# Compile workspaces (Vite frontend + tsc backend)
pnpm run buildRun via interactive environment scripts:
# Linux / macOS
chmod +x run.sh && ./run.sh
# Windows
run.batSet PORT to change the backend port (default: 3000) and DEV_PORT to change the Vite
frontend port (default: 5173). The dev proxy and the Google OAuth callback follow both
values automatically. They are read from the environment of the process you launch, not
from dango's .env, so export them in the shell before starting:
PORT=4000 DEV_PORT=5174 pnpm run dev
PORT=4000 pnpm startYou can also set ports as launch options. These override the corresponding environment variables:
dango --port 4000
dango dev --port 4000 --dev-port 5174
# From a source checkout:
pnpm start --port 4000
pnpm run dev --port 4000 --dev-port 5174OAuth callbacks follow the port, and redirect URIs are registered with the provider:
| Provider | Registered redirect URIs |
|---|---|
| AniList | http://localhost:3000/api/tracker/anilist/callback |
http://localhost:3000/api/auth/google/callback and http://localhost:5173/api/auth/google/callback (dev) |
Sign-in breaks with redirect_uri_mismatch when the port you run on is not on that list, so
a custom port needs your own AniList client and your own Google OAuth client (see Settings).
GitHub uses the device flow and rclone needs no local port, so both keep working on any port.
| Command | Action |
|---|---|
dango |
Start the installed client daemon |
dango --version |
Display current installed version |
pnpm run dev |
Start full dev stack via orchestrator.js |
pnpm --filter dango-client run dev |
Run Vite frontend independently |
pnpm --filter dango-server run dev |
Run backend via tsx watch |
pnpm -r run lint |
Run ESLint passes across all packages |
dango stores SQLite databases, cached indices, and credentials in the OS application data registry rather than the global node_modules path:
| Platform | Default Path |
|---|---|
| Windows | %APPDATA%\dango |
| macOS | ~/Library/Application Support/dango |
| Linux | $XDG_DATA_HOME/dango or ~/.local/share/dango |
Important
Legacy installs will automatically migrate .env variables and SQLite records from older server/ structures into the proper user directory on launch.
dango is local-first: primary application state lives in your local SQLite store. Cloud syncing creates point-in-time JSON snapshots to maintain seamless backups across multiple installations.
Sync Priority Engine:
[1] GitHub Sync ──(fallback)──> [2] Google Drive ──(fallback)──> [3] Rclone
- Open Settings → Synchronization.
- Click Sign in with GitHub.
- Authorize via the OAuth device code flow.
dango creates a private repository named dango-sync-data to read/write JSON snapshots (sync.json for production, sync.dev.json for development).
- Open Settings → Synchronization.
- Click Sign in with Google and authorize permissions.
Data writes directly to a sandbox appDataFolder on your personal Drive. To clear backups, revoke app permissions under Google Drive's Manage Apps menu.
Important
Advanced users can supply their own custom Github and Google OAuth Client ID & Secret in settings.
Used as a manual fallback for services like Mega, Dropbox, or custom WebDAV:
- Ensure
rcloneis installed and mapped to your systemPATH. - Configure your desired target via
rclone config. - Pick your configured remote profile inside Settings → Synchronization.
Bidirectional sync for anime and manga. Go to Trackers, connect, then Sync Now (anime) / Start Sync (manga). Progress and statuses merge both ways; remote-only entries import, local-only entries push. AniList requires no setup.
Release builds use Dango's auth worker (no setup). For your own app, create one at MAL API settings, register your-origin/api/tracker/mal/callback, and paste client ID/secret in Trackers (or set MAL_CLIENT_ID/MAL_CLIENT_SECRET). MAL needs the secret even with PKCE. MAL_AUTH_WORKER_URL points self-built releases at a worker.
Sync Now merges your authenticated list both ways. Remote-only entries import, local-only push, missing entries are never deleted. Unmatched titles are reported, not guessed. Username and XML imports work without login. Manga sync links by exact title first, then searches up to 25 unlinked titles per sync.
Progress is pushed on Sync Now (and on playback once an episode reaches 80% for the active tracker). MAL tokens refresh automatically; credentials stay on this server and are excluded from library exports. Disconnect removes local tokens. Server needs HTTPS access to myanimelist.net, api.myanimelist.net, and graphql.anilist.co.
dango is an open-source, local-first web app. It does not host or distribute unauthorized media or copyrighted video assets. Users are solely responsible for ensuring their usage aligns with relevant local laws and digital copyright regulations.
Distributed under the terms of the MIT License.

