ComfyUI Install in 2026: Desktop vs Portable vs Manual, and Which to Pick

There are now four official ways to install ComfyUI: the Comfy Desktop app, the Windows portable build, a manual install from the Git repository, and the comfy-cli command-line tool. They install the same engine but differ in platforms, GPU support, where your files end up and, most importantly, which ComfyUI version you get by default.

This guide compares the four, gives the commands for each, and explains the stable-versus-master choice that decides whether a new model works on day one. For model choice and VRAM, see our guide to running Stable Diffusion locally. BFWR has not installed ComfyUI for this article. Everything here comes from Comfy Org’s documentation, the source code of the three repositories, and the GitHub API, read on 1 November 2026.

Quick answer

• Most people: Comfy Desktop, on Windows, Apple Silicon Macs or Linux. It was rewritten in 2026 to run several ComfyUI installs side by side, with snapshots and rollback.
• Windows, no installer: the portable build. Five variants ship with each release (NVIDIA, NVIDIA for 10-series cards, NVIDIA on Windows ARM64, AMD and Intel), 1.5 to 2.0 GB each.
• Linux servers, unusual GPUs, full control: a manual install with Git and a virtual environment.
• Scripts and several workspaces: comfy-cli. Note that comfy install checks out the master branch by default, not a release.
• The version trap: Desktop defaults to the Stable channel, while comfy-cli and a fresh Git clone give you master. New model support usually lands on master first.
• Security: ComfyUI listens on 127.0.0.1 by default. Adding --listen with no address opens it to your whole network, and ComfyUI’s startup flags include no login option.

The four routes compared

Option 1: Comfy Desktop

Comfy Desktop is the route Comfy Org recommends for new users. It is no longer the app many older tutorials describe. The documentation says “Comfy Desktop is a complete rewrite that acts as a multi-installation manager”, and the old single-install repository, Comfy-Org/desktop, is now archived on GitHub with the description “Superseded by” a link to the new Comfy-Org/Comfy-Desktop repository. The current stable release is v1.1.8, published on 22 October 2026, with a v1.1.9 release candidate on 29 October.

What the rewrite adds, per its README and docs:

• Several installs side by side, each with its own ComfyUI version, custom nodes and Python environment.
• Automatic snapshots on every boot, restart and update, recording the ComfyUI version, custom nodes and pip packages (not models or outputs).
• Prebuilt environments. Each install “ships a relocatable Python with PyTorch and GPU wheels prebuilt”. The PyTorch picker offers CUDA stacks (13.0, 12.8 and others), ROCm, Intel XPU and CPU.

Requirements: Windows 10+ on x64 or ARM64, macOS 13+ on Apple Silicon, or Linux x64 (Ubuntu 22.04+ recommended); at least 4.85 GB of disk per install before models; 8 GB of RAM minimum, 16 GB recommended. Download it from comfy.org/download. On Linux, the docs give:

# Debian/Ubuntu package
sudo apt install ./*.deb

# Or the AppImage
chmod +x ./*.AppImage
./*.AppImage

On Ubuntu 24.04 and later the AppImage may need --no-sandbox, which disables Electron’s sandbox. (The ComfyUI README still lists Desktop as Windows and macOS only; the Desktop docs list Linux.)

Where Desktop puts your files

Models are shared across installs by default; custom nodes are per install. Uninstalling the app removes none of these folders.

Three defaults worth knowing

• Usage data is on unless you untick it. First-run setup has a box labelled “Help improve Comfy by sharing anonymous usage data”, described as “optional and ticked by default”. So is the beta-features box. The docs say prompts, workflows and generated media are never collected.
• Update checks cannot be switched off. The FAQ says “Comfy Desktop checks for a new version shortly after it launches and then every 10 minutes, and that check has no off switch.” Automatic installation of those updates is on by default and can be turned off.
• The app’s licence is not ComfyUI’s. ComfyUI itself is GPL-3.0. Comfy Desktop is dual-licensed under AGPL-3.0-or-later or a commercial licence, the latter “for users who do not wish to comply with the AGPL”, such as embedding the app in a proprietary product or offering it as a hosted service. The old app was GPL-3.0. For personal use nothing changes; it matters if you redistribute or host a modified version. This is a reading of the published licence text, not legal advice.

Option 2: The Windows portable build

The portable build is a folder with ComfyUI and an embedded Python (python_embeded). You extract it and run a batch file. The README is direct about its audience: “It is not recommended for regular users. Regular users should use the desktop app above.” It suits anyone who wants everything in one movable folder.

The latest GitHub release, v0.43.0 (27 October 2026), ships five archives. Sizes are from the GitHub releases API, in GB (10⁹ bytes):

The README warns that the CUDA 12.6 build is for 10-series and older cards and should not be used on 20-series and newer. The NVIDIA packages also include run_cpu.bat for CPU-only mode. Download from the ComfyUI releases page, extract with 7-Zip, and run the launcher. ComfyUI then opens at http://127.0.0.1:8188.

Updating uses the scripts in the update folder:

• update_comfyui.bat moves you to the latest commit on master. It is the “recommended way to update” in the bundled readme.
• update_comfyui_stable.bat moves you to the latest tagged release. The updater picks the highest-numbered v tag, which by that logic is v0.43.2 today, a patch tag (see below).
• update_comfyui_and_python_dependencies.bat reinstalls Python packages. The docs say to use it only for dependency problems and to back up first.

The updater reinstalls requirements.txt whenever it changes, which keeps the separately packaged interface and templates in step.

Option 3: Manual install

A manual install works on any platform, and the README states it “Supports all operating systems and GPU types (NVIDIA, AMD, Intel, Apple Silicon, Ascend)”. You need Git and Python. The README calls Python 3.13 “very well supported”, suggests 3.12 if a custom node’s dependencies fail, and says 3.14 works with some custom-node issues.

git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI

# Create and activate a virtual environment
python3 -m venv venv
source venv/bin/activate        # macOS/Linux
# venv\Scripts\activate         # Windows

# Install PyTorch for your GPU (one line from the list below), then:
pip install -r requirements.txt
python main.py

The PyTorch line is the only part that changes by GPU. These are copied from the README and docs:

# NVIDIA (stable, CUDA 13.0)
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130

# AMD on Linux (ROCm 7.2)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.2

# AMD on Windows 11 (ROCm 10.0, AMD's multi-architecture packages, Python 3.13)
pip install --index-url https://stable.repo.amd.com/rocm/whl-next/ "torch[device-all]==2.13.0+rocm10.0.0" "torchvision[device-all]==0.28.0+rocm10.0.0" "torchaudio==2.11.0.2+rocm10.0.0"

# Intel Arc (XPU)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/xpu

# Apple Silicon (PyTorch nightly, conda route from the docs)
conda install pytorch-nightly::pytorch torchvision torchaudio -c pytorch-nightly

A cu130 or newer PyTorch is required on NVIDIA 20-series and newer. On AMD Windows, replacing both device-all entries with your card’s target (device-gfx1100 for the RX 7900 XT and XTX) cuts the download. Macs use PyTorch’s MPS backend, not MLX. CPU-only mode is python main.py --cpu.

To update, pull and reinstall requirements in the same environment; the docs warn that skipping the second step leaves an outdated interface and missing templates.

git pull
pip install -r requirements.txt

The docs also note that “ComfyUI does not provide an official Docker image”; community images are unsupported.

Option 4: comfy-cli

comfy-cli is Comfy Org’s command-line tool (GPL-3.0, v1.24.0 released 29 October 2026, Python 3.10 or newer). It installs and launches ComfyUI, manages custom nodes and takes snapshots; its cloud and paid partner-API commands are optional.

pip install comfy-cli
comfy install
comfy launch

comfy install asks which GPU you have and installs a matching PyTorch build, and installs ComfyUI-Manager unless you pass --skip-manager. Without a --workspace path it installs under ~/comfy. Two details from its docs and source code:

• It installs master, not a release. The --version option defaults to nightly, which its help text defines as the latest commit on the master branch. Use comfy install --version latest for the newest stable release, or move later with comfy update comfy --version latest.
• AMD on Windows gets DirectML, not ROCm. Its install table lists torch-directml for AMD Windows, while the ComfyUI README’s manual route for AMD Windows uses ROCm 10.0.

Its README says “Analytics are opt-in and off by default”; the first interactive run asks, and comfy tracking disable turns it off later.

Stable or master: the choice that decides new-model support

ComfyUI tags a release roughly every week or two from the master branch, and fixes are backported as patch tags. The README warns: “Commits outside of the stable release tags may be very unstable and break many custom nodes.” The update docs put the cost of staying on stable just as plainly: releases “may lag behind development versions by weeks or months”.

The numbers on 1 November 2026, from the GitHub API:

• Latest GitHub release: v0.43.0, 27 October 2026. Fifteen releases were published in the 90 days to 1 November, and master took 563 commits in that time.
• Patch tags v0.43.1 (28 October) and v0.43.2 (30 October) exist without release pages. They sit on a backport line, not on master.
• master is 24 commits ahead of v0.43.0. They include support for MiniMax-H3’s latent upscaler and VAE, merged on 28 October.

A concrete case: native MOSS-Image nodes were merged to master on 16 October, are absent from the v0.41.1 to v0.41.3 patch tags, and first appear in v0.42.0 on 18 October. Our MOSS-Image guide covers what that gap meant in practice.

How to get master in each route:

• Desktop: Manage, then the Update tab, then switch the channel from Stable to Latest on GitHub. Copy & Update tries it on a copy and leaves the original alone.
• Portable: run update\update_comfyui.bat; update_comfyui_stable.bat takes you back to the latest tag.
• Manual: git checkout master then git pull. The docs give this for the latest tag:

git fetch --tags
git checkout $(git describe --tags `git rev-list --tags --max-count=1`)

• comfy-cli: comfy update comfy --version nightly for master, --version latest for the newest release.

ComfyUI-Manager and shared model folders

ComfyUI-Manager installs and updates custom nodes from inside the interface. For portable and manual installs the docs say “the new ComfyUI-Manager is built into ComfyUI core but needs to be enabled”:

# Manual install
pip install -r manager_requirements.txt
python main.py --enable-manager

# Portable (Windows)
.\python_embeded\python.exe -m pip install -r ComfyUI\manager_requirements.txt
.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --enable-manager

Desktop installs Manager with every install and starts it with --enable-manager for you.

To share one model library between several installs, or with another interface such as AUTOMATIC1111, copy extra_model_paths.yaml.example in the ComfyUI folder to extra_model_paths.yaml and set a base_path. The example includes a block for AUTOMATIC1111’s layout. Desktop users set extra model folders in the Storage tab instead. If you are not sure which file goes in which folder, our guide to checkpoints, LoRAs and VAEs explains each type.

Security: keep it on localhost

ComfyUI’s server binds to 127.0.0.1 on port 8188 unless you tell it otherwise. The --listen flag changes that. Given an address, it listens there; given nothing, its help text says it “listens on all ipv4 and ipv6” interfaces. The startup-flags reference lists TLS options and a --multi-user flag for per-user storage, but no password or login option. Anyone who can reach the port can use the server. Use --listen only on a network you trust, never forward port 8188 to the internet, and put an authenticating reverse proxy in front if you need remote access.

Custom nodes are the other risk. They are Python code that runs with your user’s permissions. The docs warn that “malicious plugins could potentially exploit custom nodes” and that “unverified plugins may pose security risks that could lead to system compromise”. Manager has security levels for this. In Desktop the recommended level, Standard, allows registered node packs and blocks installs from arbitrary Git URLs. With the default Public network mode, --listen “blocks node pack installs at every security level”, so by default an exposed Desktop instance will not install node packs. On portable and manual installs, keep the same habit: registered packs from authors you recognise.

FAQ

Can I run ComfyUI on an AMD GPU?

Yes. On Windows, use Desktop’s ROCm stack, the AMD portable build, or a manual install with AMD’s ROCm 10.0 packages on Windows 11. On Linux, use a manual install with the ROCm 7.2 PyTorch wheels. Note that comfy-cli installs DirectML for AMD on Windows rather than ROCm.

Why does a new model’s workflow show missing nodes?

Usually because its support is on master but not yet in a release. Switch to master as described above and reinstall requirements; on Desktop, use Copy & Update.

Can I move from portable or a Git clone to Desktop?

Yes. Desktop’s “Add Existing Instance” option tracks an existing Git clone or portable folder in place, so its models and custom_nodes folders stay where they are. Users of the old desktop app get a migration option at first launch.

Related guides and tools

• How to run Stable Diffusion locally: which model fits your GPU, and the licence catches
• ComfyUI templates in 2026: the 660 built-in workflows, and which need the cloud
• MOSS-Image in ComfyUI: the stable-versus-master problem in a real case
• Stable Diffusion image editors in 2026: alternatives to ComfyUI and which are still maintained
• Checkpoints, LoRAs and VAEs explained: which file goes in which folder
• ComfyUI VRAM by model: memory for each diffusion model at each precision
• Image generation VRAM calculator: check a model against your card before downloading it

Sources

• Comfy-Org/ComfyUI README: install routes, portable variants, manual PyTorch commands, release process, ComfyUI-Manager flags
• ComfyUI releases and the GitHub API: v0.43.0 date and portable asset sizes, tags, 90-day commit and release counts
• v0.43.0 compared with master and PR #17095 (MOSS-Image support)
• ComfyUI cli_args.py: --listen and --port defaults
• Portable update scripts (update.py and the batch files)
• extra_model_paths.yaml.example
• Comfy-Org/Comfy-Desktop README, releases and LICENSE; the archived Comfy-Org/desktop
• Comfy docs: Desktop overview, Desktop for Windows, Desktop FAQ, Managing installations
• Comfy docs: Portable for Windows, Manual install, System requirements, How to update ComfyUI
• Comfy docs: ComfyUI-Manager installation, Manager configuration, Installing custom nodes, Startup flags
• Comfy-Org/comfy-cli README and cmdline.py; comfy-cli getting started

Updated 1 November 2026. Release dates, tags, asset sizes and commit counts were read from the GitHub API, and the README, documentation pages, source files and licence text were read on that date. BFWR did not install or run any of the four routes.