Originally published on the Foreverse blog.
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?
Three answers exist in 2026: on the phone itself inside Termux, 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 third road, so weigh our judgment accordingly. We have tried to describe the first two roads the way their own communities describe them, because each of the three 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), 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 official 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
pkg install git nodejs
git clone https://github.com/SillyTavern/SillyTavern -b release
cd SillyTavern && ./start.sh
Then 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 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 no Termux equivalent at all.
Road three: a native app, where the server stops existing
A native tavern app ships the chat runtime inside an ordinary Android app. No Node process, no Termux session to babysit, no VPS invoice. 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. 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 two are still your roads.
How do you choose without locking yourself in?
Choose by the failure you are most willing to debug: process death (Termux), 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.
Keep the exit open. Before you commit to any road, export your cards as original PNGs and your lorebooks as JSON, and park a copy somewhere that is not the phone. We wrote a separate walkthrough on moving a SillyTavern data folder; the short version is that the formats are the contract, and any road that honors them is reversible.
Our own answer is on record and biased: we built road three 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. Foreverse removes the process Android wants to kill instead of defending it. What it does not yet do is replicate a decade of desktop extensions, and we would rather say that here than have you discover it after the move.
FAQ
Can I run SillyTavern on Android without Termux or a server?
Not the desktop build itself: it is a Node.js application and needs a Node runtime somewhere. What you can do is run a natively built tavern-style app that reads the same files (PNG/JSON/charx character cards, World Info JSON lorebooks, presets, regex scripts) and keeps everything on the phone. Check the app's import coverage against your own library before committing.
What is Android's phantom process killer, and can I turn it off?
Since Android 12, the OS caps background child processes (like a Node server spawned inside Termux) at 32 system-wide and silently kills the excess. You can raise the cap with adb from a PC: device_config put activity_manager max_phantom_processes 2147483647. On many devices the setting reverts after a reboot unless you also disable config syncing, and aggressive vendor ROMs add their own killers on top.
Is it safe to put a SillyTavern instance on a public VPS?
Only with authentication configured. SillyTavern ships with a whitelist that blocks remote access by default; to open it up safely you enable basic auth (and ideally TLS via a reverse proxy or tunnel) rather than just disabling the whitelist. Port scanners do find unauthenticated instances, and an open one exposes your API keys and chat history.
Do lorebooks, presets and regex scripts move between the three roads, or only character cards?
The whole kit is portable in principle: cards are PNG/JSON/charx, lorebooks are World Info JSON, presets and regex scripts are JSON too. Portability in practice depends on the destination's import support, so test your most complex lorebook and your regex pipeline first. Chat histories are the least portable part; export them before you move.
Top comments (0)