SillyTavern on Android: four roads now, and what each one actually costs

SillyTavern is a Node.js server that happens to draw a chat window. That one architectural fact decides everything about phones: Android treats long-running background processes as a problem to be solved, and a self-hosted web server is exactly the kind of process it solves. Every “SillyTavern on Android” thread is really arguing about a single question. Where should the server live?

When we first published this piece there were three answers; the honest count in mid-2026 is four. On the phone inside Termux. On the phone inside an app that packages the server for you — the “SillyTavern for Android” release threads you may have seen on Reddit are this road, and we will be precise below about what it is and is not. On a rented machine somewhere else. Or nowhere, because a native app replaced the server entirely. Disclosure before anything else: we build Foreverse, the app in that fourth road, so weigh our judgment accordingly. We have tried to describe the other three the way their own communities describe them, because each of the four is the right answer for somebody.

Why is a phone the hard case for SillyTavern?

Desktop SillyTavern assumes a machine that stays awake. The Node server holds your cards, chats and API keys, and a browser talks to it at localhost:8000. Phones break the assumption: Android suspends and kills background work to save battery, so the server half of SillyTavern needs life support (Termux), friendlier packaging (ST-android), different housing (a cloud box), or replacement (a native app).

That is the entire decision tree. Everything below is the concrete version of it.

Road one: Termux, where the install is easy and staying alive is not

The officially documented Android route puts a Linux userland on the phone and runs the server there. Four commands, per the official Termux guide: pkg update && pkg upgrade, then pkg install git nodejs, then git clone https://github.com/SillyTavern/SillyTavern -b release, then ./start.sh and open localhost:8000 in Chrome. Cost: zero dollars, full data ownership, every extension the desktop build has. The bill arrives later, as process management.

The first trap sits before the first command: the Termux build you want comes from F-Droid, not the Play Store, whose listing has been stale for years. That alone filters out the half of the audience that has never sideloaded an app store.

The second trap is the one people write forum posts about at 2am. Since Android 12, the OS enforces a system-wide cap of 32 “phantom” child processes and kills the excess without telling you; a Node server spawned from a shell session is a textbook phantom process. The Termux tracking issue for this, termux-app #2366, has been open for years. The standard workaround needs a PC: adb shell device_config put activity_manager max_phantom_processes 2147483647, and on many devices it quietly reverts after a reboot unless you also disable config syncing. termux-wake-lock and a battery-optimization exemption help with ordinary screen-lock kills, but vendor ROMs from Samsung, Xiaomi and friends layer their own process killers on top of stock Android's, and they do not read your wake lock as a promise.

Updates are a smaller, steadier tax: git pull, reinstall dependencies, wait while native modules rebuild on a phone CPU. If you enjoy terminals, none of this will scare you, and an 8 GB flagship handles the load fine. This road rewards exactly one kind of person: the one who reads a process-lifecycle bug report for fun.

Road two: ST-android, the server in a box

In February 2026 a new option appeared: ST-android, an APK that bundles the unmodified SillyTavern source plus a Node.js runtime patched to run on Android. One tap starts the server, the browser opens by itself, no terminal ever appears. The v0.3.0 release in late February is the one that made the rounds as “SillyTavern for Android is out”. One clarification the headlines skipped, in the project's own words: it is a personal project, not affiliated with or endorsed by SillyTavern. There is still no official SillyTavern app — which also means any Play Store listing wearing the name is a lookalike, not the real thing.

The current release is v0.4.1, published July 26, 2026. The changelog is one line — the bundled SillyTavern moves from 1.17.0 to 1.18.0, Node.js to 24.18.0 LTS — and that one line matters more than it reads. SillyTavern 1.18.0 (May 3, 2026) is the security-hardening release that followed the “Bot Browser” incident, where a malicious third-party extension exfiltrated users' API keys through a pre-1.17.0 vulnerability; among other things it added rate limiting on the login flow, an SSRF address whitelist, and a confirmation prompt before third-party extension installs. ST-android had been carrying the older 1.17.0 bundle since March 31 — nearly four months — so if you run this app, take this update for the patches, not the features. Two days after release the reception was quiet (a single reaction on the release page as of July 28, against roughly 1,443 downloads for v0.4.0 over its lifetime), and nothing in v0.4.1 moves the extension story: installs work, extension updates and several related features remain broken by the project's own account.

What you get is the actual desktop build, so cards, lorebooks, presets and group chats behave exactly as they do on PC, and the import story is genuinely good: it accepts the full user backup that SillyTavern's own UI exports (User Settings → Download Backup), plus a one-liner script for Termux migrants. Unlike Termux it works in Private Space and Secure Folder, and the incantation-grade process babysitting mostly disappears: the app manages the server's lifecycle itself instead of leaving it as a shell's orphan. It also ships a battery-exemption switch right in the settings, which tells you the honest half: this is still a server living on a phone, and Android still gets a vote when you background it.

The costs, plainly. The README scopes itself to “basic on-device chatting” and says extensions are not properly supported yet — installs work on the bundled 1.17+, but extension updates and several related features remain broken per its own changelog. The APK is a ~170 MB sideload from GitHub Releases, arm64 and Android 8+ only. And it is one volunteer's project, months old: the code is AGPL and the release pipeline is clean, but nobody owes you a fix on any particular Tuesday. If your setup is the stock feature set and your tolerance for terminals is zero, this road quietly replaces road one. If your workflow leans on an extension stack, it does not, yet.

Road three: the cloud, where battery problems become ops problems

Host SillyTavern on a small VPS for $3–6 a month and every phone limitation disappears at once. The server never sleeps, any browser can reach it, chats and cards follow you across devices. The trade: you now administer a public web server that holds your API keys, and the configuration that keeps strangers out is your job, not a default.

Out of the box SillyTavern only answers localhost. Opening it to your phone means setting listen: true, dealing with the IP whitelist that is on by default, and enabling basicAuthMode so the login page exists at all; the official docs walk through each switch, and they are blunt about why. Port scanners find naked instances. An unauthenticated tavern on a public IP is somebody else's free API key the day it is discovered.

Latency, the objection people expect, mostly is not one: the model call leaves from the server, so the phone only pushes UI traffic. The real recurring cost is quieter. Distro updates, a Node upgrade that breaks the build, a disk that fills with chat logs and generated images, a TLS certificate that expires on a weekend. None of it is hard. All of it is yours. This road fits people who already run a VPS for something else, anyone living across three devices, and every iPhone user, since iOS has neither a Termux equivalent nor an ST-android.

Road four: a native app, where the server stops existing

A native tavern app ships the chat runtime inside an ordinary Android app. No Node process anywhere, not even a packaged one: nothing to keep alive, no VPS invoice, and the phone's process manager has nothing to kill. The evaluation question changes shape: not “will it stay up?” but “does my stuff import?” Cards, lorebooks, presets, regex pipelines, group chats, and the API keys you bring with you.

Concretely, for our own entry in this lane: Foreverse imports PNG cards (v2 and v3 chara chunks), JSON cards, and .charx archives; lorebooks both embedded and standalone, including chara_card_v3 decorators; presets; regex scripts; SillyTavern group chat JSON; and cards fetched straight from a Chub, JanitorAI, Pygmalion or RisuRealm URL. We regression-test that claim against a collection of 1,500+ community files across 38 categories; in the last breadth matrix we drew from it, all 30 character cards imported 30/30 and rendered their opening screens 30/30, old English V1 relics included. Keys are BYOK across 62 providers, encrypted on the device, with calls streaming directly to the provider you configured.

The honest gap: there is no third-party extension runtime here either, and unlike ST-android this is not the desktop codebase — it is a reimplementation of the format stack. A desktop install with a hand-picked extension stack still wins any feature-checklist fight, and a few power features, vector-storage lorebooks and exact per-model token budgeting among them, are approximations on mobile today. Before switching, write down the three extensions you cannot live without and check each one by name. If one of them is load-bearing for your workflow, roads one and three are still your roads — ST-android shares this same gap for now.

How do you choose without locking yourself in?

Choose by the failure you are most willing to debug: process death (Termux), a young single-maintainer app and half-supported extensions (ST-android), server administration (cloud), or a missing desktop extension (native app). The choice is lower-stakes than it looks, because the tavern ecosystem's file formats are the portable part. Cards move as PNG, JSON or charx; lorebooks as World Info JSON; presets and regex as JSON. Only chat histories need care.

Our own answer is on record and biased: we built road four because we kept watching the same story — someone installs Termux, it works, a screen lock eats a session mid-scene, they post the phantom-process incantation, it reverts after a reboot, they give up or rent a VPS. ST-android is the first project to attack that story from inside the server-on-phone premise, and for stock-feature chatting it is a real answer. Foreverse removes the premise instead: no server to defend, in exchange for a decade of desktop extensions we have not replicated, and we would rather say that here than have you discover it after the move.