如何安装（2/2）

Install ComfyUI manually on Windows, macOS, or Linux: create a virtual environment, clone the repository, install GPU dependencies, and start the app.

For the installation of ComfyUI, it is mainly divided into several steps:

  1. Create a virtual environment(avoid polluting the system-level Python environment)
  2. Clone the ComfyUI code repository
  3. Install dependencies
  4. Start ComfyUI

You can also refer to ComfyUI CLI to install ComfyUI, it is a command line tool that can easily install ComfyUI and manage its dependencies.

Create a virtual environment

Independent virtual environments are necessary because ComfyUI's dependencies may conflict with other dependencies on the system, and it can also avoid polluting the system-level Python environment.

Install Miniconda. This will help you install the correct versions of Python and other libraries needed by ComfyUI.

Create an environment with Conda.

conda create -n comfyenv
conda activate comfyenv

Clone the ComfyUI code repository

You need to ensure that you have installed Git on your system. First, you need to open the terminal (command line), then clone the code repository.

If you have not installed Microsoft Visual C++ Redistributable, please install it [here.](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170)



Open Terminal application.



Open [Terminal application](https://support.apple.com/guide/terminal/open-or-quit-terminal-apd5265185d-f365-44cb-8b09-71a064a42125/mac).

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

Install GPU and ComfyUI dependencies

Install GPU Dependencies

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

  Alternatively, you can install the nightly version of PyTorch.


    Install Nightly version (might be more risky)

pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu132

  For Linux, install the ROCm 7.2 version of PyTorch:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.2

  Alternatively, you can install the nightly version of PyTorch (ROCm 7.2).


    Install Nightly version (might be more risky)

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm7.2

  For Windows, use AMD's [multi-architecture PyTorch packages](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html) with ROCm 10.0. The `device-*` extras install your GPU's kernels and the matching ROCm runtime automatically; a separate HIP SDK installation is not needed. Use Windows 11, a current [AMD graphics driver](https://www.amd.com/en/support/download/drivers.html), and 64-bit Python 3.13.

  The install command below uses `device-all` to install kernels for all supported GPUs. To reduce download size and disk usage, optionally replace **both** occurrences of `device-all` with the target for your GPU:

  | GPU | Device extra |
  | - | - |
  | RX 9070 / XT, Radeon AI PRO R9700 | `device-gfx1201` |
  | RX 9060 / XT | `device-gfx1200` |
  | RX 7900 XT / XTX | `device-gfx1100` |
  | RX 7700 XT / 7800 XT | `device-gfx1101` |
  | RX 7600 / XT | `device-gfx1102` |
  | Ryzen AI Max / Max+ (Strix Halo) | `device-gfx1151` |


    This table only lists examples. A GPU missing from it may still be supported: supported architectures include RDNA 2, RDNA 3, RDNA 3.5, and RDNA 4. Keep `device-all` to install kernels for all supported targets. For other models, see AMD's [GPU target table](https://github.com/ROCm/TheRock/blob/main/RELEASES.md#gfx-target-lookup-table) and [ROCm compatibility matrix](https://rocm.docs.amd.com/en/docs-10.0.0/compatibility/compatibility-matrix.html).

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"

conda install pytorch-nightly::pytorch torchvision torchaudio -c pytorch-nightly

cd ComfyUI
pip install -r requirements.txt

Start the application

cd ComfyUI
python main.py

Run `python main.py --help` for built-in help, or see the [Startup Flags reference](https://docs.comfy.org/development/comfyui-server/startup-flags) for a complete list of command-line options.

For advanced server configuration (custom port, LAN access, VRAM modes, and more), see the Startup Flags reference.

How to update ComfyUI

Use the command line to enter the installation path of ComfyUI, then pull the latest code.

cd <installation path>/ComfyUI
git pull

Use the command line to enter the installation path of ComfyUI, then install the dependencies.


  You need to ensure that the current Python environment is the ComfyUI virtual environment, otherwise the dependencies will be installed to the system-level Python environment, polluting the system-level Python environment.

pip install -r requirements.txt

Adding Extra Model Paths

If you want to manage your model files outside of ComfyUI/models, you may have the following reasons:

  • You have multiple ComfyUI instances and want them to share model files to save disk space
  • You have different types of GUI programs (such as WebUI) and want them to use the same model files
  • Model files cannot be recognized or found

We provide a way to add extra model search paths via the extra_model_paths.yaml configuration file

Open Config File

For the ComfyUI version such as [portable](https://docs.comfy.org/installation/comfyui_portable_windows) and [manual](https://docs.comfy.org/installation/manual_install), you can find an example file named `extra_model_paths.yaml.example` in the root directory of ComfyUI:

ComfyUI/extra_model_paths.yaml.example

Copy and rename it to `extra_model_paths.yaml` for use. Keep it in ComfyUI's root directory at `ComfyUI/extra_model_paths.yaml`.
You can also find the config example file [here](https://github.com/Comfy-Org/ComfyUI/blob/master/extra_model_paths.yaml.example)



If you are using the [Comfy Desktop](https://docs.comfy.org/installation/desktop/windows) application, click the capsule menu at the top of the desktop app, then open the **Storage** tab and add your model directories there. The capsule only exists in the desktop app, not when ComfyUI runs in a browser.

&lt;img alt="Comfy Desktop capsule menu: Storage tab showing model directory settings" />

Or open it directly at:

C:\Users\YourUsername\AppData\Roaming\ComfyUI\extra_models_config.yaml

~/Library/Application Support/ComfyUI/extra_models_config.yaml

You should keep the file in the same directory, should not move these files to other places.

If the file does not exist, you can create it yourself with any text editor.

Example Structure

Suppose you want to add the following model paths to ComfyUI:

📁 YOUR_PATH/
  ├── 📁models/
  |   ├── 📁 loras/
  |   │   └── xxxxx.safetensors
  |   ├── 📁 checkpoints/
  |   │   └── xxxxx.safetensors
  |   ├── 📁 vae/
  |   │   └── xxxxx.safetensors
  |   └── 📁 controlnet/
  |       └── xxxxx.safetensors

Then you can configure the extra_model_paths.yaml file like below to let ComfyUI recognize the model paths on your device:

my_custom_config:
    base_path: YOUR_PATH
    loras: models/loras/
    checkpoints: models/checkpoints/
    vae: models/vae/
    controlnet: models/controlnet/

or

my_custom_config:
    base_path: YOUR_PATH/models/
    loras: loras
    checkpoints: checkpoints
    vae: vae
    controlnet: controlnet

For the desktop version, please add the configuration to the existing configuration path without overwriting the path configuration generated during installation. Please back up the corresponding file before modification, so that you can restore it when you make a mistake.

Or you can refer to the default extra_model_paths.yaml.example for more configuration options. After saving, you need to restart ComfyUI for the changes to take effect.

Below is the original config example:

#Rename this to extra_model_paths.yaml and ComfyUI will load it

#config for a1111 ui
#all you have to do is change the base_path to where yours is installed
a111:
    base_path: path/to/stable-diffusion-webui/

    checkpoints: models/Stable-diffusion
    configs: models/Stable-diffusion
    vae: models/VAE
    loras: |
         models/Lora
         models/LyCORIS
    upscale_models: |
                  models/ESRGAN
                  models/RealESRGAN
                  models/SwinIR
    embeddings: embeddings
    hypernetworks: models/hypernetworks
    controlnet: models/ControlNet

#config for comfyui
#your base path should be either an existing comfy install or a central folder where you store all of your models, loras, etc.

#comfyui:
#     base_path: path/to/comfyui/
#     # You can use is_default to mark that these folders should be listed first, and used as the default dirs for eg downloads
#     #is_default: true
#     checkpoints: models/checkpoints/
#     clip: models/clip/
#     clip_vision: models/clip_vision/
#     configs: models/configs/
#     controlnet: models/controlnet/
#     diffusion_models: |
#                  models/diffusion_models
#                  models/unet
#     embeddings: models/embeddings/
#     loras: models/loras/
#     upscale_models: models/upscale_models/
#     vae: models/vae/

#other_ui:
#    base_path: path/to/ui
#    checkpoints: models/checkpoints
#    gligen: models/gligen
#    custom_nodes: path/custom_nodes

For example, if your WebUI is located at D:\stable-diffusion-webui\, you can modify the corresponding configuration to

a111:
    base_path: D:\stable-diffusion-webui\
    checkpoints: models/Stable-diffusion
    configs: models/Stable-diffusion
    vae: models/VAE
    loras: |
         models/Lora
         models/LyCORIS
    upscale_models: |
                  models/ESRGAN
                  models/RealESRGAN
                  models/SwinIR
    embeddings: embeddings
    hypernetworks: models/hypernetworks
    controlnet: models/ControlNet

Add Extra Custom Nodes Path

Besides adding external models, you can also add custom nodes paths that are not in the default path of ComfyUI

Please note that this will not change the default installation path of custom nodes, but will add an extra path search when starting ComfyUI. You still need to complete the installation of custom node dependencies in the corresponding environment to ensure the integrity of the running environment.

Below is a simple configuration example (MacOS), please modify it according to your actual situation and add it to the corresponding configuration file, save it and restart ComfyUI for the changes to take effect:

my_custom_nodes:
  custom_nodes: /Users/your_username/Documents/extra_custom_nodes

FAQ

Docker: ComfyUI does not provide an official Docker image. If you want to run ComfyUI in a container, search Docker Hub for community-maintained images. Note that none of these are official ComfyUI images, and they are not supported by the ComfyUI team. Use them at your own risk.

How to Stop/Exit ComfyUI

Press Ctrl+C in the terminal window where ComfyUI is running, or simply close the terminal window.

Create, edit, rename, and delete ComfyUI instances in Comfy Desktop

Comfy Desktop lets you manage multiple ComfyUI instances from the Chooser view.

Instance Types

Comfy Desktop supports four types of instances. Each type displays a distinct icon on its card and in the title bar.

Type Icon Description
Standalone 💻 A self-contained ComfyUI instance created by Comfy Desktop. Includes bundled Python, automatic updates, and full snapshot support. This is the default when you click New Instance.
Cloud ☁️ A Comfy Cloud instance. Requires a Comfy Cloud account. Cloud instances run on Comfy's servers and are billed separately.
Remote 🌐 Connects to a ComfyUI instance running on another machine on your network. Configure the remote host and port during setup.
Tracked — Tracks an existing ComfyUI installation (Git clone or portable). Uses the same icon as Standalone — there is no separate icon for tracked instances. You manage updates manually. See Tracking an Existing Installation.

The image below labels the key actions available for each instance card:

<img alt="Instance management actions" />

  1. New Instance: Create a brand new ComfyUI instance. See Creating a New Instance. You can also create an instance from a snapshot file.
  2. ⋮ Menu: Click the three-dot icon to open the action menu for an instance.
  3. Manage: Open the Manage panel to configure the instance (path, launch args, model directories, environment variables). See the Manage page.
  4. Restore Snapshot: Revert the instance to a previous snapshot. See the Snapshots page.
  5. Share: Export a snapshot of the instance to share with others.
  6. Copy Installation: Duplicate an existing standalone installation with its own Python environment and custom nodes. See Copying an Installation.
  7. Forget: Remove the instance from the Chooser without deleting its files (equivalent to Untrack).
  8. Uninstall: Permanently delete the instance and all its files from disk. See Uninstalling an Instance for details on Forget and Uninstall.

Creating a New Instance

Click the + card (top-left) in the Chooser view to add a new ComfyUI instance.

    &lt;img alt="Configure Comfy Desktop on Windows" />



    &lt;img alt="Configure Comfy Desktop on macOS" />



1. **Installation Name**: The name of your instance. The default is "ComfyUI".
2. **Install Location**: Choose where to install ComfyUI. On Windows, it's strongly recommended to use an **SSD** and avoid the root of the C: drive.
3. **Advanced**: Click to expand to access additional options.
4. **Standalone**: The recommended option. A self-contained install with bundled Python, automatic updates, and snapshot support.
5. **Remote Connection**: Connect to a ComfyUI instance running on another machine.



&lt;img alt="Installing ComfyUI" />

Comfy Desktop will handle the rest: downloading Python, setting up the environment, and installing ComfyUI. The progress screen shows the current step.



&lt;img alt="Template library after installation" />

Once the installation is complete, Comfy Desktop opens the template library where you can pick a workflow template to get started.

Tracking an Existing Installation

If you already have a ComfyUI installation (either manually set up from the Git repository or downloaded as a portable version), you can add it to Comfy Desktop without creating a new one.

Click New Instance on the Dashboard to open the installation menu, then select Add Existing Instance.

<img alt="Add Existing Instance" />

  1. Click New Instance to open the installation options.
  2. Select Add Existing Instance to open the tracking dialog.

Detecting Your Installation

In the tracking dialog, click Browse to select a ComfyUI directory. Comfy Desktop probes the folder and automatically detects the installation type.

For a Windows portable install, the probe looks for:

  • standalone-env directory — the bundled Python environment
  • ComfyUI/main.py — the ComfyUI entry point

For a manually cloned git repo, the probe looks for:

  • models/ and user/ directories — signs of a configured ComfyUI
  • .venv directory — a Python virtual environment

Setting Paths

After selecting the directory, the dialog shows the detected paths. You can adjust them if needed.

<img alt="ComfyUI directory and Python environment" />

  1. ComfyUI Directory: The path to the ComfyUI folder containing main.py. For portable installations, this is typically the folder inside the portable package.
  2. Portable example: D:\ComfyUI_windows_portable\ComfyUI
  3. Python Environment: The path to the Python environment folder. Comfy Desktop detects this automatically and lets you override it if needed.
  4. Portable example: D:\ComfyUI_windows_portable\python_embeded
  5. Git repo example: <ComfyUI_dir>/.venv

Track vs Standalone

The key difference between a Tracked (Add Existing Instance) installation and a Standalone installation is how updates are managed:

Aspect Tracked (Existing) Standalone
Updates No automatic updates — manage ComfyUI version manually via Git Built-in automatic updates
Python Uses an existing Python environment (.venv, python_embeded, etc.) Bundled Python, automatic dependency management
Isolation Shares the existing path and environment Fully self-contained, isolated installation
Snapshots Not supported Snapshot support available
Use case Already have ComfyUI set up and customized Fresh install from scratch

Note: Tracked installations use launchMode: 'external'. Comfy Desktop launches the existing ComfyUI process without managing it internally. Snapshots are currently supported for Standalone instances only.

Uninstalling an Instance

↩ Back to overview

When you want to remove an instance, the three-dot menu offers two options depending on whether you want to keep the files or delete everything.

<img alt="Forget vs Uninstall" />

  1. Forget / Untrack: Removes the instance from the Chooser list without deleting any files. The installation folder and all its data remain on disk. Use this when you just want to clean up the list but might need the instance again later.
  2. Uninstall / Delete: Permanently removes the installation and all its files from disk. Model files in shared directories are not affected.

The name you see in the menu depends on the instance type: Forget appears for standalone installations (untrack doesn't apply because standalone installs are local), while Untrack appears for installations that were adopted or added manually. Both do the same thing: remove the instance from the list without deleting its files.

Copying an Installation

↩ Back to overview

You can duplicate an existing standalone installation by right-clicking its card and selecting Copy Installation. This creates a copy with:

  • A new Python environment
  • The same ComfyUI version
  • Its own custom node setup

You'll be prompted to enter a name for the new installation before the copy starts.

Editing an Instance

↩ Back to overview

In the Manage panel for an instance, you can:

  • Change the installation path
  • Adjust launch arguments
  • Modify model directories
  • Update environment variables

Open the Manage panel by right-clicking the instance card and selecting Manage.

Error State

If an installation encounters a problem, a warning indicator appears on its card. Right-click the card and select Dismiss Error to clear the error state. If the issue persists, check the logs at the Data Locations.

Common questions and troubleshooting tips for Comfy Desktop

General Questions

Comfy Desktop is a complete rewrite that acts as a multi-installation manager. Unlike Legacy Desktop which was a single-install application, Comfy Desktop lets you install, manage, and run multiple ComfyUI versions side by side. It also adds snapshots and model download management.

For users of Legacy Desktop, check the Migration Guide to transfer your existing setup.

Yes. The source is on GitHub. Comfy Desktop is dual-licensed: AGPL-3.0-or-later, or a commercial license from Comfy Org (licensing@comfy.org).

Comfy Desktop is one of several installation options. You can still use the Portable (Windows) install, Manual Install, or Comfy Cloud depending on your needs. Desktop is recommended for most users due to its ease of use and features like one-click updates and snapshot management.

Installation & Setup

See system requirements for full details.

  • Windows: Windows 10+, x64 or ARM64. A dedicated GPU (NVIDIA / AMD) is recommended, but not required.
  • macOS: macOS 13+ (Ventura), Apple Silicon (M1+)
  • Linux: Official .deb and AppImage packages are distributed through the Comfy Desktop repository. A dedicated GPU is recommended.
  • Disk: At least 4.85 GB per standalone installation
  • RAM: 8 GB minimum, 16 GB recommended

On Windows, the standalone installation does not require admin rights. On macOS, you'll need admin rights for the initial system-wide installation. On Linux, installing the .deb package requires sudo; the AppImage runs in user space without admin rights.

Download the latest Windows or macOS build from the official ComfyUI Download page. On Linux, download the .deb or AppImage with the universal download link from the Comfy Desktop repository. To run from source instead, see the Linux install guide.

Yes, they can coexist. However, we recommend migrating your installations to the new Comfy Desktop and eventually uninstalling Legacy Desktop. See the Migration Guide.

Usage

On the Dashboard, click New Instance to create a standalone instance, or open New Instance and choose Add Existing Instance to track a git clone or Windows portable install. Use the Comfy Cloud card to connect to Cloud.

  • Standalone: Fresh install with bundled Python
  • Add Existing Instance: Track a git clone or portable install
  • Cloud: Connect to Comfy Cloud

Yes! Comfy Desktop is designed for this. Each installation runs in its own isolated environment with its own Python and dependencies. You can launch them simultaneously in separate windows.

Models are shared across instances by default. Configure shared folders in Desktop Settings → Storage.

  • Standalone: The install itself lives in its installation folder. Custom nodes and the Python environment are per-install. Models usually come from the shared model directories.
  • Git clone / portable (tracked): Data stays in that existing folder (models/, custom_nodes/, user/). You can still opt into shared models, input, and output.

Comfy Desktop automatically creates a snapshot before every update. Snapshots capture:

  • Custom nodes and their versions
  • Model files
  • Settings and configuration

You can browse and restore any snapshot from the app's Snapshots section.

How to Stop/Exit Comfy Desktop

To stop a running ComfyUI instance (stop the Python backend while keeping the app open):

  1. Click the ⋮ (kebab) menu on the instance card
  2. Select Stop
  3. Confirm in the dialog

This stops the ComfyUI Python process but leaves the desktop app window open so you can relaunch anytime. To fully quit the desktop app, use File → Quit (or the equivalent OS quit command). Closing the last window returns to the Dashboard unless you quit the app.

Troubleshooting

  1. Windows: Try running as administrator once
  2. macOS: If you see a security warning, go to System Settings → Privacy & Security and click Open Anyway
  3. Linux: Make sure FUSE 2 is installed (sudo apt install libfuse2)

  4. Check the Downloads page for the latest version

  5. Ensure your NVIDIA drivers are up to date

  6. On Linux, verify CUDA toolkit is installed

  7. Check that the installation type supports GPU (Standalone and Git Clone do; Cloud connections use remote GPU)

  8. Check your internet connection

  9. Try taking a manual snapshot first via the app menu
  10. If the issue persists, restore to a previous snapshot and try again

The Desktop app writes a rotating app.log file. The fastest way to find it is Desktop Settings → Logs → Diagnostics → Open logs folder (☰ menu in the top-left).

Default log folders:

  • Windows: %APPDATA%\Comfy Desktop\logs
  • macOS: ~/Library/Logs/Comfy Desktop
  • Linux: ~/.config/Comfy Desktop/logs

Look for app.log. Previous sessions rotate to timestamped app.log_*.log files.

For ComfyUI process output (not the Desktop app itself), open the instance Manage panel and use the Terminal tab. See Manage.

Comfy Desktop and its installations are separate on disk. To uninstall the app and its installations:

  1. Delete the installations from within the app (right-click → Remove) or delete the installation folders manually
  2. Uninstall the app using your system's standard method (Add/Remove Programs on Windows, drag to Trash on macOS, package manager on Linux)

That does not delete app settings, logs, shared models, or outputs. For leftover folders and a complete cleanup, see Windows, macOS, or Linux.

No. Comfy Desktop is designed as a local GUI application and does not support headless, server-only, or remote operation modes. It requires a graphical desktop environment to launch and manage ComfyUI instances.

For headless or server deployments, use a manual ComfyUI installation or the Windows Portable build instead.

Install ComfyUI-Manager on Desktop, Portable, or manual ComfyUI setups to search, install, and update custom nodes from inside the app.

Desktop users

Comfy Desktop installs ComfyUI-Manager with every ComfyUI installation and starts it with --enable-manager, so there is nothing for you to install. Manager is configured per installation from inside the app:

In Comfy Desktop, open the installation and go to the **Manage panel**, then switch to the **Startup Args** tab.



* **Manager Security Level** decides which node packs Manager may install: **Strict**, **Standard** (recommended), **Relaxed**, or **Permissive**. Stricter levels matter most when ComfyUI is exposed to your network with `--listen`
* **Manager Network Mode** decides how Manager reaches the node registry: **Public** (default), **Private**, **Offline**, or **Personal cloud** (only for a machine you control)

Both options apply the next time you launch the installation.



**Startup Arguments** on the same tab controls the flags the installation launches with. Remove `--enable-manager` to run ComfyUI without Manager, or keep it and add `--disable-manager-ui` to hide the Manager UI while its background tasks continue.

See the Startup Args tab for the rest of the per-installation settings and the startup flags reference for the Manager flags.

Portable users

For users running the Windows Portable version, the new ComfyUI-Manager is built into ComfyUI core but needs to be enabled.

  1. Install the manager dependencies:
.\python_embeded\python.exe -m pip install -r ComfyUI\manager_requirements.txt
  1. Launch ComfyUI with the manager enabled:
.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --enable-manager
pause

Manual install users

For users with a manual installation, the new ComfyUI-Manager is built into ComfyUI core but needs to be enabled.

  1. Activate your virtual environment:
# Windows
venv\Scripts\activate

# Linux/macOS
source venv/bin/activate
  1. Install the manager dependencies:
pip install -r manager_requirements.txt
  1. Enable the manager with the --enable-manager flag when running ComfyUI:
python main.py --enable-manager

Command line options

Flag Description
--enable-manager Enable ComfyUI-Manager
--enable-manager-legacy-ui Use the legacy manager UI instead of the new UI (requires --enable-manager)
--disable-manager-ui Disable the manager UI and endpoints while keeping background features (requires --enable-manager)

Switch between new and legacy UI

The following version updates only support pip installations. Versions installed via custom nodes do not support switching to the new UI.

To use the new UI:

python main.py --enable-manager

To use the legacy UI:

python main.py --enable-manager --enable-manager-legacy-ui

Desktop users can switch to the legacy UI in **Server Settings → UI Settings → Use legacy manager interface**

&lt;img alt="Switch to legacy UI" />

Updating ComfyUI-Manager

ComfyUI-Manager ships as its own Python package, and ComfyUI core pins the version it works with in manager_requirements.txt. How you update the Manager depends on how ComfyUI is installed:

Desktop includes the Manager and keeps it current with Comfy Desktop updates. Update the ComfyUI engine from the [Manage panel](https://docs.comfy.org/installation/desktop/usage/manage#update-tab).



Updating ComfyUI may leave the installed Manager package unchanged. Install the manager requirements in the environment you launch ComfyUI from, then restart ComfyUI with `--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

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

If you cloned the Manager into `custom_nodes` yourself:

cd ComfyUI/custom_nodes/comfyui-manager
git pull

Then restart ComfyUI.

Legacy installation methods

To install ComfyUI-Manager in addition to an existing installation of ComfyUI:

  1. Navigate to ComfyUI/custom_nodes directory in terminal
  2. Clone the repository:
git clone https://github.com/Comfy-Org/ComfyUI-Manager comfyui-manager
  1. Install the manager dependencies:
cd comfyui-manager
pip install -r requirements.txt

  1. Restart ComfyUI

  2. Install Git for Windows (standalone version, select "use windows default console window")

  3. Download install-manager-for-portable-version.bat into your ComfyUI_windows_portable directory
  4. Double-click the batch file to install

comfy-cli provides various features to manage ComfyUI from the CLI.

Prerequisites: Python 3, Git

Windows:

python -m venv venv
venv\Scripts\activate
pip install comfy-cli
comfy install

Linux/macOS:

python -m venv venv
. venv/bin/activate
pip install comfy-cli
comfy install

See also: comfy-cli documentation

Prerequisites: python-is-python3, python3-venv, git

  1. Download install-comfyui-venv-linux.sh into an empty install directory
  2. Run:
chmod +x install-comfyui-venv-linux.sh
./install-comfyui-venv-linux.sh
  1. Execute ComfyUI with ./run_gpu.sh or ./run_cpu.sh

Installation precautions:

  • ComfyUI-Manager files must be accurately located in the path ComfyUI/custom_nodes/comfyui-manager
  • Do not decompress directly into ComfyUI/custom_nodes (files like __init__.py should not be in that directory)
  • Do not install in paths like ComfyUI/custom_nodes/ComfyUI-Manager/ComfyUI-Manager or ComfyUI/custom_nodes/ComfyUI-Manager-main