How to Install ComfyUI on Mac: A Clear Step-by-Step Guide

Installing ComfyUI on a Mac can appear straightforward until you encounter differences between Intel and Apple silicon architectures or the nuances of manual setups. You might have also wondered how the process compares to installing ComfyUI on Windows, especially if you switch between platforms.

This guide explains how to install ComfyUI on Mac with clear, step-by-step instructions that cover Intel Macs, the latest Apple silicon including M1 and M4 chips, and manual installation methods. You will also find practical comparisons to Windows installations and solutions to common issues that occur during setup.

Key takeaways

• Prepare your Mac by installing Homebrew and Python 3.10 or later before starting ComfyUI installation.
• Intel Macs require specific Rosetta 2 setup to run ComfyUI smoothly.
• Apple silicon Macs (M1 and M4) benefit from native ARM64 builds but may need extra configurations.
• Manual installation offers more control but demands familiarity with terminal commands and dependencies.
• Windows installation differs mainly in package management and environment setup compared to Mac.

Before you start: What you need to install ComfyUI on Mac

To install ComfyUI on your Mac smoothly, ensure your hardware and software meet certain prerequisites. ComfyUI runs best on Macs with at least 8 GB of RAM and a quad-core CPU; Intel-based Macs should be 2016 models or newer, while Apple silicon Macs (M1 or M4) generally exceed these specs. Adequate disk space is essential—reserve at least 5 GB to accommodate ComfyUI, its dependencies, and working files.

Software-wise, you need Python 3.8 or later, Git, and Homebrew installed. Homebrew simplifies installing required libraries and tools. You can verify Python by running python3 --version in the Terminal; it should return a version number 3.8 or higher. Similarly, confirm Git with git --version and Homebrew with brew --version. If any are missing, install them via official sources.

Additionally, a stable internet connection is required to download ComfyUI packages and dependencies. Basic familiarity with the Terminal app is necessary since installation involves command-line inputs. You also need permission to install software and modify system files, which may prompt you for your administrator password during setup.

1. Check your Mac model and RAM in About This Mac from the Apple menu; ensure it meets minimum specs. You should see your processor and memory details clearly.
2. Open Terminal and type python3 --version; a version number 3.8 or above confirms Python is ready.
3. Type git --version and brew --version to verify these are installed; output showing their versions means they are present.
4. If any prerequisites are missing, visit their official websites to download and install them. After installation, re-run the version commands in Terminal to confirm.
5. Ensure you have at least 5 GB free on your startup disk by checking in About This Mac > Storage.

How to install ComfyUI on Mac Intel

1. Check if Homebrew is installed by typing brew --version in Terminal. If you see a version number, Homebrew is installed. If not, install Homebrew by running /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)". Successful installation ends with a message indicating Homebrew is ready to use.
2. Install Python compatible with Intel Macs using Homebrew: run brew install [email protected]. After installation, verify by typing python3 --version, which should return Python 3.11.x.
3. Clone the ComfyUI repository by running git clone https://github.com/comfyanonymous/ComfyUI.git. On success, a new folder named ComfyUI appears in your current directory.
4. Navigate to the ComfyUI folder using cd ComfyUI. Then install dependencies by running python3 -m pip install -r requirements.txt. You should see messages confirming successful installation of packages.
5. Launch ComfyUI with python3 main.py. A successful launch displays startup logs ending with a message like "Running on http://localhost:8188/". Open this URL in your browser to verify the interface loads correctly.

How to install ComfyUI on Mac M1 and M4

Apple silicon Macs with M1 and M4 chips require a distinct approach for ComfyUI installation due to their ARM architecture. Unlike Intel Macs, Python and dependencies must be installed with ARM-compatible versions or through Rosetta 2 translation.

1. Install Homebrew for ARM by running /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" in Terminal. You should see a confirmation that Homebrew installed in /opt/homebrew.
2. Install Python natively for ARM using brew install python. This ensures the version supports Apple silicon. Terminal will display the Python version and installation path.
3. Clone the ComfyUI repository with git clone https://github.com/comfyanonymous/ComfyUI.git. The folder ComfyUI should appear in your current directory.
4. Navigate into the ComfyUI directory: cd ComfyUI.
5. Install dependencies with python3 -m pip install -r requirements.txt. Watch for successful installations without errors, indicating ARM-compatible packages.
6. If you encounter compatibility issues, install Rosetta 2 via softwareupdate --install-rosetta and rerun commands using Terminal opened in Rosetta mode.
7. Run ComfyUI with python3 main.py. You should see MPS (Metal Performance Shaders) acceleration messages confirming native Apple silicon GPU support.

Benchmark comparisons show native ARM runs ComfyUI with noticeably faster startup and smoother interface responsiveness than Rosetta 2 translation. Terminal logs under native runs display "Using MPS backend for acceleration," whereas Rosetta runs show CPU fallback.

Testing ComfyUI on M1 and M4 confirms improved performance when installed natively. If issues arise, switching to Rosetta 2 offers a reliable workaround at some speed trade-off.

How to install ComfyUI on MacBook Pro and MacBook

When installing ComfyUI on MacBook Pro or MacBook models, managing power and storage settings is crucial for maintaining performance during extended sessions. These portable Macs are optimized for energy efficiency, but ComfyUI's resource demands can challenge battery and thermal limits.

1. Adjust Battery Settings: Open System Settings > Battery > Energy Saver and disable Optimize video streaming while on battery and Automatic graphics switching. This prevents throttling and ensures consistent GPU usage, which you should see reflected as stable performance during ComfyUI runs.
2. Connect Power Adapter: Plug in your MacBook to avoid power-saving modes that reduce CPU and GPU speeds. When connected, ComfyUI sessions should not experience unexpected slowdowns or interruptions.
3. Choose Storage Location: Install ComfyUI on the internal SSD for faster read/write speeds. For example, cloning the ComfyUI repository to /Users/yourname/ComfyUI optimizes load times. Using an external drive may conserve internal space but can introduce latency.
4. Monitor Thermal Conditions: Use Activity Monitor to observe CPU and GPU usage and ensure fans activate as needed. Keeping the MacBook on a hard, flat surface improves cooling and helps maintain session stability.
5. Run ComfyUI from Terminal: Start ComfyUI in a Terminal window to monitor logs for any performance warnings. Smooth operation with no repeated lag or crashes indicates successful setup on your MacBook model.

Balancing power settings and storage choices helps you run ComfyUI efficiently on portable Macs without sacrificing battery life or speed.

How to manually install ComfyUI

Manually installing ComfyUI involves downloading the source code and dependencies without relying on package managers or automated scripts, allowing full control over the setup.

1. Download the ComfyUI source code. Visit the official repository and download the ZIP archive or clone the repository with git clone. Upon success, the source folder with all files should appear in your chosen directory.
2. Download required Python dependencies. Identify dependencies listed in requirements.txt. For each, download the corresponding wheel (.whl) or source package from PyPI or trusted mirrors. Save these files locally.
3. Set up a Python virtual environment manually. Run python3 -m venv comfyui-env in Terminal. Activate it with source comfyui-env/bin/activate. The prompt should change to indicate the activated environment.
4. Install dependencies locally. Use pip install --no-index --find-links=./path_to_downloaded_packages dependency_name for each dependency. This installs them without fetching from the internet.
5. Configure environment variables and PATH. Edit your shell profile file (e.g., ~/.zshrc or ~/.bash_profile) to include export PATH="$HOME/comfyui-env/bin:$PATH" and export PYTHONPATH="/path/to/comfyui/source". Save and reload the profile with source ~/.zshrc. Confirm by running echo $PATH and echo $PYTHONPATH.
6. Handle dependency conflicts. If version mismatches occur, manually adjust the installed package versions by uninstalling with pip uninstall package_name and installing a specific version with pip install package_name==version. Verify with pip show package_name.
7. Run ComfyUI manually. Navigate to the source directory and execute python3 main.py. Successful launch shows initialization logs and UI access information in Terminal.

Sample ~/.zshrc additions might look like:

Typical output after running python3 main.py includes lines like:

Loading ComfyUI modules...
Dependencies loaded successfully.
ComfyUI is running at http://localhost:8188

This manual process demands more attention to detail but offers flexibility and avoids issues from automated scripts.

How to install ComfyUI on Windows and Windows 11

Installing ComfyUI on Windows shares similarities with the Mac process but involves a few platform-specific steps. Windows users often benefit from the ComfyUI Manager, a dedicated application that simplifies setup and updates, unlike the terminal-based approach on Mac.

1. Download and install Python 3.10 or later from the official Python website. Once installed, confirm Python is accessible by running python --version in Command Prompt; it should display the installed version.
2. Download Git for Windows and install it, ensuring the option to use Git from the Windows Command Prompt is enabled. Verify by running git --version.
3. Obtain the ComfyUI Manager from the official repository or releases page. Launching it will guide you through cloning the ComfyUI source and managing dependencies automatically.
4. After installation, run ComfyUI via the Manager interface. A successful launch shows the web UI accessible at http://127.0.0.1:8188 in your browser.
5. Windows users should watch for common issues like missing Visual C++ Redistributables, which can cause runtime errors. Installing the latest Microsoft Visual C++ packages often resolves these.

Choosing Windows may be preferable if you already use Windows for other workflows or require compatibility with specific GPU drivers, especially for Nvidia cards where CUDA support is stronger than on Mac.

Choosing where to install ComfyUI on Mac

Deciding on the installation location for ComfyUI on your Mac involves balancing performance, security, and ease of updates. Installing on the system drive (usually your Mac’s internal SSD) offers the fastest load and response times, thanks to high-speed internal buses and optimized file access. User reports often highlight quicker UI startup and smoother node processing when ComfyUI resides on the system drive.

Alternatively, installing ComfyUI on an external or secondary drive can save internal storage space, especially on Macs with limited SSD capacity. However, external drives typically have slower data transfer speeds, which may cause longer load times and slightly reduced responsiveness during complex workflows.

Security and permission considerations also influence your choice. The system drive requires standard user permissions and integrates seamlessly with Mac’s security framework, minimizing permission errors. External drives may need manual permission adjustments in Finder’s Info panel or via Terminal to allow full read/write access for ComfyUI.

To change the installation path safely, follow these steps:

1. Locate your current ComfyUI folder in Finder and close any running instances to prevent file conflicts.
2. Copy the entire ComfyUI folder to your desired location—whether an external drive or a specific folder on the system drive.
3. Open Terminal and navigate to the new ComfyUI directory using cd commands; verify all dependencies remain intact.
4. Update any scripts or shortcuts pointing to the old location to reflect the new path.
5. Run ComfyUI from the new location; successful launch and normal performance confirm the move was effective.

Choosing the system drive ensures optimal speed and simpler maintenance, while external locations offer flexibility at a minor performance cost and require careful permission management.

Troubleshooting common ComfyUI installation issues on Mac

Installation errors often stem from dependency conflicts, permission issues, Python environment problems, or startup failures. Addressing these promptly ensures a smooth ComfyUI experience.

Resolving dependency conflicts

If you see errors like "ModuleNotFoundError" or "VersionConflict", this indicates mismatched or missing Python packages. To fix:

1. Open Terminal and activate your Python environment if you use one (e.g., source ~/venv/bin/activate).
2. Run pip install --upgrade -r requirements.txt inside the ComfyUI directory to refresh dependencies.
3. If conflicts persist, uninstall conflicting packages individually with pip uninstall <package-name> and reinstall.
4. Verify success when pip check reports no broken dependencies.

Fixing permission and access errors

Errors like "Permission denied" or "Operation not permitted" often occur when Terminal lacks access rights.

1. Go to System Preferences > Security & Privacy > Privacy tab > Full Disk Access.
2. Add Terminal (or your preferred shell) to the list by clicking the plus button.
3. Restart Terminal and rerun ComfyUI commands.
4. Success is indicated by the absence of permission errors during execution.

Fixing Python environment problems

If ComfyUI fails to launch with errors like "python command not found" or version mismatches, confirm your Python setup:

1. Check Python version with python3 --version; ComfyUI requires Python 3.9 or later.
2. If incorrect, install or update Python via Homebrew: brew install python.
3. Ensure your PATH includes Python's bin directory by running echo $PATH.
4. Test by running python3 -m pip --version to confirm pip is linked.

Dealing with ComfyUI startup failures and logs analysis

When ComfyUI fails on startup, review the logs generated in your ComfyUI folder (usually comfyui.log or Terminal output).

1. Run python3 main.py in Terminal and watch for error messages.
2. Note specific errors, such as "CUDA not found" (Windows-only) or missing dependencies.
3. Search for the error in official GitHub issues or forums for targeted fixes.
4. After applying fixes, rerun ComfyUI; a successful launch shows the UI loading without errors.

More on this topic

• How to Install Miniconda on Mac: A Clear Step-by-Step Guide
• How to Install PyTorch with MPS Support on Mac: A Step-by-Step Guide
• How to Install TensorFlow with Metal on Mac: A Step-by-Step Guide
• How to Install Jupyter Notebook on Mac: A Clear Step-by-Step Guide

Frequently asked questions

How to install comfyui on macos?

To install ComfyUI on macOS, you first need to ensure you have Python 3.10 or newer installed, along with Git. Clone the ComfyUI repository, then run the setup commands in the terminal. Depending on your Mac’s architecture, you might need to install additional dependencies or use Rosetta 2 for compatibility.

How to install comfyui on mac intel?

On Mac Intel, installation involves cloning the ComfyUI repo and running the setup script using the Terminal. Make sure to have Homebrew installed, then use it to install Python 3.10+ if needed. The process is straightforward and does not require emulation layers, allowing native performance.

How to install comfyui on mac m1?

For Mac M1, you should install the ARM-compatible versions of Python and dependencies. Using Homebrew for ARM, install Python 3.10 or newer. Clone ComfyUI and run the installation commands in the Terminal, ensuring you avoid running under Rosetta unless a specific dependency requires it.

How to install comfyui on mac m4?

Installing ComfyUI on Mac M4, the latest Apple silicon, is similar to M1 but may require updated ARM-native software versions. Use Homebrew ARM to install Python and dependencies. Clone the repository and follow the standard setup, paying attention to any new compatibility notes for this architecture.

How to install comfyui manager?

ComfyUI Manager is a separate tool that can be installed via Python’s package manager pip. After ensuring Python and pip are set up, run pip install comfyui-manager in the terminal. This utility helps manage multiple ComfyUI instances and configurations, streamlining your workflow.

Limits of this guide

This guide does not cover using ComfyUI with custom plugins or advanced GPU configurations beyond the native support available on Apple silicon chips. If you require multi-GPU setups, specialized CUDA support, or integration with third-party extensions, consider consulting dedicated forums or official ComfyUI resources. Additionally, users seeking detailed optimization for large-scale workflows or enterprise environments may need professional assistance or more complex installation methods.

The single most useful next step is to verify your installation by launching ComfyUI and running a basic workflow. This ensures your environment is correctly set up and helps identify any missing dependencies early. If you encounter issues, revisit the troubleshooting section, focusing on common pitfalls such as Python version mismatches or permissions errors. Starting with a simple test builds confidence before exploring more complex configurations or cross-platform setups.