How do I run Stable Diffusion WebUI Forge on a cloud GPU?

Deploy a Raw GPU, check nvidia-smi, then install Forge Neo (a community-maintained fork of Forge) with git clone https://github.com/Haoming02/sd-webui-forge-classic sd-webui-forge-neo --branch neo, uv venv venv --python 3.13 --seed and ./webui-user.sh, and open port 7860 in your own browser through an SSH tunnel (see our SSH port-forwarding guide).

Updated 2026-10-27

This guide follows the Forge Neo README, its Linux wiki page and launcher scripts, the uv installation docs, NVIDIA’s CUDA Toolkit release notes and the PyTorch install page and forums, all read on 2026-10-27, plus CloudGPU’s own /deploy, /pricing and /terms pages, read the same day. It has not been timed on our instances, so it shows commands, not measured output.

Forge or Forge Neo?

We recommend Forge Neo for new installs. The original Forge’s last commit on its default branch is dated 2025-06-26. Neo is a community-maintained fork of Forge, published under AGPL-3.0, and it has had commits since.

Project Last commit on its default branch (GitHub API, read 2026-10-27) License (GitHub repository license file)
lllyasviel/stable-diffusion-webui-forge (original Forge) 2025-06-26 AGPL-3.0
Haoming02/sd-webui-forge-classic, branch neo (Forge Neo, a community-maintained fork) 2026-10-26 AGPL-3.0

According to the Forge Neo README, Neo “mainly serves as an continuation for the latest version of Forge”, and its feature list adds models such as Flux.2-Klein, Z-Image and Wan 2.2. This guide installs Neo. If you need a feature Neo removed, check its README before you switch.

What you need

  • On CloudGPU: an instance from /deploy using the Raw GPU option, which our deploy page describes as “a raw GPU with JupyterLab + CUDA pre-installed. SSH access, root on a dedicated container”. If you would rather use ComfyUI’s node-based UI, see Rent a GPU for ComfyUI; Forge goes on a Raw GPU.
  • On your computer: an SSH client such as ssh in a terminal.
  • A model file you are allowed to use. Check each model’s license on its model page.

Cards listed on /pricing on 2026-10-27 include the RTX 5090 32G, RTX 4090 48G, RTX 4090 24G, RTX 3090 24G, RTX A6000 and A100 80G. VRAM need depends on model, precision and workflow; see How much VRAM do I need for FLUX and SDXL? and How much VRAM do I need to run an LLM?.

GPU time is billed per minute, rounded up, with a 1-minute minimum, and billing stops when you destroy the instance (see /terms). The first launch of Forge Neo downloads and installs its requirements while the instance runs.

Step 1: Deploy a Raw GPU and log in

  1. Open /deploy and choose Raw GPU (under “Need SSH + your own environment?”).
  2. Pick a card and deploy.
  3. When the instance is running, copy its SSH host, port, user and password from your dashboard, then log in:
ssh -p <ssh-port> <ssh-user>@<ssh-host>

Step 2: Check the environment before you install anything

nvidia-smi            # GPU name, driver version, VRAM
nvcc --version        # CUDA toolkit version, if one is on PATH
python3 --version
git --version
cat /etc/os-release   # which Linux distribution the image uses
ss -ltn               # ports already in use (for example by JupyterLab)

What to look for:

  • Driver version. According to the Neo launcher script, Neo installs torch==2.14.0+cu130 by default. NVIDIA’s CUDA Toolkit release notes list driver branch R580 for CUDA 13.0 and say CUDA 13.x applications run on drivers 580 or newer. If nvidia-smi shows an older driver, see Step 5.
  • nvcc. A PyTorch maintainer on the official PyTorch forums writes that the PyTorch binaries “ship with their own CUDA runtime” and need only a properly installed NVIDIA driver; the local toolkit is used when you build CUDA code from source. So nvcc matters here only if you compile an optional package such as SageAttention.
  • Port 7860. If ss shows something already on 7860, pick another port with --port in Step 5.

Step 3: Install git, FFmpeg and uv

The Neo Linux wiki page lists git, FFmpeg and uv as the tools to install first, and notes that Linux “may need to install additional development tools (e.g. gcc)”. On a Debian or Ubuntu based image (check /etc/os-release from Step 2):

apt-get update
apt-get install -y git ffmpeg build-essential curl

You are root on a Raw GPU, so sudo is not needed; on another image, check which package manager it uses. FFmpeg is only needed to export video, per the Neo README.

According to the official uv installation docs, install uv with:

curl -LsSf https://astral.sh/uv/install.sh | sh

Then open a new shell (or follow the PATH hint the installer prints) and check that uv --version works.

Step 4: Clone Forge Neo and create its Python environment

According to the official Forge Neo README and Linux wiki page:

cd ~
git clone https://github.com/Haoming02/sd-webui-forge-classic sd-webui-forge-neo --branch neo
cd sd-webui-forge-neo
uv venv venv --python 3.13 --seed

The uv docs say uv downloads a Python version automatically when it cannot find one on the system, so you do not need Python 3.13 pre-installed. Check where ~ points on your instance (echo ~) and that the folder has room for the model files you plan to use.

Step 5: Set launch options in webui-user.sh

Open webui-user.sh. In the version read on 2026-10-27 it already contains export COMMANDLINE_ARGS="--uv", which the README says replaces python -m pip with uv pip. Flags you may add, all from the Neo README and cmd_args.py:

Flag What it does (per Neo docs) Use on a cloud GPU
--port 7861 Server port; defaults to 7860 Only if 7860 is taken
--listen Serves on 0.0.0.0 so other machines can connect Not needed with an SSH tunnel; if you use it, add --gradio-auth user:password
--api Enables the HTTP API alongside the UI Only if you call Forge from scripts
--xformers Installs xformers The README warns xformers does not support RTX 50s, so skip it on an RTX 5090

Example:

export COMMANDLINE_ARGS="--uv --port 7860"

Older driver? The Neo wiki’s “Older PyTorch” section shows how to pin an older build through TORCH_COMMAND. Its example is written for Windows (set ...); in webui-user.sh the same value goes on the commented export TORCH_COMMAND= line:

export TORCH_COMMAND="pip install torch==2.10.0+cu126 torchvision==0.25.0+cu126 --extra-index-url https://download.pytorch.org/whl/cu126"

The PyTorch install page (read 2026-10-27) lists the current CUDA builds; pick one that fits the driver nvidia-smi reports.

Step 6: Launch Forge Neo in tmux

The first launch installs all requirements, per the README. Run it inside tmux so it keeps going if your SSH connection drops:

apt-get install -y tmux      # if tmux is not already there
tmux new -s forge
cd ~/sd-webui-forge-neo
./webui-user.sh

Detach with Ctrl+b then d; reattach later with tmux attach -t forge. When the log shows a local URL on port 7860, the UI is up. The Neo launcher read on 2026-10-27 has no root check. (The original Forge launcher refuses to run as root unless you pass -f.)

If the log says Cannot locate TCMalloc, the Neo wiki suggests installing libtcmalloc-minimal4 (apt-get install -y libtcmalloc-minimal4 on Debian or Ubuntu).

Step 7: Open the UI in your browser through SSH

Forge’s port 7860 is not meant to be opened to the internet. Forward it to your own computer instead. On your own computer, in a new terminal:

ssh -N -L 7860:127.0.0.1:7860 -p <ssh-port> <ssh-user>@<ssh-host>

Leave it running and open http://localhost:7860. For other ports, background tunnels and troubleshooting, see our guide How do I use SSH port forwarding on a cloud GPU?

Without --listen Forge stays on the instance’s loopback address, so the UI is not reachable from the internet. If the browser shows nothing, check on the instance that something listens on 7860 (ss -ltn) and that the SSH server on your instance allows port forwarding. Whether a Raw GPU instance also gets its own public URL for this port is something to check in your dashboard; the tunnel works either way.

Step 8: Add models

Per the Neo README, models live in the models folder with subfolders such as Stable-diffusion (checkpoints), Lora, VAE and ESRGAN (upscalers). The Neo wiki’s Download Models page lists where to get the files each model type needs (diffusion model, text encoder, VAE).

Download straight to the instance instead of uploading from your computer, for example:

cd ~/sd-webui-forge-neo/models/Stable-diffusion
# then use hf download or wget with the model's file URL

See How do I download a Hugging Face model on a cloud GPU? for hf download, tokens and gated models. Then use the refresh button in the UI’s Quicksettings, which the Neo README says updates the model dropdowns.

Step 9: Copy your images, then destroy the instance

Check where Forge writes images (the output directory settings in the UI’s Settings tab) and copy anything you want to keep to your computer before you destroy the instance (see our guide to keeping your work before you destroy a cloud GPU). Billing stops when you destroy the instance (see /terms).

Troubleshooting

Symptom Likely cause What to check
PyTorch install fails or Forge does not detect CUDA at launch Driver older than the CUDA build Neo installs nvidia-smi driver version vs NVIDIA’s release notes; Step 5 “Older driver”
uv: command not found uv’s install folder is not on PATH in this shell Open a new shell or follow the installer’s PATH hint
Build error mentioning gcc Compilers missing apt-get install -y build-essential (Debian/Ubuntu)
Cannot locate TCMalloc Library missing libtcmalloc-minimal4, per the Neo wiki
xformers errors on RTX 5090 README: xformers does not support RTX 50s Remove --xformers
Browser shows nothing on localhost:7860 Forge not running or on another port, or tunnel not open tmux attach -t forge, ss -ltn, rerun the ssh -N -L command from Step 7
CUDA out of memory Model, precision or resolution too large for the card Smaller model or precision, lower resolution; VRAM for FLUX and SDXL

FAQ

Which Forge should I install in 2026, the original or Forge Neo?

We recommend Forge Neo. On 2026-10-27 the GitHub API showed the last commit on the original lllyasviel/stable-diffusion-webui-forge repository dated 2025-06-26, while the neo branch of Haoming02/sd-webui-forge-classic, a community-maintained fork of Forge under AGPL-3.0, had commits up to 2026-10-26. This guide installs Neo.

Can I run Forge Neo as root on a Raw GPU?

The Neo webui.sh launcher read on 2026-10-27 has no root check. The original Forge launcher refuses to run as root unless you pass -f. A Raw GPU gives you root on a dedicated container, so if you use the original Forge, add -f or create a normal user.

Which port does Forge Neo use and how do I open it?

According to the Neo README, the --port flag defaults to 7860. Without --listen the UI stays on the instance’s own loopback address, so open it from your computer through an SSH tunnel to port 7860 and browse to http://localhost:7860. Step 7 shows the command; our SSH port-forwarding guide covers the details.

Why does Forge Neo fail to install PyTorch or not see the GPU?

The Neo launcher installs torch 2.14.0+cu130 by default. NVIDIA’s CUDA release notes say CUDA 13.x applications run on drivers 580 or newer, so check the driver version in nvidia-smi first. On an older driver, the Neo wiki shows how to set TORCH_COMMAND to an older PyTorch build.

How much VRAM does Forge Neo need?

VRAM need depends on model, precision and workflow. We have not measured Forge Neo on our cards, so check the model you plan to load and see our guides on VRAM for FLUX and SDXL and on VRAM for LLMs.

Sources (read 2026-10-27)