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.

For the simplest Foreverse path, choose your Android or iPhone download, import one character card, and check its opening message and lorebook before moving a larger library. Foreverse is an independent native app, not an official SillyTavern client. The deployment routes below matter when you specifically need the original server environment; dated project versions are historical examples, not a claim that we rechecked every release in October.

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, Wivern, ST-Ctrl), 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: the server in a box — ST-android, and now Wivern and ST-Ctrl

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 release that matters is v0.4.1, published July 26, 2026 (v0.5.0 followed on July 29 with quality-of-life additions — optional data-folder access for external file managers — on the same core). The v0.4.1 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.

When we last updated this piece, ST-android was alone on this road. The honest 2026 count is three, and the other two bracket it from opposite sides. Wivern is the maximalist: a genuine fork that packages the entire SillyTavern — server, frontend, and extensions, which ST-android still half-supports — on a nodejs-mobile runtime, with the UI in a native WebView. The asterisk is the calendar: its latest release, v1.16.0-fix, landed March 7, 2026, and the repo has been quiet since — so it still carries SillyTavern 1.16.0, two versions behind the 1.18.0 security-hardening release that the Bot Browser incident made non-optional. Full extension support on an unpatched core is a trade you should make with open eyes, if at all.

ST-Ctrl, published June 2026, is the operator's take: a Kotlin/Compose shell (MIT-licensed, Chinese-language UI) around a bundled Node.js runtime plus the real SillyTavern (1.18.0), wrapped in an actual management console — third-party extension installs from a GitHub URL or zip with update detection, full backup and restore, four performance modes, LAN access from a desktop browser, and online updates for both the app and the bundled ST core. It is the youngest of the three and the only one that treats “a server lives on this phone” as an ops problem deserving tooling. If you read Chinese, it is a packager worth evaluating against those requirements. Check maintenance and security updates before using any of them. The family shares one fact: these are single-maintainer community projects, and the SillyTavern team endorses none of them.

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 needing the same server workspace across several devices. iPhone users also have a native Foreverse app option in supported App Store regions; remote hosting is not a prerequisite for importing cards and chatting on iPhone.

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

A native tavern app runs its own chat interface on the phone instead of asking you to maintain a Node.js server. Foreverse is available on Android and iPhone, subject to store-region availability. Mobile background limits still exist; removing a server does not make an app immune to suspension. The useful first test is whether your cards, lorebooks, and required behaviors work in the target app version.

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 compatibility boundary is important: Foreverse is not the desktop SillyTavern codebase, and a SillyTavern extension package is not automatically a Foreverse plugin. Foreverse has its own plugin capabilities; check the current roleplay feature list and your target platform. Write down the extensions you actually depend on and test them by name. A required extension may still justify keeping your existing server environment, without implying that every native workflow is inferior.

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 — with half-supported extensions (ST-android), a stalled update train (Wivern), or a two-month track record (ST-Ctrl) — 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. We also keep a one-page map of all ten mobile options — both families, with status dates — updated as the field moves.

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. The packager family — ST-android first, now Wivern and ST-Ctrl — attacks that story from inside the server-on-phone premise, and for stock-feature chatting it is a different trade-off. Foreverse removes the need to maintain that server for its supported workflows. Try one card and its lorebook in Foreverse, keep a backup of the original, and verify any extension or chat-history requirement separately.