ComfyUI on AMD GPUs: installing with ROCm step by step

#ComfyUI on AMD: which installation path to choose

ComfyUI is built on PyTorch. On an NVIDIA card, PyTorch goes through CUDA; on a Radeon, it goes through ROCm, AMD's compute stack, whose HIP layer exposes an interface deliberately close to CUDA. That's why ComfyUI shows “cuda” even on an AMD card: PyTorch keeps that name for the device regardless of the brand. So the whole job comes down to getting a version of PyTorch built for ROCm, and a driver that lets it access the GPU.

Windows, recent Radeon

ComfyUI Desktop with ROCm, the official path documented by AMD and announced by Comfy.org. It's the easiest option: the installer takes care of Python, PyTorch, and the dependencies.

Linux

Installation from source with a Python virtual environment and the PyTorch ROCm wheels. This is the oldest, best-documented path and the one that covers the most cards, including through a workaround for unlisted models.

Linux, server, or shared machine

Docker on a ROCm image provided by AMD. Handy for isolating ComfyUI from the rest of the system and starting from scratch if something breaks.

Windows, older Radeon

No official ROCm path. The fallback options (DirectML, or switching to Linux) are covered in the troubleshooting section.

If you're new to ComfyUI, keep our beginner's installation guide handy: the interface, nodes, and model placement are identical on AMD and on NVIDIA. Only the hardware layer changes, and that's what this guide covers.

#Prerequisites and supported cards

The list of GPUs that ROCm supports changes with every release, and it isn't the same on Windows and Linux. Don't rely on a forum or an old tutorial. When you install, open the compatibility matrix in the "ROCm on Radeon and Ryzen" documentation and find your card and operating system in the table for the current release.

Architecture

The official paths primarily target RDNA 3 (RX 7000) and RDNA 4 (RX 9000) Radeon cards, as well as some Ryzen AI processors with integrated graphics. RDNA 2 (RX 6000) cards remain usable on Linux, often with a workaround variable. Check your exact model in the matrix.

Windows driver

AMD Software: Adrenalin Edition, at the minimum version listed on AMD's installation page. An outdated version is the most common cause of failure on Windows.

Linux driver

The amdgpu kernel driver from an up-to-date distribution, with access to the /dev/kfd and /dev/dri devices. The PyTorch ROCm wheels bundle the compute libraries they need, but a full ROCm install is still useful for diagnostic tools like rocminfo.

Python

For a manual installation, a Python version supported by the chosen PyTorch wheel. The pytorch.org selector tells you which.

Disk

Plan for several gigabytes for PyTorch ROCm alone, plus the size of the image models, each of which ranges from a few gigabytes to more than ten.

Video memory

It determines which models you can use, just as on NVIDIA. On a Ryzen processor with integrated graphics, you set the amount of memory reserved for the GPU in the BIOS or in the AMD software.

#Windows: ComfyUI Desktop with ROCm

ComfyUI Desktop is Comfy.org's official installer app. On a supported AMD card, it installs a ROCm-compatible version of PyTorch without you having to deal with pip indexes. AMD's page on installing ComfyUI on Windows and Comfy.org's announcement of official AMD ROCm support are the two references to follow: if they differ from this guide, they take precedence.

1. 01
   Update the driver

   Install the version of AMD Software Adrenalin Edition required by AMD's documentation, then restart. Depending on the version, the Adrenalin installer also offers optional AI components: you don't need them to follow this guide.
2. 02
   Download ComfyUI Desktop

   Get the Windows installer from the comfy.org download page, never from a mirror site. Run it with your regular user account.
3. 03
   Select the AMD GPU

   At the hardware selection step, choose the AMD option. If it doesn't appear or stays grayed out, your installer version or your card isn't supported: check the compatibility matrix before going any further.
4. 04
   Choose the data location

   Pick a folder on a drive with plenty of free space: models, outputs, and custom nodes pile up quickly. If you already had a ComfyUI installation, the wizard can import its models.
5. 05
   Let the installation finish

   The first launch downloads Python, PyTorch, and the dependencies. It takes a while and uses a lot of space, which is normal. Don't close the window until the interface appears.
6. 06
   Check the log

   Open the logs from the app menu and look for the “Device” line: it should name your Radeon. If it shows the CPU, PyTorch didn't find the GPU: see the troubleshooting section.

For a portable version without an installer, check the releases page of the ComfyUI GitHub repository: see whether an archive for AMD cards is listed for the current version, and follow the instructions that come with it. Don't pair an archive designed for NVIDIA with an AMD card: it contains a CUDA build of PyTorch that will never see your Radeon.

#Linux: installing ComfyUI for AMD from source

On Linux, manual installation is still the most flexible option. It boils down to three steps: give your user access to the GPU, install PyTorch ROCm in a virtual environment, then install ComfyUI on top without overwriting that PyTorch.

1. 01
   Granting GPU access

   Add your user to the render and video groups, then log out and log back in. Without this, PyTorch can't open /dev/kfd and doesn't see any GPU.
2. 02
   Check that the system sees the card

   If ROCm is installed, rocminfo should list a GPU-type agent with a gfx identifier (for example, gfx1100 for a RX 7900 XTX, gfx1201 for a RX 9070 XT). Write down this identifier: you'll need it for troubleshooting.
3. 03
   Create the Python environment

   Clone ComfyUI, create a virtual environment in its folder, and activate it. Every work session will start with this activation.
4. 04
   Install PyTorch ROCm first

   On pytorch.org, on the Get Started page, choose Linux, Pip, Python, and ROCm: the site shows the exact command and the current ROCm version. Install this PyTorch before any other dependency.
5. 05
   Install ComfyUI and launch it

   Install ComfyUI's dependencies, then run main.py. By default, the interface is served at http://127.0.0.1:8188.

sudo usermod -a -G render,video $LOGNAME
# Fermez la session puis reconnectez-vous, et vérifiez :
groups
rocminfo | grep -i gfx

git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
python3 -m venv .venv
source .venv/bin/activate

# Remplacez rocmX.Y par la version affichée sur pytorch.org (Get Started > Linux > Pip > ROCm)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocmX.Y

pip install -r requirements.txt
python main.py

The ComfyUI README also describes an experimental path, on Windows and Linux, using PyTorch wheels published by AMD for some RDNA 3, 3.5, and 4 architectures. It's changing fast: if you want to try it, copy the command directly from the AMD section of the README rather than from a tutorial, because the index URLs depend on your card's architecture.

#Docker with a ROCm image

AMD publishes rocm/pytorch images on Docker Hub that contain ROCm and a PyTorch already built for it. To our knowledge, there's no official ComfyUI image for AMD: the cleanest approach is to start from AMD's image and install ComfyUI in it. The host only needs the amdgpu driver; the container gets GPU access through the /dev/kfd and /dev/dri devices.

mkdir -p $HOME/comfyui-docker

docker run -it \
  --name comfyui-rocm \
  --device=/dev/kfd --device=/dev/dri \
  --group-add video --ipc=host \
  --security-opt seccomp=unconfined \
  -p 127.0.0.1:8188:8188 \
  -v $HOME/comfyui-docker:/workspace \
  rocm/pytorch:latest

cd /workspace
git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt
python3 main.py --listen 0.0.0.0 --port 8188

Image tag

latest changes with each ROCm release. For an installation you want to reproduce, write down the exact tag you used and reuse it, after checking that it supports your card.

Volume

The folder mounted at /workspace keeps ComfyUI, its models, and its outputs when the container is removed. Without it, you start over from scratch.

Exposition

The port is published on 127.0.0.1: only the host machine can access the interface. Don't expose ComfyUI on an open network: it has no authentication by default, and custom nodes execute code.

Relance

docker start -ai comfyui-rocm rouvre le même conteneur, sans réinstaller.

The same warning applies as for a manual installation: after pip install, check that the container's PyTorch is still AMD's.

#Verify that the AMD GPU is actually doing the work

An install that starts up proves nothing, since ComfyUI can fall back to the CPU. Two checks are enough. The first queries PyTorch directly, in the environment ComfyUI runs in.

python -c 'import torch; print(torch.__version__); print(torch.version.hip); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0))'

torch.version.hip

Should display a version number. None means this PyTorch wasn't built for ROCm: it's almost always a CUDA or CPU PyTorch installed by mistake.

torch.cuda.is_available()

Should print True. Seeing the word cuda on AMD is normal: PyTorch reuses that interface for HIP.

get_device_name(0)

Should name your Radeon. If it's the processor's integrated graphics, see the item on the wrong GPU in the troubleshooting section.

The second check happens during a render: on Linux, rocm-smi or amd-smi show GPU utilization and memory usage; on Windows, Task Manager or the Adrenalin software show the card's load. If the CPU climbs to 100% while the GPU stays idle, the computation isn't running on the Radeon.

#Common driver and detection errors

"hipErrorNoBinaryForGpu" or "Unable to find code object"

The installed PyTorch doesn't contain code for your card's architecture. On Linux, for a card close to a supported architecture, the ComfyUI README points to the HSA_OVERRIDE_GFX_VERSION variable: 10.3.0 for RDNA 2 cards such as the RX 6700 or 6600, 11.0.0 for RDNA 3 cards such as the RX 7600. This is a workaround that AMD does not guarantee.

No GPU detected on Linux

After logging back in, check that you belong to the render and video groups (groups command), then check that /dev/kfd exists. In Docker, make sure the --device options were actually passed.

Wrong GPU selected

On a machine with AMD integrated graphics and a Radeon, PyTorch may see two devices. Restrict it to the discrete card with HIP_VISIBLE_DEVICES, using the order shown by rocminfo.

AMD option missing in ComfyUI Desktop

The driver is too old, the installer version predates ROCm support, or the card isn't in the compatibility matrix. Update Adrenalin and the installer, then check compatibility again.

ComfyUI runs on the CPU after adding a node

A node reinstalled torch. Reinstall PyTorch ROCm using the command from pytorch.org, then check torch.version.hip.

Older Radeon on Windows

ComfyUI accepts a --directml option with the torch-directml package. The README describes it as poorly supported, so keep it for troubleshooting. For regular use on a RX 6000, Linux is still the most reliable path.

# Carte RDNA 2 non listée (ex. RX 6700 XT), selon le README de ComfyUI
HSA_OVERRIDE_GFX_VERSION=10.3.0 python main.py

# Carte RDNA 3 non listée (ex. RX 7600)
HSA_OVERRIDE_GFX_VERSION=11.0.0 python main.py

# N'utiliser que le premier GPU listé
HIP_VISIBLE_DEVICES=0 python main.py

#Running out of video memory: useful settings

On AMD, running out of memory shows up as an error like "HIP out of memory" instead of "CUDA out of memory." The fixes are the same as on NVIDIA: start with ComfyUI's launch options, then look at your choice of model and resolution.

--lowvram

Splits the model and loads it in chunks. Slower, but lets you fit larger models.

--novram

Goes even further, for when --lowvram isn't enough.

--reserve-vram

Reserves an amount of memory, in gigabytes, that ComfyUI won't touch. Useful when the display, the browser, or another program share the same card.

--cpu-vae

Moves VAE decoding to the CPU. The VAE Decode (Tiled) node is another option, which stays on the GPU by working in tiles.

Resolution and batch size

Reduce the image size or the number of images per batch before switching models: memory used during decoding grows with them.

Quantized models

Reduced versions (FP8, GGUF via a dedicated node) exist for several large image models. Check that the format is supported by your PyTorch ROCm version before relying on it.

PYTORCH_HIP_ALLOC_CONF

The AMD equivalent of PYTORCH_CUDA_ALLOC_CONF. Setting it to expandable_segments:True can reduce memory fragmentation; the effect depends on the PyTorch version.

python main.py --lowvram --reserve-vram 1

# Variante : allocation moins fragmentée
PYTORCH_HIP_ALLOC_CONF=expandable_segments:True python main.py --lowvram

The ComfyUI README also mentions a variable, TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1, to combine with --use-pytorch-cross-attention to enable more memory-efficient attention on some AMD cards. It's experimental; if it causes errors, remove it before looking for another cause.

#What this guide doesn't promise

We ran no speed tests for this guide, and you won't find render times or comparisons with a NVIDIA card here. ComfyUI performance on AMD depends on the card, the ROCm version, the PyTorch version, the model, and the attention options. A standalone number without that context wouldn't tell you anything. The commands above follow the AMD and PyTorch documentation and the ComfyUI README. We deliberately leave version numbers for you to look up in those sources, because they change faster than a guide does.

Also keep in mind that custom nodes are usually written for CUDA. Some call libraries specific to NVIDIA and will fail on a Radeon, even if ComfyUI itself works. Before installing a complex workflow, check each node's repository to see whether it mentions ROCm or AMD.

#Go further

Once ComfyUI is up and running on your Radeon, these guides pick up where the installation leaves off: first steps in the interface, the same ROCm setup work for Ollama if you also want to run LLMs, and the spec sheets for the most common AMD cards.