# Install ComfyUI (2026): Windows, Mac, Linux and Desktop App

> Published 2025-02-22, updated 2026-09-20 · https://www.promptzone.com/celine/comfyui-installation-guide-a-comprehensive-tutorial-56h

---
title: "Install ComfyUI (2026): Windows, Mac, Linux and Desktop App"
published: true
description: "Follow this comfyui installation guide to install ComfyUI on Windows, Mac, or Linux, configure your GPU, add models, and fix common errors."
tags: ai, comfyui, stablediffusion, tutorial
---

**Windows:** Install Comfy Desktop for a guided setup, or extract the portable build matched to your GPU.  
**Mac:** Install Comfy Desktop on Apple Silicon; use the manual route when you need control over Python and PyTorch.  
**Linux:** Use the official Desktop AppImage or Debian package, or install manually for a custom GPU environment.

## Overview {#overview}

ComfyUI connects models and generation steps through a node graph. This guide covers five installation routes and your first local image.

The [Desktop overview](https://docs.comfy.org/installation/desktop/overview) lists Windows, Apple Silicon macOS, and Linux packages. The core README's quick-start summary lists only Windows and macOS; use the platform-specific Desktop instructions.

For manual installations, the [system requirements](https://docs.comfy.org/installation/system_requirements) recommend Python **3.13**, with **3.12** as a fallback for custom-node dependency problems. Choose your installation method before adding extensions.

## Which install method

| Method | Platforms | Choose it when | Main consideration |
| --- | --- | --- | --- |
| Comfy Desktop | Windows, Apple Silicon Mac, Linux | You want guided installation and environment management | Each instance has its own configuration |
| Portable package | Windows | You want an extracted folder with bundled Python | Match the package to your GPU |
| Manual installation | Windows, macOS, Linux | You need direct control over dependencies | Maintain the Python environment yourself |
| comfy-cli | Windows, macOS, Linux | You prefer terminal-based installation and launching | GPU prerequisites still matter |
| Stability Matrix | Windows, macOS, Linux | You manage several generation applications | Follow its package and model management conventions |

## Installation Methods {#methods}

For a first installation, I recommend Desktop on supported hardware. Choose portable or manual installation when you want direct access to the underlying environment.

### 1. Comfy Desktop app

Desktop creates ComfyUI instances and manages their Python dependencies. Its [usage guide](https://docs.comfy.org/installation/desktop/usage/overview) describes independent instances and shared model storage.

**Windows:** Get the installer through the [official Windows guide](https://docs.comfy.org/installation/desktop/windows), run the `.exe`, and launch Comfy Desktop. The page lists Windows 10 or later, with a dedicated NVIDIA or AMD GPU recommended.

**Mac:** Follow the [macOS guide](https://docs.comfy.org/installation/desktop/macos): open the `.dmg`, drag the app into Applications, and launch it. Desktop requires Apple Silicon and macOS 13 or later; Intel Macs are outside this Desktop route.

**Linux:** The [Linux guide](https://docs.comfy.org/installation/desktop/linux) provides `.deb` and AppImage packages for x64, recommending Ubuntu 22.04 or later. Download into a folder containing only the chosen installer.

For Debian/Ubuntu, run from that folder:

```bash
sudo apt install ./*.deb
```

Alternatively, run the downloaded AppImage:

```bash
chmod +x ./*.AppImage
./*.AppImage
```

Create your first installation from Desktop's welcome screen. Let dependency setup finish, then launch ComfyUI through the instance controls.

Desktop updates and ComfyUI-instance updates are separate: the Desktop Update control updates the launcher, while the instance's Manage panel handles its ComfyUI update.

### 2. Installation via the Pre-Compiled Package

The [Windows portable guide](https://docs.comfy.org/installation/comfyui_portable_windows) documents separate NVIDIA, AMD, and Intel packages. Extract the archive completely, then run the matching launcher from its root folder.

For NVIDIA, in PowerShell:

```powershell
.\run_nvidia_gpu.bat
```

AMD and Intel packages provide `run_amd_gpu.bat` and `run_intel_gpu.bat`; CPU execution uses `run_cpu.bat`. Keep the terminal open while using the browser interface.

The documented NVIDIA builds distinguish CUDA 13.0/Python 3.13 for RTX hardware from CUDA 12.6/Python 3.12 for NVIDIA 10-series and older hardware. Read the package notes before downloading.

When startup prints its local address, open [http://localhost:8188](http://localhost:8188) if the browser does not open automatically. The bundle's Python folder is named **`python_embeded`**, including that spelling.

The folder is portable, but another machine still needs compatible hardware and drivers.

### 3. Manual Installation

Install Git and Miniconda first. On Windows, use a terminal where Conda is initialized. The [manual guide](https://docs.comfy.org/installation/manual_install) also calls for the Microsoft Visual C++ Redistributable on Windows.

Create an isolated environment using [Conda's documented environment commands](https://docs.conda.io/projects/conda/en/stable/user-guide/tasks/manage-environments.html):

```bash
conda create -n comfyenv python=3.13
conda activate comfyenv
git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
```

Keep this environment active and install **one** PyTorch build matching your hardware. The original `comfyanonymous/ComfyUI` address redirects to Comfy-Org.

#### Windows or Linux with NVIDIA

The [ComfyUI README](https://github.com/comfyanonymous/ComfyUI) currently supplies this stable CUDA command:

```bash
python -m pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
```

Use a compatible NVIDIA driver. The README requires a cu130-or-newer PyTorch build for NVIDIA 20-series and newer hardware; its older-GPU portable package is a separate route.

#### Linux with AMD

For a supported AMD GPU and ROCm environment, the manual guide supplies the ROCm 7.2 build:

```bash
python -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.2
```

Check your GPU and operating system against AMD's compatibility documentation linked from the ComfyUI README. Installing a wheel cannot make an unsupported hardware combination compatible.

For **AMD on Windows**, the official guide now documents ROCm packages as well. Use the AMD portable package for the simpler route, or follow its hardware-specific manual instructions.

#### Mac with Apple Silicon

Apple's [PyTorch guide](https://developer.apple.com/metal/pytorch/) explains MPS acceleration and lists the current PyTorch requirements, including macOS 14 or later. That PyTorch requirement is distinct from Desktop's launcher requirement.

Install Apple's command-line tools if needed:

```bash
xcode-select --install
```

ComfyUI's README recommends nightly PyTorch on Apple Silicon. Apple's documented nightly command, run in the active environment, is:

```bash
python -m pip install --pre torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/nightly/cpu
```

Despite `cpu` in the index URL, this is Apple's published macOS nightly installation route. Confirm MPS availability using the check below.

![Mac Terminal Installation](https://promptzone-community.s3.amazonaws.com/uploads/articles/nymlsul3mnjwv34i9fof.jpg)

#### Finish on every platform

From the cloned ComfyUI folder, install its dependencies and start the server:

```bash
python -m pip install -r requirements.txt
python main.py
```

Open the address printed in the terminal. For later launches, activate `comfyenv`, return to the same folder, and run `python main.py` again. Stop the server with `Ctrl+C`.

### 4. Install with comfy-cli

The official [comfy-cli guide](https://docs.comfy.org/comfy-cli/getting-started) documents installation, environment inspection, and launching. In an isolated Python environment, run:

```bash
pip install comfy-cli
comfy install
comfy which
comfy env
comfy launch
```

Follow the prompts and confirm the workspace. CUDA or ROCm support must still suit your machine. Use `comfy which` before modifying an installation when you maintain several.

### 5. Installation via Stability Matrix

[Stability Matrix](https://github.com/LykosAI/StabilityMatrix) is a third-party package manager for Windows, macOS, and Linux. It embeds Git and Python and supports ComfyUI packages and shared model management.

Download its platform release, extract or install it as instructed, and launch it. Add a ComfyUI package through its package interface, let setup complete, then launch that package. This route uses the app rather than manual shell commands.

![Stability Matrix Interface](https://promptzone-community.s3.amazonaws.com/uploads/articles/pxbe5zld3j9ubnqc0ay2.jpeg)

Select a compatible model for your first workflow. For broader context, see our [Stable Diffusion and image-generator comparison](/deepa_kowalski/ai-image-generators-2026-vheer-visualgpt-fooocus-comfyui-midjourney-more-compared-2i44).

## After installing

Check the environment before downloading an elaborate workflow. For manual NVIDIA or AMD ROCm installs, run:

```bash
python -c "import torch; print(torch.cuda.is_available())"
```

[PyTorch's installation guide](https://pytorch.org/get-started/locally/) uses this check for CUDA and ROCm. Expect `True` when the supported GPU backend is accessible.

On Apple Silicon, run:

```bash
python -c "import torch; print(torch.backends.mps.is_available())"
```

Then follow ComfyUI's [first-generation tutorial](https://docs.comfy.org/get_started/first_generation): load its basic workflow, download the requested checkpoint, and select it in Load Checkpoint. Click **Run** and confirm that Save Image receives a result.

Refresh model lists with **R** after adding files. Keep the successful workflow as a baseline for checking later changes.

## Managing Models and Extensions {#models}

Paths below are relative to the ComfyUI directory. They follow the project's [folder definitions](https://github.com/Comfy-Org/ComfyUI/blob/master/folder_paths.py).

| Model component | Folder |
| --- | --- |
| Complete checkpoints | `models/checkpoints/` |
| Separate diffusion weights | `models/diffusion_models/` |
| Text encoders | `models/text_encoders/` |
| VAE | `models/vae/` |
| LoRA | `models/loras/` |
| ControlNet | `models/controlnet/` |
| Upscaling models | `models/upscale_models/` |

Use the workflow's download instructions for `.safetensors` files. A separate diffusion model is not necessarily a complete checkpoint; [ComfyUI's model documentation](https://docs.comfy.org/basic-concepts/models) explains that distinction.

For FLUX workflows, obtain the required encoders and VAE as well as the diffusion weights. For an SDXL starting point, follow [installing and running SDXL in ComfyUI](/jaroslav/how-to-install-and-run-sdxl-models-in-comfyui-a-complete-guide-2nk2).

To share an Automatic1111 model library, copy `extra_model_paths.yaml.example` to `extra_model_paths.yaml`, edit its existing path examples, and restart. Desktop exposes external model directories through its Storage controls.

## Install ComfyUI Manager First {#manager}

Before adding custom extensions, check whether Manager is already available. The [Manager installation guide](https://docs.comfy.org/manager/install) says Desktop includes and enables it; manual and portable installations require setup.

For a manual install, stop the server and run from the ComfyUI folder:

```bash
python -m pip install -r manager_requirements.txt
python main.py --enable-manager
```

For portable Windows, run from the folder containing `python_embeded`:

```powershell
.\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
```

Manager helps install and update custom nodes. A workflow using only built-in nodes does not require third-party extensions. If an imported workflow needs additional nodes, install the relevant packages and restart.

## Troubleshooting

Use the error message and active environment to choose the relevant fix below.

## Fixing Common Installation Errors {#troubleshooting}

**GPU check returns False:** Check the active environment, PyTorch build, driver, and hardware support. This result alone does not prove that you installed a CPU-only wheel.

For NVIDIA's “Torch not compiled with CUDA enabled” error, the README recommends removing Torch and reinstalling the CUDA build:

```bash
python -m pip uninstall torch
python -m pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
```

**Missing modules or red custom nodes:** Read the startup import error. Install the extension's own dependencies into the Python environment running ComfyUI. A system-wide installation will not repair the portable interpreter's environment.

To isolate extension problems, use the [custom-node troubleshooting guide](https://docs.comfy.org/troubleshooting/custom-node-issues) and start a manual install with:

```bash
python main.py --disable-all-custom-nodes
```

**Out of memory:** Test a smaller workflow and resolution. The [model troubleshooting guide](https://docs.comfy.org/troubleshooting/model-issues) documents `--lowvram`, then `--novram`, as options when the model exceeds available GPU memory.

**Browser never opens:** Read the terminal for a startup failure. If it reports an occupied port, choose another using the documented [startup flags](https://docs.comfy.org/development/comfyui-server/startup-flags):

```bash
python main.py --port 8189
```

**Models missing or incompatible:** Check the folder, filename, download integrity, and model family. Refresh or restart after adding files. Tensor-shape errors can indicate a mismatched VAE or encoder.

**Mac generation is unexpectedly slow:** Run the MPS check. If it returns `False`, resolve the Python/PyTorch/macOS combination before comparing generation speed with GPU examples.

## Which Method Should You Choose? {#which-method}

Choose Desktop for guided setup, portable for bundled Windows Python, or manual installation for dependency control. Stability Matrix suits an existing package library; comfy-cli suits terminal workflows.

## Conclusion {#conclusion}

Finish with one working installation, one compatible model, and one saved image. Keep that baseline workflow available while adding the tools your next project needs.

## FAQ {#faq}

### How much VRAM do I need to install ComfyUI?

There is no single requirement covering every model. ComfyUI supports CPU execution through `--cpu`; GPU memory needs depend on the selected workflow. Check its model requirements before downloading large weights.

### Does ComfyUI work on AMD GPUs?

Yes. Official documentation provides ROCm instructions for Linux and Windows, plus an AMD Windows portable build. Support still depends on the GPU, driver, operating system, and PyTorch combination.

### Can ComfyUI and Automatic1111 share models?

Yes. Configure `extra_model_paths.yaml` using the supplied example and restart ComfyUI. Desktop also supports external model directories, so copying every checkpoint is unnecessary.

### Why do downloaded workflows show missing nodes?

An extension may be absent or may have failed to import. Check Manager and the terminal log, install the needed package and dependencies into the correct environment, then restart.

## Sources

- [ComfyUI repository and README](https://github.com/comfyanonymous/ComfyUI)
- [System requirements](https://docs.comfy.org/installation/system_requirements)
- [Desktop overview](https://docs.comfy.org/installation/desktop/overview)
- [Desktop Windows installation](https://docs.comfy.org/installation/desktop/windows)
- [Desktop macOS installation](https://docs.comfy.org/installation/desktop/macos)
- [Desktop Linux installation](https://docs.comfy.org/installation/desktop/linux)
- [Desktop usage](https://docs.comfy.org/installation/desktop/usage/overview)
- [Windows portable installation](https://docs.comfy.org/installation/comfyui_portable_windows)
- [Manual installation](https://docs.comfy.org/installation/manual_install)
- [Conda environment management](https://docs.conda.io/projects/conda/en/stable/user-guide/tasks/manage-environments.html)
- [Apple PyTorch and MPS guide](https://developer.apple.com/metal/pytorch/)
- [comfy-cli installation](https://docs.comfy.org/comfy-cli/getting-started)
- [Stability Matrix](https://github.com/LykosAI/StabilityMatrix)
- [PyTorch installation and checks](https://pytorch.org/get-started/locally/)
- [First image generation](https://docs.comfy.org/get_started/first_generation)
- [ComfyUI folder definitions](https://github.com/Comfy-Org/ComfyUI/blob/master/folder_paths.py)
- [Model concepts and locations](https://docs.comfy.org/basic-concepts/models)
- [Manager installation](https://docs.comfy.org/manager/install)
- [Custom-node troubleshooting](https://docs.comfy.org/troubleshooting/custom-node-issues)
- [Model troubleshooting](https://docs.comfy.org/troubleshooting/model-issues)
- [Server startup flags](https://docs.comfy.org/development/comfyui-server/startup-flags)

*Last reviewed and updated: September 2026.*