How do I run SwarmUI on a cloud GPU?

Run SwarmUI on a cloud GPU

Deploy a Raw GPU instance on CloudGPU, clone SwarmUI, install .NET with the project’s own linux-dotnet-install.sh, start it with ./launch-linux.sh --launch_mode none, and open http://127.0.0.1:7801/Install in your local browser through an SSH tunnel to port 7801.

Updated 2026-10-31

SwarmUI is a web UI for image and video generation by mcmonkeyprojects, licensed under the MIT License. On the day this guide was written, the official SwarmUI README (read 2026-10-31) reported “SwarmUI v0.9.8 Beta”, and the latest tag on the releases page was 0.9.8-Beta, published 2026-02-07 (UTC+8; read 2026-10-31). All commands below are taken from the official SwarmUI docs and scripts as read on 2026-10-31; check them again before you start, because the project changes often.

What you need

  • A CloudGPU account with a balance. Payment methods: card, Alipay, Google Pay, Apple Pay or USDT.
  • An SSH client on your own computer (ssh is built into macOS, Linux and Windows 10/11).
  • A GPU. We offer the RTX 5090 and other cards on /pricing. See current rates on /pricing.

VRAM need depends on model, precision and workflow. See How much VRAM do I need to run an LLM? and, for image models, How much VRAM do I need for FLUX and SDXL?

Step 1: Deploy a Raw GPU instance and connect

  1. Open /deploy, pick a card, and choose the Raw GPU option (JupyterLab + CUDA pre-installed, SSH access, root on a dedicated container, as described on /deploy, read 2026-10-31).
  2. Copy the SSH command shown for your instance and connect from your own terminal:
ssh root@<your-instance-host> -p <port>

Use the exact host, port and user shown for your instance.

Step 2: Check the GPU and the environment

Run these before any install command:

nvidia-smi
nvcc --version
git --version
python3 --version
python3 -m pip --version
python3 -m venv --help > /dev/null && echo "venv OK"
wget --version | head -n 1
tmux -V
  • nvidia-smi must list your GPU and a driver version. If it fails, stop here and check the instance on /deploy.
  • nvcc --version shows the CUDA toolkit on the image.
  • According to the official SwarmUI README (read 2026-10-31), Linux needs git and python3 with pip and venv; the README asks for Python 3.11 or 3.12, says 3.10 should also work, and says not to use 3.14 or later. If something is missing, the README gives sudo apt install git python3-full for Debian or Ubuntu Server (drop sudo if you are root).
  • The official .NET install script downloads with wget, and this guide uses tmux to keep SwarmUI running. If either is missing: apt update && apt install -y wget tmux.

Step 3: Start a tmux session

SwarmUI runs in the foreground. Run it inside tmux so it keeps going if your SSH connection drops:

tmux new -s swarm

Detach with Ctrl+b then d; reattach later with tmux attach -t swarm.

Step 4: Clone SwarmUI and install .NET

These are the manual Linux install commands from the official SwarmUI README (read 2026-10-31):

cd ~
git clone https://github.com/mcmonkeyprojects/SwarmUI
cd SwarmUI
./launchtools/linux-dotnet-install.sh

According to the README, the current version targets .NET 8 and a future version will target .NET 10, so the script installs both. The script itself (read 2026-10-31) installs the .NET 10.0 and 8.0 SDKs and ASP.NET Core runtimes into $HOME/.dotnet, which its comments say SwarmUI detects on launch.

Step 5: Launch SwarmUI and open it through an SSH tunnel

Start SwarmUI without trying to open a browser on the server:

./launch-linux.sh --launch_mode none

According to the official SwarmUI Command Line Arguments doc (read 2026-10-31), --host defaults to localhost and --port defaults to 7801. The README’s headless example adds --host 0.0.0.0; this guide keeps the default localhost, so the web UI is not exposed on a public port, and reaches it through SSH instead.

On your own computer, open a second terminal and forward the port:

ssh -N -L 7801:127.0.0.1:7801 root@<your-instance-host> -p <port>

Leave it open, then browse to http://127.0.0.1:7801/Install. More on tunnels: How to use SSH port forwarding on a cloud GPU.

Step 6: Finish the install page

According to the official SwarmUI Basic Usage doc (read 2026-10-31), the install page starts with an option to skip the installer and use defaults. Otherwise you:

  1. Pick a theme.
  2. Pick who the UI is for. Because you reach it through an SSH tunnel, choose Yourself.
  3. Pick a backend. The doc’s author suggests ComfyUI for local usage; on a fresh instance, pick the ComfyUI option so SwarmUI installs it into dlbackend/ComfyUI.
  4. Pick any starter models you want to download, or skip and add your own in Step 7.
  5. Confirm and let it install. Watch the tmux window for progress and errors.

Step 7: Add models

According to the official SwarmUI Model Support doc and Settings.cs defaults (read 2026-10-31), models live under SwarmUI/Models:

  • Models/Stable-Diffusion — the default main model folder (SDModelFolder)
  • Models/diffusion_models — also listed in the Model Support doc for diffusion model files

Download model files into those folders from the server, for example with hf download (see How to download a Hugging Face model on a cloud GPU). Use only models whose licence allows your use. Then refresh the Models tab under Generate in the UI. The folder root can be changed in Server > Server Configuration (ModelRoot, SDModelFolder).

Step 8: Confirm the GPU is used

Generate one image, and in a second tmux window (Ctrl+b then c) run:

nvidia-smi

The ComfyUI backend process should appear in the process list. You can also check that the backend’s PyTorch sees CUDA:

~/SwarmUI/dlbackend/ComfyUI/venv/bin/python -c "import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))"

Our own measurements on CloudGPU are coming.

Step 9: Save your files, then destroy the instance

According to Settings.cs (read 2026-10-31), images go to Output with the user name appended (AppendUserNameToOutputPath), and the Command Line Arguments doc gives local as the default single-user ID, so look in ~/SwarmUI/Output/local. Your settings live in ~/SwarmUI/Data. Copy what you need to your own computer before you destroy the instance:

rsync -avP -e "ssh -p <port>" root@<your-instance-host>:~/SwarmUI/Output/ ./swarmui-output/

Stop SwarmUI with Server > Shutdown in the UI (or Ctrl+c in the tmux window), then destroy the instance on CloudGPU. When an instance is destroyed, its data is deleted. GPU instances are billed per minute, rounded up to the next whole minute, with a 1-minute minimum, and billing stops when you destroy the instance. See /terms.

Troubleshooting

  • The page does not load at 127.0.0.1:7801. Check that the tunnel terminal is still open and that SwarmUI is running in tmux (tmux attach -t swarm). If port 7801 is taken on your own computer, forward another local port, e.g. ssh -N -L 7802:127.0.0.1:7801 ..., and open http://127.0.0.1:7802. To change the server port, the Command Line Arguments doc lists --port.
  • “Torch not compiled with CUDA enabled”. According to the official Troubleshooting doc (read 2026-10-31), reinstall PyTorch inside the ComfyUI backend’s venv:
cd ~/SwarmUI/dlbackend/ComfyUI
source venv/bin/activate
python -s -m pip install torch torchvision -U --index-url https://download.pytorch.org/whl/cu128
  • Errors during install or generation. Open Server > Logs in the UI and set the view type to Debug, as the Troubleshooting doc describes, then search the error text in the official docs.
  • More than one GPU on the instance. According to the official Using More GPUs doc (read 2026-10-31), add one self-starting backend per GPU in Server > Backends and increase GPU_ID for each.
  • Restarting later. According to the README, ./launch-linux.sh re-launches SwarmUI at any later time.

FAQ

Do I need to open a public port to use SwarmUI on a cloud GPU?

No. According to the official SwarmUI Command Line Arguments doc (read 2026-10-31), --host defaults to localhost and --port to 7801, so this guide keeps SwarmUI on localhost and opens it through an SSH tunnel with ssh -N -L 7801:127.0.0.1:7801.

Which backend should I pick on the SwarmUI install page?

The official SwarmUI Basic Usage doc (read 2026-10-31) says its author suggests ComfyUI for local usage. On a fresh Raw GPU instance, picking the ComfyUI option lets SwarmUI install ComfyUI into dlbackend/ComfyUI.

Where does SwarmUI save models and images?

According to the official SwarmUI Model Support doc and Settings.cs defaults (read 2026-10-31), models go under SwarmUI/Models (for example Models/Stable-Diffusion and Models/diffusion_models) and images go to SwarmUI/Output, in a subfolder named after the user (local by default).

How much VRAM do I need for SwarmUI?

VRAM need depends on model, precision and workflow. See https://cloudgpu.app/guides/how-much-vram-do-i-need-to-run-an-llm and https://cloudgpu.app/guides/how-much-vram-do-i-need-for-flux-and-sdxl before you pick a card on /pricing.

How am I billed while SwarmUI is running?

GPU instances are billed per minute, rounded up to the next whole minute, with a 1-minute minimum, and billing stops when you destroy the instance. Copy your outputs off first, because data is deleted when the instance is destroyed. See https://cloudgpu.app/terms.