# SillyTavern-Launcher: one script for the whole local AI stack

> Running a local language model, an image generator and a voice synthesis stack on one machine means installing a surprising number of programs, each with its own dependencies, its own port, and its own idea of where things belong. The SillyTavern Launcher is a menu-driven set of scripts that installs, starts, updates and removes all of them, and its real subject is the operational side of local AI rather than the models themselves.

**SillyTavern/SillyTavern-Launcher** — Launcher scripts for SillyTavern and ST-Extras.

- Repository: https://github.com/SillyTavern/SillyTavern-Launcher
- Stars: 591 · Forks: 128
- Language: Batchfile
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/sillytavern-sillytavern-launcher

## What the project is

The repository holds launcher scripts for SillyTavern and for the extras that go with it, and the readme is organised as installation instructions, a features section, and a support section.

The thing being launched is worth understanding first. The readme's feature list is a taxonomy of four kinds of application, and the central one is the chat interface itself. Around it sit the core utilities, the text completion backends, the image generation tools, and the voice generation tools, and the launcher's job is to install, start, update, and remove all of them from one place.

The core utilities list is the most revealing part, because it shows what a local AI stack actually needs underneath. Alongside the application itself there is an archiver, a video and audio conversion tool, the JavaScript runtime, a YAML processor, the Microsoft build tools for Windows, the CUDA toolkit for the graphics hardware, a mesh virtual network tool, and a minimal development toolchain for Windows. Those are not optional extras. They are the dependencies that the individual projects assume are present, and the launcher is collecting them in one place so that a user does not have to.

The text completion list is the set of backends a local language model can run on, and it covers a web interface for text generation, two builds of a C++ inference server, one of them in a raw configuration, a standalone C++ implementation, and a text generation API server, including a variant with the extras for the chat interface installed alongside it.

The image list is four graphical interfaces for diffusion models, including a fork of the main one, a node-based workflow tool, a simpler interface, and a toolkit for training and fine-tuning.

The voice list is a text to speech system, a conversational voice tool in two versions, one of which has diagnostic and fine-tuning modes, and a voice conversion system that works in real time.

The licence is MIT, the primary language is recorded as a batch file because the Windows path is the entry point, and the last push was in August 2026 with no tagged releases.

## Installing it, three platforms, and the same shape each time

The installation instructions are given for three platforms, and the readme is careful to give the exact keystrokes rather than assuming where you are.

On Windows it starts with the run dialog, opened with the Windows and R keys, and a command that installs git through the system package manager.

```shell
cmd /c winget install -e --id Git.Git
```

Then it asks you to open the file explorer with the Windows and E keys, navigate to the folder where you want the launcher to live, type a command shell into the address bar and press enter, which is the trick for opening a terminal in a chosen directory. And then the clone and the installer in one line.

```shell
git clone https://github.com/SillyTavern/SillyTavern-Launcher.git && cd SillyTavern-Launcher && start installer.bat
```

The Linux instructions are the same shape with the platform's own conventions: install git, clone the repository, make the installer executable and run it, and then do the same with the launcher script afterwards.

```shell
git clone https://github.com/SillyTavern/SillyTavern-Launcher.git && cd SillyTavern-Launcher
```

```shell
chmod +x install.sh && ./install.sh
```

```shell
chmod +x launcher.sh && ./launcher.sh
```

The macOS instructions insert one more step at the front, which is to install the package manager itself, and then it is the Linux sequence again with the package manager used for git.

```shell
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

```shell
brew install git
```

Two things are worth noticing about that. The first is that the clone and the install are on one line, so there is no step where the user is left in the wrong directory, which is the classic way a copy-paste installation goes wrong. The second is that the permission change and the run are also on one line, so the user is not told to make a script executable and then to run it, which is where most people get stuck on a system where the bit is not set by default.

And the last observation is the one that explains the primary language of the repository. The Windows path is a batch file, and the other two are shell scripts, and the repository listing shows all three of them side by side: the batch file, the two shell scripts, and the installer for Windows.

## The menu system, and what the features are for

Every feature group in the readme ends with the same two lines: what the group manages, and what the menu options let you do about it. The pattern is consistent enough that it is worth describing once.

For the core utilities, the menu options install, uninstall, and configure the tools, and edit environment variables and configurations. For the text completion applications, the menu installs, launches, uninstalls, and customises the modules. The same four verbs for the image applications and the same for the voice applications.

So the launcher is a menu over four families of applications, and the verbs are always the same. That is a deliberate simplification, and it is the difference between a script collection and a tool. The user learns one menu and then uses it for everything, rather than learning four different installers with four different conventions.

The additional features section is the part that shows the project has been used. There is a backup and restore function for the chat interface's own data. There is SSL certificate generation from a dedicated menu, which tells you that somebody is deploying this behind a public address rather than only on a laptop. There is a troubleshooting menu with a list of tasks that reads like a support ticket's worth of experience: detect VPN issues, gather information about the graphics hardware, check the ports, resolve conflicts on the source host, clear the caches of the JavaScript runtime, the package manager and the Python package manager, export diagnostic data, and restart the launcher. And there is a link to the community servers, which is where the support happens.

The app management group is the one that turns the launcher from a setup script into a maintenance tool: automatic updates, switching branches, and managing installations and removals. The branch switching in particular is the feature that matters for the kind of user this is, because the backends in the list are separate projects that move at their own pace, and being able to pin one to a different branch is how you keep a working setup working while the upstream changes.

The last three entries are small and useful. There is logging, with the logs kept in their own directory and viewable from the menu, which is what you want when a backend fails to start. There is a directory of custom settings for shortcuts and modules, so the launcher can be reshaped without editing the scripts. And there is a note about the directory of the scripts themselves, which is where the release-data and other pieces live.

The screenshots are given per platform, Windows and Linux, which tells you the interface is a graphical one on both, and the translations are the header: English, two forms of Chinese, Japanese, Korean, Dutch, French, Vietnamese, Portuguese, and Spanish. Ten languages, which is a remarkable amount of localisation for a set of scripts, and it is the clearest signal of how widely this is used.

## The repository, and what the file names say

The repository listing is short, and it reads as a description of the design.

There are three entry points: a batch file for Windows, a shell script for the Unix platforms, and an installer for Windows, plus a second shell script that does the installing on the Unix side. There is a directory for the binaries, a directory of icons, and a licence file.

And there are ten readme files, one for each of the languages the interface is offered in. The English one is the main one, and the others are translations of it, each named for its language and region. Keeping ten copies of a document in step is a chore, and the fact that the project does it anyway says something about who uses it.

The naming of the two shell scripts is worth a small note. The installer prepares the environment, and the launcher starts the applications, and the split is the same on both Unix platforms. On Windows the split is a batch file and an installer batch file. So the same conceptual split exists on all three platforms, which is what makes the three sets of instructions in the readme look so similar.

The primary language being recorded as a batch file is the repository's own metadata being literal rather than being useful, since the bulk of the work is in the shell scripts and in the application code they pull down. The real work of this project is not in this repository at all. The scripts here are a thin, careful layer over a large number of other people's installations, and the value is in the ordering, the environment variables, and the menu, not in the scripts themselves.

That is also why the readme spends so much of its length on the list of applications. The list is the product, and the launcher is the product in the sense that it is the thing a user interacts with, but the contents of the list are what makes it worth using.

## Conclusion

The launcher fits somebody setting up a local stack for the first time, or keeping several of them on one machine, who does not want to discover the correct order of installation and the correct environment variables by hand. It does not fit a deployment where the components are managed elsewhere, and it does not fit a user who wants a single model rather than a workshop. Verify first which of the listed applications you actually need, because the installer offers all of them and the menu is organised around having many of them, and that the ports it uses are free on your machine, because the troubleshooting menu includes a port checker for exactly that reason.

## FAQ

### What does the SillyTavern Launcher do?

It is a menu-driven set of scripts that installs, launches, updates, configures and removes the local AI stack: the chat interface, the text completion backends, the image generation applications, the voice generation tools, and the core utilities they depend on.

### Which applications can the SillyTavern Launcher install?

The core utilities, including an archiver, a media conversion tool, the JavaScript runtime, a YAML processor, the Windows build tools, the CUDA toolkit, a mesh networking tool and a minimal development toolchain. The text completion backends include a text generation web interface, two builds of a C++ inference server, a standalone C++ implementation and a text generation API server. There are four image generation applications and four voice generation tools.

### How do you install the SillyTavern Launcher on Linux?

Install git, clone the repository, make the install script executable and run it, and then do the same with the launcher script. The readme combines the clone with the directory change in one command, and the permission change with the run in another, so that there is no step where the working directory or the executable bit is wrong.

### What troubleshooting does the SillyTavern Launcher offer?

A menu of tasks including detecting VPN issues, gathering graphics hardware information, checking ports, resolving conflicts on the source host, clearing the caches of the JavaScript runtime and the two package managers, exporting diagnostic data, and restarting the launcher, plus viewing the logs and generating SSL certificates.

### Which languages is the SillyTavern Launcher available in?

Ten: English, two forms of Chinese, Japanese, Korean, Dutch, French, Vietnamese, Portuguese, and Spanish, each with its own readme file in the repository alongside the English one.

## Sources

- [Issues](https://github.com/SillyTavern/SillyTavern-Launcher/issues)
- [License: MIT](https://github.com/SillyTavern/SillyTavern-Launcher/blob/main/LICENSE)
- [README](https://github.com/SillyTavern/SillyTavern-Launcher/blob/main/README.md)
- [SillyTavern/SillyTavern-Launcher on GitHub](https://github.com/SillyTavern/SillyTavern-Launcher)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sillytavern-sillytavern-launcher