docs.sillytavern.app

SillyTavern (ST) is a locally installed user interface for interacting with text-generation LLMs, image-generation engines, and TTS voice models. It is aimed at power users who want maximum control over LLM prompts and are willing to accept a steep learning curve. According to the official documentation at docs.ST.app, it is a community-driven passion project that is always free and open-source, and it began in February 2023 as a fork of TavernAI 1.2.8.

What SillyTavern actually is

SillyTavern is a frontend only. It does not provide inference by itself — you connect it to an LLM backend. The docs describe it as a locally installed interface whose goal is to give users as much utility and control over prompts as possible.

It works with three kinds of models:

• Text generation LLMs — the core use case
• Image generation engines
• TTS voice models

Who it is for

The documentation is explicit that SillyTavern embraces a steep learning curve "as part of the fun." It positions itself for savvy AI hobbyists rather than casual users. If you want a simple chat box, this is more machinery than you need; if you want fine-grained control over prompts and backends, that is the point.

What you need besides SillyTavern

Because ST is only an interface, you need access to an LLM backend for inference. The docs list these options:

Installation requirements

The hardware bar is low: it runs on anything that can run NodeJS 20 or higher. If you plan to run LLM inference on your own machine, the docs recommend a 3000-series NVIDIA graphics card with at least 6GB of VRAM.

Installation guides are provided per platform: Windows, Linux and Mac, Android, and Docker.

Branches: which one to use

SillyTavern develops on a two-branch system:

• release — Recommended for most users. The most stable branch, updated only when major releases are pushed, typically once a month.
• staging — Not recommended for casual use. Latest features, but may break at any time. For power users and enthusiasts; updates several times daily.

If you just want it to work, use release.

Character cards

SillyTavern is built around character cards. A character card is a collection of prompts that set the behavior of the LLM, and it is required for persistent conversations in SillyTavern. The docs compare them to ChatGPT's GPTs or Poe's bots. Card content can be anything: an abstract scenario, a task-specific assistant, a famous personality, or a fictional character.

Project status and cost

• Free and open-source, per the official docs ("will always be free and open-sourced")
• Started February 2023 as a fork of TavernAI 1.2.8
• Over 300 contributors and 3 years of independent development, as stated on the page
• Maintained by a dedicated community of LLM enthusiasts

Where to go next

docs.ST.app is the reference site: it hosts the "What is SillyTavern?" overview, screenshots, installation requirements, branch descriptions, and the API Connections section for supported backends. Start there if you need the current, authoritative version of any of the details above.

A character card in SillyTavern is a collection of prompts that sets the behavior of the LLM, and it is required to have persistent conversations in the app. SillyTavern is built around this concept, so if you want an ongoing chat rather than a one-off exchange, you need a card selected. The card works similarly to a ChatGPT GPT or a Poe bot: it defines who or what the model is responding as.

What a character card actually is

According to the SillyTavern documentation, a character card is "a collection of prompts that set the behavior of the LLM." It is not a model, not a backend, and not a separate program — it is the instruction layer that sits between you and whatever LLM you have connected.

The content can be anything:

• An abstract scenario
• An assistant tailored for a specific task
• A famous personality
• A fictional character

Because the card is just prompt content, the same card can be used across different LLM backends you connect to SillyTavern.

Why it is required for persistent conversations

SillyTavern is only an interface. On its own it does not generate text — you need an LLM backend to provide inference, such as AI Horde for instant out-of-the-box chatting, or an OpenAI-compatible API, KoboldAI, Tabby, and others.

The character card is what gives that inference a consistent identity and behavior across sessions. Without a card, you can still have a quick conversation, but the documentation notes that a card is required to have persistent conversations in SillyTavern. In practice, the card is the anchor that keeps the model's persona, scenario, and instructions stable each time you return.

How this compares to tools you may already know

The comparison is the documentation's own: character cards "function similarly to ChatGPT's GPTs or Poe's bots."

What this means for you

If you are setting up SillyTavern and wondering why the app keeps asking you to pick or create a character, this is the reason. The card is not decoration — it is the mechanism that makes repeated, coherent conversations possible. Choose or build a card whose prompt content matches what you want the LLM to do, then connect a backend to supply the actual inference.

SillyTavern's own hardware bar is low: it runs on anything that can run NodeJS 20 or higher. The heavier requirement is separate — if you want to run the language model itself on your own machine, the docs recommend a 3000-series NVIDIA graphics card with at least 6GB of VRAM. If you plan to connect to a cloud or remote backend instead, that GPU recommendation does not apply to SillyTavern itself.

SillyTavern's own requirements

According to the official documentation, the hardware requirements for SillyTavern are minimal. The stated baseline is:

• NodeJS 20 or higher — this is the actual gate. If your device can run it, it can run SillyTavern.
• No specific CPU, RAM, or GPU figure is given for the interface itself.

This matters because SillyTavern is described as a locally installed user interface, not an inference engine. It sits in front of text generation LLMs, image generation engines, and TTS voice models — the compute happens elsewhere, whether that's a local model server or a cloud API.

If you want to run the LLM locally

The docs give a separate recommendation for local inference: a 3000-series NVIDIA graphics card with at least 6GB of VRAM.

Read that as a starting recommendation, not a hard minimum enforced by SillyTavern. Two conditions are worth separating:

If your machine doesn't meet the GPU recommendation, you can still use SillyTavern — you'd just point it at a backend that isn't your own hardware.

Installation guides by platform

The documentation links platform-specific installation guides for:

• Windows
• Linux and Mac
• Android
• Docker

Before starting, confirm your device meets the NodeJS 20+ requirement. That's the one check the docs frame as the practical prerequisite.

Choosing a branch before you install

SillyTavern is developed on a two-branch system, and your choice affects stability:

• release — recommended for most users. The most stable branch, updated only when major releases are pushed, typically about once a month.
• staging — not recommended for casual use. Carries the latest features but may break at any time; intended for power users and enthusiasts, updated several times daily.

For a first install, release is the documented default.

What you still need after installing

SillyTavern is only an interface, so installation alone doesn't give you a working chat. You need access to an LLM backend to provide inference. Options named in the docs include:

• AI Horde — for instant out-of-the-box chatting
• OpenAI-compatible API
• KoboldAI
• Tabby
• and other local and cloud-based backends

The docs point to an API Connections section for the full list. Separately, persistent conversations in SillyTavern are built around character cards — collections of prompts that set the LLM's behavior, roughly analogous to ChatGPT's GPTs or Poe's bots. A card can describe anything from an abstract scenario to a task-specific assistant or a fictional character.

So the practical sequence is: check NodeJS 20+, pick a platform guide, install the release branch, then decide whether your inference runs locally (where the GPU recommendation kicks in) or through a backend like AI Horde or an OpenAI-compatible API.

Yes. SillyTavern is only a frontend interface — it does not include a model or provide inference itself. To actually chat, you need access to an LLM backend that generates the text. The fastest way to start is AI Horde, which works out of the box without any local setup. If you want more control, SillyTavern supports many local and cloud-based backends, including OpenAI-compatible APIs, KoboldAI, and Tabby.

Why SillyTavern alone isn't enough

SillyTavern is a locally installed user interface for interacting with text generation LLMs, image generation engines, and TTS voice models. Its job is to give you control over prompts and how you talk to a model — not to run the model. The actual inference happens on whatever backend you connect.

This separation is deliberate: it lets you swap models and providers without changing how you use the interface.

Options for getting a backend

If you plan to run LLM inference on your own machine, the docs recommend a 3000-series NVIDIA graphics card with at least 6GB of VRAM. Hardware requirements for the interface itself are minimal — it runs on anything that can run NodeJS 20 or higher.

What else you'll need: a character card

SillyTavern is built around character cards. A character card is a collection of prompts that set the behavior of the LLM, and it's required for persistent conversations. Cards can represent an abstract scenario, a task-specific assistant, a famous personality, or a fictional character — similar in concept to ChatGPT's GPTs or Poe's bots.

Practical starting path

1. Install SillyTavern for your platform (Windows, Linux/Mac, Android, or Docker) using the official installation guide.
2. Pick a backend. For a zero-setup first chat, use AI Horde. For more control, connect an OpenAI-compatible API or a local backend like KoboldAI.
3. Select or create a character card to define how the model behaves.
4. Start chatting.

If you're unsure which backend fits your setup, the API Connections section of the documentation lists everything SillyTavern supports.

Use the release branch unless you are deliberately testing new features and can tolerate breakage. According to the SillyTavern documentation, release is "recommended for most users," is the most stable branch, and is updated only when major releases are pushed — typically about once a month. The staging branch carries the latest features but "may break at any time"; it is explicitly "not recommended for casual use" and is intended only for power users and enthusiasts, with updates several times a day.

The two branches compared

The two-branch system exists so that everyday users get a smooth experience while development continues elsewhere. If your goal is simply to chat with an LLM, image generation engine, or TTS voice model through SillyTavern, stability matters more than having the newest commit.

When staging makes sense

Choose staging only if you specifically want features that haven't reached a release yet and you're comfortable troubleshooting a broken install. The documentation's own framing is that staging is for people who treat the steep learning curve as part of the fun — the same audience the project describes as "savvy AI hobbyists."

If you do run staging, expect to update frequently and to occasionally roll back or wait for a fix. That's the trade-off the branch is designed around, not a defect.

What this choice does not change

Branch selection is independent of the rest of your setup:

• Hardware. Requirements are minimal — anything that can run NodeJS 20 or higher. If you plan to do LLM inference locally, the docs recommend a 3000-series NVIDIA graphics card with at least 6GB of VRAM.
• Backend. SillyTavern is only an interface, so you still need an LLM backend for inference. AI Horde works out of the box for instant chatting; OpenAI-compatible APIs, KoboldAI, Tabby, and others are also supported.
• Character cards. Persistent conversations require a character card, which is a collection of prompts that set the LLM's behavior. This works the same on either branch.

Practical guidance

1. Install following the guide for your platform — Windows, Linux and Mac, Android, or Docker.
2. Stay on release for normal use, and update when a major release is pushed.
3. Switch to staging only for a specific feature you need, and be ready to move back to release if something breaks.

For most readers the answer is simply: pick release. Staging is a testing channel, not an upgrade.