SwarmUI in 2026: Setup, Models and When to Use It Instead of ComfyUI

SwarmUI is a free, MIT-licensed web interface for local image and video generation. It runs ComfyUI underneath as its engine and adds a form-based Generate tab on top, so you can pick a model, type a prompt and get an image without wiring nodes.

This guide covers installing it on Windows, Linux and macOS, the two main tabs, which model families it supports, where model files go (including sharing a folder with an existing ComfyUI), multiple GPUs, and its network and login defaults. BFWR has not run SwarmUI. Everything here comes from the project’s README, documentation, source code and the GitHub API, read on 1 November 2026.

Quick answer

• What it is: a front end that installs and drives ComfyUI for you. Its pitch to ComfyUI users: “Swarm is a wrapper around Comfy – it contains Comfy, in full, node graph and all, and then adds more.”
• Install: one script on Windows or Linux; on an Apple Silicon Mac, install .NET with Homebrew and run ./launch-macos.sh. Use Python 3.11 or 3.12; the README says “Do not use 3.14 or later.”
• Models: the support table lists about 20 current image families, including Flux.2, Krea 2, Qwen Image 2.1, Z-Image and MOSS Image, plus Wan, LTX-2 and MiniMax H3 for video.
• Versions: the last tagged release is 0.9.8-Beta from 6 February 2026, but the installers clone the master branch, which took 279 commits in the last 90 days.
• Security: by default it listens on localhost:7801 with no login. The installer’s LAN option opens it to your whole network, still with no login, and that includes raw ComfyUI access.

What SwarmUI is, and its release status

The project is mcmonkeyprojects/SwarmUI, formerly StableSwarmUI. It began under Stability AI: the README lists updates before June 2024 as copyright Stability AI and the current code as copyright Alex Goodwin (mcmonkey). The server is written in C# on .NET and starts ComfyUI as a separate Python process.

The README calls the project “Almost-Release” and explains: “This means for most tasks, Swarm has excellent tooling available to you, but there are a few areas I still want to perfect.” Every tagged release carries a Beta label, but the tags say little about how current it is. The installers run git clone on the default branch rather than downloading a release, and updating is a git pull. Repository health from the GitHub API, 1 November 2026:

When comparing installs with someone else, compare commit hashes, not version numbers.

Installing SwarmUI

On every platform a script fetches .NET and the code, builds the server, starts it and opens an install page at http://localhost:7801/Install. There you choose who the install is for, a backend (ComfyUI, unless you already run one) and any starter models.

Windows

Download install-windows.bat from the 0.9.8-Beta release page, put it in the folder you want SwarmUI in (not Program Files) and run it. The script uses winget to install the .NET 10 and .NET 8 SDKs and Git if they are missing and clones the repository. On Windows 10 you may need to install Git and the .NET 8 SDK yourself first, and if the window closes early, the README says “it sometimes needs to run twice.” The manual route, after installing Git and both SDKs:

git clone https://github.com/mcmonkeyprojects/SwarmUI
cd SwarmUI
launch-windows.bat

The README: “Current version targets .NET 8, but a future version will target .NET 10, so install both”. The project file still targets net8.0.

Linux

Install Git and Python 3.11 or 3.12 first (on Ubuntu desktop, sudo apt install git python3-pip python3-venv). Then:

wget https://github.com/mcmonkeyprojects/SwarmUI/releases/download/0.6.5-Beta/install-linux.sh -O install-linux.sh
chmod +x install-linux.sh
./install-linux.sh

The link points at an old 0.6.5-Beta pre-release, and the README adds “Yes this link is still current”. It works because the script only clones the latest code and installs .NET in your home folder. The manual alternative:

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

macOS (Apple Silicon only)

“You can only run SwarmUI on Mac computers with M-Series Apple silicon processors”, says the README. Its steps:

brew update
brew install dotnet
brew install python@3.11
brew install virtualenv
git clone https://github.com/mcmonkeyprojects/SwarmUI
cd SwarmUI
./launch-macos.sh

There are also Docker scripts (./launchtools/launch-standard-docker.sh) and an example Compose file for NVIDIA GPUs. Read the security section first: they publish port 7801 on every interface.

The Generate tab and the Comfy Workflow tab

The README splits them by audience: “Beginner users will love Swarm’s primary Generate tab interface”, while “Advanced users may favor the Comfy Workflow tab to get the unrestricted raw graph”.

Generate is a parameter form. You pick a model from a thumbnail browser, type a prompt and press Generate, and SwarmUI builds the ComfyUI workflow behind the scenes. It also holds the image editor and the Grid Generator, which renders results across settings you choose.

Comfy Workflow is the full ComfyUI node editor. Build a graph and click Use This Workflow, and the Generate tab takes its parameters from your graph. Or go the other way and import a Generate-tab setup into the graph to see how it is wired.

Non-admin accounts do not get the graph: “Default user accounts have a lot fewer tabs, and notably can’t play with custom comfy workflows”, because it is hard to secure.

Which models SwarmUI supports

The main image entries in docs/Model Support.md on 1 November 2026, with the doc’s own scale figures (older models such as SD 1.x and Stable Cascade sit in a separate “obscure” list):

The video doc lists Hunyuan Video and 1.5, LTX Video and LTX Video 2 (with LTX-2.3 and LTX-2.5 notes), Wan 2.1 and 2.2, and MiniMax H3. The README adds “some AI audio models”, naming ACE-Step. Besides .safetensors, SwarmUI loads GGUF, Nunchaku and NF4 quantized files.

The doc also gives the maintainer’s picks under “Image model(s) most worth using, as of September 2026”: Krea 2 first, then Flux.2 Klein, with Qwen Image 2.1 for editing. The doc itself calls its quality column “a loose vibe-based metric”. Its memory notes are more useful. For FLUX.2 [dev] it warns: “This can easily fill up 128 gigs of system RAM in usage, but does still work on 64 gig systems.” Before downloading, estimate VRAM with our image generation VRAM calculator and check the licence on each image model page: several models in this table are non-commercial.

Where models go, and sharing a ComfyUI models folder

Everything lives under Models/ in the SwarmUI folder. The defaults in Settings.cs are Stable-Diffusion for main models, plus Lora, VAE, Embeddings, controlnet, text_encoders and clip_vision. The server also creates and scans diffusion_models, which is where the docs tell you to save newer models such as Flux.2 and Z-Image; for those two, the VAE and text encoder download automatically. SwarmUI hands its ComfyUI backend a generated --extra-model-paths-config file, so both read the same folders.

To use an existing ComfyUI models folder, go to Server > Server Configuration:

• Set ModelRoot to your ComfyUI models folder and SDModelFolder to checkpoints to match ComfyUI’s layout.
• ModelRoot accepts several folders separated by ;, such as a fast SSD first and a slower drive second. DownloadToRootID sets which one receives downloads.
• Click Save at the bottom of the page.

You can also point SwarmUI at your existing ComfyUI install as a “ComfyUI Self-Starting” backend, but the Basic Usage doc says this “is not recommended for most users”.

More than one GPU

Each GPU runs its own backend. For several cards in one PC, add a self-start backend per card under Server > Backends and increase GPU_ID each time; the docs warn that NVIDIA’s numbering may not match slot order, so test which card each ID drives. For several machines, install SwarmUI on each and add them to the main one as Swarm-API-Backend entries by LAN address, with model files at identical paths on every machine.

“Backends get used in the order they’re listed”, so put the fastest card first: the second backend only gets work when two jobs are queued at once. That speeds up batches and grids, not a single image. AMD cards work through ROCm, which the installer offers, though the project’s AMD page advises NVIDIA if you have the choice.

Security: port, bind address and logins

The defaults in src/Core/Settings.cs:

The setting’s own description: “If false, the UI will be open to anyone who can connect to it.” On a localhost bind that is only you. But three common setups widen the bind without turning login on:

• The installer’s LAN option. “Just Yourself, with LAN access” sets the host to 0.0.0.0 (* on Windows), so anyone on your network gets the full interface.
• The README’s headless Linux example, which uses --host 0.0.0.0.
• Docker. The container starts with --host 0.0.0.0 and the scripts publish -p 7801:7801, which Docker binds on every host interface.

That interface includes raw ComfyUI access, and the hosting doc warns: “Some Swarm API routes can be used maliciously, such as the routes that forward raw ComfyUI access.” The ComfyUI process itself is better contained: SwarmUI starts it with --port (from 7820 up) and no --listen flag, so ComfyUI keeps its default of 127.0.0.1.

What to do:

• One machine, one user: keep localhost.
• Other devices at home: set a password on the local account, turn on AuthorizationRequired, then change Host. Give housemates the User role, not PowerUser, unless you trust them with the graph.
• Docker: the script asks you to edit a copy, not the original; in yours, publish -p 127.0.0.1:7801:7801.
• Over the internet: “You should not host publicly without an authentication layer in front”, meaning a reverse proxy with its own login and HTTPS. The built-in ngrok and Cloudflare options create a public URL, so enable login first. An SSH tunnel or private VPN is safer for reaching a home machine.

The project is candid about its limits: “Currently, SwarmUI is only validated to be safely usable by Friends and Family.” Two-factor login is planned, not built. On privacy, “Swarm itself has no native autoenabled phone home nor data tracking”, though it checks GitHub for update tags at startup and auto-updates ComfyUI and custom nodes unless you turn that off per backend.

Licence

SwarmUI’s own code is MIT: you may use, modify and ship it commercially, keeping the copyright notice. The README adds: “SwarmUI itself is under the MIT license, however some usages may be affected by the GPL variant licenses of connected projects list above, and note that any models used have their own licenses.” ComfyUI, which it installs, is GPL, and the optional YOLOv8 face detection pulls in Ultralytics, whose use “may become subject to AGPL terms”. For personal use none of this restricts you; the model licences are usually the tighter limit. This is a reading of the published text, not legal advice.

SwarmUI or ComfyUI?

Since SwarmUI contains ComfyUI, the choice is about interface and one extra layer.

SwarmUI fits if you want to generate without building graphs, compare settings often (the Grid Generator is its standout tool), want a thumbnail model browser and per-user output folders, share one GPU box with family, or have several GPUs.

Plain ComfyUI fits if you work in the graph anyway and want one fewer process and project to update, or rely on ComfyUI’s built-in templates (see our guide to ComfyUI templates). ComfyUI’s latest release was v0.43.0 on 27 October 2026.

New architectures reach ComfyUI first. SwarmUI’s graph tab can use one once its bundled ComfyUI updates, but the Generate tab waits for SwarmUI to add support. So far it has kept pace: its table already lists MOSS Image, whose weights appeared on Hugging Face on 11 October 2026.

FAQ

Is SwarmUI free?

Yes. It is MIT-licensed with no paid tier; the README says “100% free and open source forever” and development is funded by donations.

Can SwarmUI use my existing ComfyUI models?

Yes. Set ModelRoot to your ComfyUI models folder and SDModelFolder to checkpoints. No copying needed.

Related guides and tools

• Stable Diffusion image editors in 2026
• How to run Stable Diffusion locally in 2026
• Best local image generation models in 2026
• ComfyUI templates in 2026
• ComfyUI models and VRAM
• Image generation VRAM calculator
• Image model directory

Sources

• SwarmUI repository and README (status, install steps, licence notes)
• SwarmUI releases
• Model Support and Video Model Support
• Basic Usage and Advanced Usage
• Using More GPUs and AMD Radeon GPUs
• Sharing Your Swarm and Privacy
• Docker and Why Use Swarm
• Settings.cs, Installation.cs and ComfyUISelfStartBackend.cs (defaults)
• ComfyUI cli_args.py (the --listen default)

Updated 1 November 2026. The README, the docs folder, the settings, installer and backend source files, and the repository’s release, commit and advisory data were read from GitHub on that date.