Install ComfyUI on a Mac, an AMD card or a rented GPU

On an Apple Silicon Mac, install Comfy Desktop from comfy.org and use FP16 or GGUF model files instead of FP8. On an AMD Radeon card, use ComfyUI's official AMD build on Windows, or ComfyUI with PyTorch for ROCm on Linux. With no suitable GPU, rent one by the hour on Runpod with the official ComfyUI template and a network volume, or open Comfy Cloud, Comfy Org's own hosted ComfyUI, in your browser.

Checked on 2 October 2026 against ComfyUI v0.38.0 (released 29 September 2026) and the official pages listed under Sources. I run ComfyUI on one Nvidia card, so I have not run these three routes myself: every step below comes from the official documentation. Install steps change often. If this page and an official page disagree, follow the official page.

Mac: install ComfyUI on Apple Silicon

Who this is for

Any Mac with an Apple M-series chip (M1 or newer) on macOS 13 Ventura or later. Those are Comfy Desktop's requirements, and its FAQ asks for 8 GB of memory at minimum, 16 GB recommended. To check your Mac, open the Apple menu → About This Mac. Comfy Desktop doesn't run on an Intel Mac, and Apple's PyTorch guide needs Apple silicon too, so on an Intel Mac go to the cloud section.

What works on a Mac, and what doesn't

• Images: yes. ComfyUI runs on the Mac's GPU through PyTorch's MPS backend, which is Apple's Metal. You don't switch anything on: Comfy Desktop sets it up. The nodes and workflows are the same as in the course.
• FP8 model files: often not. PyTorch's MPS backend doesn't support the FP8 data type, so an FP8 file can stop with a Float8_e4m3fn error. Download the FP16 (or BF16) version of the same model, or a GGUF version. That's the advice from Part 1: on a Mac, you work with FP16 and GGUF files. The glossary explains the letters.
• Memory is shared. A Mac's memory is unified: macOS, your apps and the GPU all use the same pool, so the GPU gets most of it but never all of it. A 16 GB Mac is not a 16 GB graphics card. The course's rule of thumb, model file size plus about 2 GB, still helps, but leave room for macOS.
• Video: limited. In Part 1's hardware tiers, Macs and AMD cards share a tier: images work, video is limited, and a rented GPU helps with heavy video jobs. That said, I know creators who run Mac Studios and do almost everything I do.
• Nvidia-only extras don't run. CUDA is Nvidia's. A custom node or speed-up that needs CUDA won't work on a Mac. If a node's page says it needs CUDA or an Nvidia card, believe it.

Install Comfy Desktop, step by step

1. Check your Mac. Apple menu → About This Mac: you need an Apple M-series chip and macOS 13 Ventura or later. The first install also needs an administrator account.
2. Download Comfy Desktop from comfy.org/download. Only from there. The page picks the Mac version for you.
3. Install it. Open the .dmg file, drag Comfy Desktop into Applications, then start it from Launchpad or Spotlight.
4. If macOS blocks it on the first launch, open System Settings → Privacy & Security and click Open Anyway.
5. Create your ComfyUI. Click the + card (New Instance), give it a name and choose an install location on a drive with plenty of space: 30 GB or more, as in Part 1, because models add up fast. Keep the Standalone option. Comfy Desktop then downloads Python, PyTorch and ComfyUI by itself. Let it run.
6. Done. When the install finishes, ComfyUI opens on the template library. You can close it for now: Part 1 shows you how to get back to it.

Today's Comfy Desktop is a rewrite of the original app: a launcher that manages several ComfyUI installs side by side, which it calls instances. If your screens look different from older videos, that's why. The ComfyUI inside is the same.

Your models go in a shared model library that every instance uses, ~/ComfyUI-Shared by default. To use a model folder you already have, add it under Desktop Settings → Storage.

Prefer the Terminal? The manual install

ComfyUI's README also documents a manual install for Apple silicon: the PyTorch nightly from Apple's guide, then ComfyUI's own requirements. Apple's guide (written for PyTorch 2.11.0) asks for macOS 14 or later, Python 3.10 or later and the Xcode command-line tools. ComfyUI recommends Python 3.13. The python3 that comes with the command-line tools is older than that, so install Python 3.13 first, from python.org or with Homebrew, and make the virtual environment with it.

xcode-select --install
brew install python@3.13        # or the installer from python.org
git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
python3.13 -m venv .venv
source .venv/bin/activate
pip3 install --pre torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/nightly/cpu
pip install -r requirements.txt
python main.py

The PyTorch address ends in cpu, but it's the command Apple's guide gives for the nightly with the latest MPS support. When ComfyUI is running, open the address it prints, http://127.0.0.1:8188, in your browser.

First launch: check these

• ComfyUI found the GPU. Its log should show the line Device: mps. In Comfy Desktop, open the instance's Manage panel and its Terminal tab. With a manual install, it's in the Terminal window. Device: cpu means ComfyUI is running without the GPU.
• PyTorch sees Metal (manual install): python -c "import torch; print(torch.backends.mps.is_available())" should print True.
• One small image works. Load a simple image template with an FP16 model and press Run. If an image comes out, your install is fine and the rest of Part 1 applies to you.

Common errors on a Mac

• Trying to convert Float8_e4m3fn to the MPS backend but it does not have support for that dtype. The model file is FP8. Download the FP16 or GGUF version of the same model. On ComfyUI's GitHub this error was closed as a limitation of PyTorch's MPS support, not a ComfyUI bug. Community patches exist, but they are unofficial and an update can overwrite them.
• macOS won't open the app on the first start. System Settings → Privacy & Security → Open Anyway.
• An error says an operation isn't supported on the MPS device. Some PyTorch operations have no Metal version yet. Starting ComfyUI with PYTORCH_ENABLE_MPS_FALLBACK=1 runs those operations on the processor instead: slower, but it finishes. With a manual install: PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py.
• A GGUF model won't load. GGUF files need the ComfyUI-GGUF custom node: its Unet Loader (GGUF) node replaces Load Diffusion Model, and the files go in ComfyUI/models/unet. Its README has a macOS note about PyTorch versions. If a GGUF still fails, use the FP16 file.
• Generation crawls and the whole Mac slows down. The job wants more memory than the GPU can get. Step down one size (FP16, then GGUF Q8, Q6, Q4), lower the resolution and close other apps. "Step down one size" is the rule from Part 1, Module 2.

Official pages for the Mac: Comfy Desktop for macOS · ComfyUI system requirements · Apple: Accelerated PyTorch training on Mac · ComfyUI README: Apple Mac silicon

AMD: install ComfyUI on a Radeon card

Who this is for

Owners of a Radeon RX 9000, RX 7000 or RX 6000 card, or a Ryzen AI Max machine, on Windows 11 or Linux. AMD's ROCm 10.0 compatibility matrix lists the RX 9000 and RX 7000 series and the Ryzen AI processors. The RX 6000 series isn't on AMD's list, but ComfyUI's README names RDNA 2, the RX 6000 generation, among the supported architectures on Windows, and AMD's ROCm development tracker (TheRock) marks RDNA 2 release-ready on Windows and Linux. For older cards, see older cards and ZLUDA.

What works on an AMD card, and what doesn't

• ComfyUI runs on the card. ROCm is AMD's counterpart to Nvidia's CUDA, and ComfyUI now ships an official AMD build for Windows. PyTorch even reports an AMD card as a cuda device, so most of ComfyUI doesn't notice the difference. Part 1's tiers still put AMD cards next to Macs: images work, video is more limited, and a rented GPU helps with heavy video.
• FP8 speed-up only on the RX 9000 series. ComfyUI switches on FP8 maths for Nvidia cards that support it and, on AMD, for RDNA 4 (the RX 9000 series) with PyTorch 2.7 or newer and ROCm 6.4 or newer. On an RX 7000 or older card, an FP8 model gets no FP8 speed-up. If an FP8 file gives an error, use the FP16 or GGUF version.
• Nvidia-only extras don't run. Custom nodes and speed-ups built only for CUDA won't work. The ZLUDA build's README, for example, says xformers isn't usable.
• Expect extra setup. As Part 1 says: it isn't difficult, but there are a couple of extra steps. Do them in order.

Windows: the official ComfyUI portable for AMD

Comfy Desktop's requirements list AMD cards too, but its documentation doesn't describe how it sets them up, so this guide uses the AMD build that ComfyUI's README documents.

1. Update Windows and the driver. For ROCm on Windows, ComfyUI's README asks for Windows 11 and a current AMD graphics driver.
2. Download the AMD portable from ComfyUI's releases on GitHub. The file is ComfyUI_windows_portable_amd.7z, 1.61 GB for v0.38.0.
3. Extract it with 7-Zip, or with Windows Explorer on recent Windows, onto a drive with 30 GB or more free, ideally an SSD. Not in Program Files and not in a OneDrive folder. If Windows won't extract it, right-click the file → Properties → Unblock.
4. Start it with run_amd_gpu.bat in the extracted folder. A console window opens and ComfyUI starts. Keep that window open: it's the engine room from Part 1. The interface is at http://127.0.0.1:8188.
5. Models go in the subfolders of ComfyUI\models\, exactly as in Part 1, Module 7.
6. Updates: the update folder has update_comfyui_stable.bat (the latest stable release) and update_comfyui.bat (the latest commit).

Windows: manual install with ROCm 10.0

If you'd rather use your own Python, ComfyUI's README installs AMD's multi-architecture PyTorch packages. They bring the ROCm runtime with them, so you don't need AMD's separate HIP SDK. You need Windows 11, a current AMD driver, Git and 64-bit Python 3.13.

git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
py -3.13 -m venv .venv
.venv\Scripts\activate
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"
pip install -r requirements.txt
python main.py

device-all downloads the kernels for every supported card. To download less, replace both device-all with your card's target:

Linux: ComfyUI with PyTorch for ROCm

1. Driver and permissions. AMD's PyTorch guide needs the AMD GPU driver (amdgpu) installed. Check your card and your distribution in AMD's compatibility matrix. Then add yourself to the video and render groups, and log out and back in so the change applies:

   sudo usermod -a -G video,render $LOGNAME

2. Install ComfyUI and PyTorch for ROCm 7.2, the stable command from ComfyUI's README:

   git clone https://github.com/Comfy-Org/ComfyUI.git
   cd ComfyUI
   python3 -m venv .venv
   source .venv/bin/activate
   pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.2
   pip install -r requirements.txt
   python main.py

3. Open http://127.0.0.1:8188 in your browser.

Comfy Desktop also has Linux packages, but its documentation doesn't say how it sets up AMD cards, so this guide sticks to the route in ComfyUI's README.

Older cards and ZLUDA

Part 1 mentions a ZLUDA build for AMD on Windows. That's ComfyUI-Zluda, a Windows-only community fork that runs ComfyUI on AMD cards through ZLUDA. Today ComfyUI's own AMD build is the first thing to try on an RX 6000 or newer, and the fork's README itself points RDNA 1 to RDNA 4 owners to a separate ROCm-based project. Keep ZLUDA for cards the official route doesn't cover, such as the RX 400 and RX 500 series and Vega. The RX 5000 series (RDNA 1) sits in between: AMD's tracker marks it release-ready, but ComfyUI's README doesn't name it, so try the official route first.

The ZLUDA fork needs its own setup: Git, Python, the Visual C++ runtime, the Visual Studio Build Tools and AMD's HIP SDK, in the version its README names for your card's generation. Read its README from top to bottom before you start, including its note on antivirus warnings.

First launch: check these

• The console names your card. Look for Device: cuda:0 followed by your card's name, then the lines AMD arch: (for example gfx1100 on an RX 7900 XTX) and ROCm version:. Device: cpu means PyTorch can't see the card.
• Check PyTorch directly (manual installs): python -c "import torch; print(torch.cuda.is_available())" prints True when ROCm and your card are detected. That's AMD's own check.
• The address line. The console prints To see the GUI go to: http://127.0.0.1:8188. Open it, load a simple image template and press Run.

Common errors on an AMD card

• The 7z file won't extract. Right-click it → Properties → Unblock, then extract again.
• Device: cpu, or torch.cuda.is_available() prints False. Update the AMD driver first. On Windows, ROCm needs Windows 11. On Linux, check the video and render groups and that your card is on AMD's list. With a manual install, make sure you installed the ROCm build of PyTorch: run the install command again inside the activated .venv.
• ComfyUI uses the processor's built-in Radeon graphics instead of the card. Add --cuda-device 1 to the start command. In the portable, open run_amd_gpu.bat in Notepad and add it to the end of the line that starts ComfyUI. ComfyUI hands the number to ROCm as HIP_VISIBLE_DEVICES; the ComfyUI-Zluda README gives the same fix for this problem. If 1 isn't your card, try 0 or 2.
• Linux: ROCm doesn't officially support your card. ComfyUI's README suggests overriding the reported architecture: HSA_OVERRIDE_GFX_VERSION=10.3.0 python main.py for an RX 6700, RX 6600 and possibly other RDNA 2 or older cards, HSA_OVERRIDE_GFX_VERSION=11.0.0 python main.py for an RX 7600 and possibly other RDNA 3 cards.
• Slower than you hoped. ComfyUI's README suggests trying PYTORCH_TUNABLEOP_ENABLED=1. It might speed things up, at the cost of a very slow first run.
• An FP8 model gives an error. Use the FP16 or GGUF version of the same model.

Official pages for AMD: ComfyUI README: AMD GPUs · ComfyUI Portable for Windows · AMD: Install PyTorch for ROCm · ROCm compatibility matrix · ROCm on Linux: prerequisites

No GPU: rent one in the cloud

Who this is for

No graphics card, an Intel Mac, a laptop with a small GPU, or a job your card can't do. In Part 1's tiers, "No GPU" means renting a cloud GPU by the hour. You run the same ComfyUI, in your browser. There are two ways to do it.

• Rent a machine (Runpod). You get a GPU and full control: install any custom node and any model, and run your own workflows. The most setup, and the most freedom. This is what the course uses.
• Hosted ComfyUI (Comfy Cloud). Comfy Cloud is Comfy Org's own cloud version of ComfyUI, on Blackwell RTX 6000 Pro GPUs. Nothing to install: models and custom nodes come pre-installed, and you can import models from Civitai and Hugging Face. There's a free tier and paid plans. A session bills only while the GPU is working, and closing the tab stops it. The catch: you get their custom nodes, not any node you like, so a workflow that needs a node they don't have won't run there.

What works in the cloud, and what doesn't

• Everything in the course. A Runpod pod runs the same ComfyUI on an Nvidia GPU: same nodes, same workflows, same Manager. From Module 4 of Part 1 on, nothing changes.
• Bigger cards than you'd buy. You choose the GPU each time you start a pod, from an RTX 4090 to an RTX 5090 or a data-centre card, and only for as long as you need it.
• It costs money while it's on. Runpod bills pods by the second while they run, whether you're generating or only moving nodes around. Stop the pod when you finish.
• Licences don't change. A model's licence follows the model, not the machine it runs on. Part 2, Module 9 covers what you're allowed to sell.

Runpod, step by step

Part 2, Module 9 of the course, When your card says no, walks through this on screen with my own Runpod setup. It starts at 6:12:03 in the full course video. The short version:

1. Make an account and add credit. Runpod's own ComfyUI tutorial asks for at least $10 of credit (as of 2 October 2026).
2. Choose the GPU, then the data centre. The network volume and the GPU must be in the same data centre, and the GPUs you can pick depend on where the volume is. Check that a data centre has the card you want before you create anything.
3. Create the network volume first. Storage → New Network Volume: pick the data centre, a name and a size. I use 100 GB, which holds my MiniMax H3 and LTX 2.5 models. You can make a volume bigger later but never smaller. Network volumes only work with Secure Cloud pods.
4. Deploy a pod with the volume attached. Pods → Deploy, select Network Volume and your volume, choose a GPU, and pick the official ComfyUI - CUDA 12.8 template, the one Module 9 uses. For a Blackwell card (RTX 5090, RTX PRO 6000, B200), Runpod recommends its ComfyUI - CUDA 13.0 template. Then Deploy On-Demand. Attach the volume now: you can't add it to a pod that already exists.
5. Wait for the first start. The template copies ComfyUI onto your volume, at /workspace/runpod-slim/ComfyUI. The first start can take up to 30 minutes. It's ready when the pod's log shows [ComfyUI-Manager] All startup tasks have been completed.
6. Open ComfyUI. Connect → Connect to HTTP Service [Port 8188]. ComfyUI opens in a new tab at https://[POD_ID]-8188.proxy.runpod.net.
7. Install nodes and models from inside the pod. Use the Manager for custom nodes and its Model Manager for models, so they download straight onto the volume at data-centre speed and survive the pod. Don't click a download button that saves to your own computer.
8. Load your workflow JSON and press Run. It's the same graph you'd run at home. The template's ComfyUI can be several releases older than yours: if a node shows up red, update ComfyUI from the Manager first.
9. Save the pod as a template once it works, so next time you only press start.
10. Stop the pod when you're done. An idle pod bills like a busy one. Stopping releases the GPU, and the network volume keeps your files. Set a reminder on your phone.

The volume costs money even when no pod runs: $0.07 per GB per month for the first terabyte on Runpod's pricing page on 2 October 2026, so 100 GB is about $7 a month. If your balance reaches $0, Runpod stops your pods. The network volume survives, but its storage charges keep running, and an unpaid volume can eventually be deleted for good. Switch on low-balance notifications.

The template also runs a file browser on port 8080 and JupyterLab on port 8888. The file browser's default login is printed in the template's public README, so set your own with the FILEBROWSER_PASSWORD environment variable, and JUPYTER_PASSWORD for JupyterLab, in your saved template.

First launch: check these

• The port 8188 button says Ready, not Not Ready.
• The pod's log shows [ComfyUI-Manager] All startup tasks have been completed.
• Your volume is attached. Your files should be under /workspace/runpod-slim/ComfyUI: look with the file browser on port 8080 or JupyterLab on port 8888. Terminating a pod deletes everything that isn't on a network volume.
• One small image works. Load a simple image template, let the Manager fetch its model, and press Run.

Common errors in the cloud

• "Bad Gateway", or the port 8188 button says Not Ready. ComfyUI is still starting. Wait 2 to 3 minutes and refresh. The very first start can take up to 30 minutes. If it never comes up, read the pod's logs in the Runpod console.
• The GPU you want isn't offered, or the volume can't be attached. The volume is in a different data centre, or the pod already exists. Create the volume where the GPU is, and attach it while you deploy.
• A stopped pod comes back with zero GPUs. The machine's GPUs were rented out while yours was stopped. With a network volume, deploy a new pod on the same volume: your files are still there.
• Your models vanished after a stop. They were on the pod's container disk, which is cleared when a pod stops. Keep everything under /workspace on a network volume.
• ComfyUI fails to start, or stops with a CUDA error, on a Blackwell pod (RTX 5090, RTX PRO 6000, B200). Runpod's notes disagree on how well the CUDA 12.8 template covers these cards. The CUDA 13.0 template is built for them: deploy that one on the same volume.
• A workflow needs a custom node Comfy Cloud doesn't have. Comfy Cloud only runs its pre-installed nodes. Run that workflow on a rented pod instead.

Official pages for the cloud: Runpod: Generate images with ComfyUI · Runpod: Network volumes · Runpod: Manage Pods · Runpod's ComfyUI template source · Comfy Cloud

Sources

• Comfy-Org/ComfyUI README: the install options, the Windows portable downloads, the AMD (Linux and Windows) and Apple Mac silicon sections, the HSA override and the ROCm tips. The v0.38.0 release, for the AMD portable's file name and size.
• ComfyUI's code at v0.38.0: comfy/model_management.py for the Device:, AMD arch: and ROCm version: log lines and the FP8 maths check, and main.py for --cuda-device
• docs.comfy.org: System requirements, Comfy Desktop for macOS, Using Comfy Desktop, Instance management, Comfy Desktop FAQ, Manual install, ComfyUI Portable for Windows and Comfy Cloud
• Apple Developer: Accelerated PyTorch training on Mac, for the requirements, the nightly command and the MPS check
• PyTorch documentation: MPS environment variables, for PYTORCH_ENABLE_MPS_FALLBACK
• ComfyUI issue #8988 (the FP8 error on MPS, closed as a PyTorch MPS limitation) and discussion #13273 (the same error in 2026, with an unofficial patch)
• city96/ComfyUI-GGUF README: the GGUF loader node, its model folder and its macOS note
• AMD ROCm documentation: Install PyTorch for ROCm (supported cards, the driver requirement and the torch.cuda.is_available() check), the ROCm 10.0.0 compatibility matrix and the Linux prerequisites (video and render groups)
• ROCm/TheRock: GFX target lookup table and supported GPUs
• patientx/ComfyUI-Zluda README: the cards it covers, its prerequisites and its pointer to a ROCm-based project for RDNA 1 to RDNA 4
• Runpod documentation: Generate images with ComfyUI, Network volumes, Manage Pods and Pod pricing, all read on 2 October 2026
• runpod-workers/comfyui-base README: the official template's ports, folders, CUDA versions and ready message
• On this site: the ComfyUI From Zero course (Part 1, Modules 2 and 3, and Part 2, Module 9) and the ComfyUI glossary

Common questions

Can I run ComfyUI on a Mac?+

Yes, on an Apple Silicon Mac (M1 or newer) with macOS 13 Ventura or later. Install Comfy Desktop from comfy.org/download. It runs ComfyUI on the Mac's GPU through Apple's Metal, PyTorch's MPS backend. Use the FP16 or GGUF version of each model, because FP8 files can fail with a Float8_e4m3fn error. Comfy Desktop doesn't support Intel Macs, so on one of those, rent a cloud GPU.

Does ComfyUI work with AMD graphics cards?+

Yes. On Windows 11, ComfyUI ships an official portable build for AMD GPUs that runs on ROCm: download ComfyUI_windows_portable_amd.7z from ComfyUI's GitHub releases, extract it and start run_amd_gpu.bat. On Linux, install ComfyUI manually with PyTorch for ROCm 7.2. AMD lists the RX 9000 and RX 7000 series as supported, and ComfyUI's README names RDNA 2, the RX 6000 series, as well.

Do I need ZLUDA to run ComfyUI on an AMD card?+

Not for an RX 6000 or newer on Windows 11: ComfyUI's official AMD build runs on ROCm. ZLUDA, through the community ComfyUI-Zluda fork, remains the route for older cards such as the RX 400, RX 500 and Vega series.

How do I use ComfyUI without a GPU?+

Rent one. On Runpod, create a network volume, deploy a pod from the official ComfyUI template with the volume attached, open port 8188, and stop the pod when you finish, because it bills by the second while it runs. Or use Comfy Cloud, Comfy Org's hosted ComfyUI, in your browser. ComfyUI can also run on the processor alone with the --cpu flag, but it's slow.

Why do FP8 models fail on my Mac?+

Because PyTorch's MPS backend, which ComfyUI uses for Apple's GPU, doesn't support the FP8 data type. The error reads "Trying to convert Float8_e4m3fn to the MPS backend but it does not have support for that dtype." Download the FP16, BF16 or GGUF version of the same model instead.