How to Install ComfyUI on Fedora Linux with AMD GPU Support 2025

You need ComfyUI running on Fedora Linux with your AMD GPU at full speed. The good news is that Fedora packages ROCm 6 natively, making AMD GPU acceleration significantly easier than on Ubuntu. With proper ROCm configuration and PyTorch setup, your RX 6000 or 7000 series GPU will deliver professional-quality AI image generation performance.

Quick Answer: Install ComfyUI on Fedora with AMD GPU by setting up ROCm 6.x packages, installing PyTorch with ROCm support, configuring HSA_OVERRIDE_GFX_VERSION for your GPU architecture, and running ComfyUI in a Python virtual environment with proper dependencies.

You've been running ComfyUI on Windows or watching tutorial videos showing NVIDIA GPU setups. Your AMD Radeon RX 7900 XTX sits there with untapped potential. Ubuntu guides don't quite match your Fedora system. Official ROCm documentation mentions Fedora support but lacks the practical details you need.

Linux provides superior AI workload performance compared to Windows, and Fedora's native ROCm 6 packaging eliminates the repository configuration headaches that plague Ubuntu installations. While platforms like Apatero.com offer instant access without setup complexity, understanding the local installation process gives you complete control over your AI generation environment and eliminates cloud dependency.

Why Should You Use Fedora for AMD GPU AI Workloads?

Before diving into installation commands, understanding Fedora's advantages helps you appreciate why this distribution works particularly well for AMD GPU setups.

Fedora's Native ROCm Integration

According to the Fedora ROCm 6 Release documentation, Fedora includes ROCm 6 packages in the official repositories starting with Fedora 40. This means you don't need to add external AMD repositories, manage GPG keys, or worry about repository conflicts that plague Ubuntu installations.

The AMDGPU kernel driver ships with Fedora's kernel automatically. No separate driver installation required. The system recognizes your AMD GPU immediately after installation, and drivers update through normal system updates.

Fedora ROCm Advantages:

Ubuntu receives official AMD support and documentation, but Fedora's streamlined packaging often results in fewer installation problems. The trade-off is worth it for most users who value simplicity over corporate backing.

Understanding AMD GPU Architecture Requirements

Your specific AMD GPU architecture determines critical configuration values. Getting this wrong causes cryptic error messages or GPU detection failures.

AMD GPU Architecture Table:

The HSA_OVERRIDE_GFX_VERSION environment variable tells ROCm which architecture code to use. This override is necessary because PyTorch's pre-compiled ROCm binaries don't include optimizations for every GPU variant. For modern gaming and professional approaches, compare this to running Flux on Apple Silicon hardware.

How Do You Install ROCm and Configure AMD GPU Support?

The installation process splits into distinct phases. Rushing through causes problems that waste hours troubleshooting later.

Installing ROCm Packages on Fedora

Open your terminal and start with system updates. Outdated packages cause dependency conflicts during ROCm installation.

Update your system completely:

sudo dnf update -y

Install the essential ROCm packages:

sudo dnf install rocm-hip rocm-opencl rocm-opencl-devel rocm-clinfo rocm-smi -y

These packages provide the ROCm HIP runtime, OpenCL support for compatibility, development headers, GPU information tools, and system management utilities. The installation takes 5-10 minutes depending on your internet connection speed.

Verify ROCm installation by checking available devices:

rocm-smi

This command displays your AMD GPU information including temperature, memory usage, and clock speeds. If you see your GPU listed, ROCm installed correctly. If not, your GPU might not have proper kernel driver support.

Configuring User Permissions for GPU Access

Non-root users need specific group membership to access GPU hardware. Without this configuration, ComfyUI cannot detect your AMD GPU even with ROCm installed correctly.

Add your user to the render and video groups:

sudo usermod -a -G render,video $USER

Log out completely and log back in for group changes to take effect. A simple terminal restart doesn't work. You need a full logout and login cycle.

Verify group membership:

groups

You should see both render and video in the output list. According to official ROCm documentation, these groups grant necessary permissions for GPU resource access.

Setting Critical Environment Variables

Create a ROCm configuration file that loads automatically with every terminal session:

nano ~/.bashrc

Add these lines at the end of the file:

For RX 7000 series (RDNA 3):

export HSA_OVERRIDE_GFX_VERSION=11.0.0

export ROCM_PATH=/usr

export HIP_VISIBLE_DEVICES=0

For RX 6000 series (RDNA 2), use this instead:

export HSA_OVERRIDE_GFX_VERSION=10.3.0

export ROCM_PATH=/usr

export HIP_VISIBLE_DEVICES=0

Save the file and reload your shell configuration:

source ~/.bashrc

The HSA_OVERRIDE_GFX_VERSION tells ROCm which architecture optimizations to use. ROCM_PATH points to the installation directory. HIP_VISIBLE_DEVICES selects which GPU to use if you have multiple cards installed.

What's the Process for Installing PyTorch with ROCm Support?

PyTorch serves as the foundation for ComfyUI and most AI image generation tools. Installing the correct PyTorch version with proper ROCm support is critical for performance.

Creating a Python Virtual Environment

Virtual environments isolate Python packages and prevent system-wide conflicts. This isolation proves essential for AI tools with specific dependency requirements.

Install Python development tools:

sudo dnf install python3-devel python3-virtualenv git -y

Create a dedicated directory for ComfyUI:

mkdir -p ~/AI/ComfyUI

cd ~/AI/ComfyUI

Create and activate a virtual environment:

python3 -m venv venv

source venv/bin/activate

Your terminal prompt changes to show (venv) indicating the virtual environment is active. All subsequent Python package installations go into this isolated environment rather than system-wide locations.

Installing PyTorch with ROCm 6 Support

According to the PyTorch official installation guide, the latest stable PyTorch version supports ROCm 6.2 and newer.

Install PyTorch with ROCm support:

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

This installation takes 10-15 minutes as it downloads approximately 3GB of packages. The index-url parameter tells pip to use the ROCm-specific PyTorch builds rather than CPU-only versions.

Verify PyTorch recognizes your AMD GPU:

python3 -c "import torch; print(f'GPU Available: {torch.cuda.is_available()}'); print(f'GPU Name: {torch.cuda.get_device_name(0)}')"

Expected output shows:

GPU Available: True

GPU Name: AMD Radeon RX 7900 XTX

If GPU Available shows False, your environment variables might be incorrect or the ROCm installation has problems. Double-check the HSA_OVERRIDE_GFX_VERSION value matches your GPU architecture. While troubleshooting can be complex, platforms like Apatero.com eliminate these configuration challenges entirely by providing pre-configured environments.

Understanding ROCm Version Compatibility

PyTorch ROCm wheels target specific ROCm versions. Using mismatched versions causes performance problems or GPU detection failures.

PyTorch and ROCm Version Compatibility:

Always use the newest stable combination unless specific compatibility issues require older versions. Newer releases include performance optimizations and bug fixes that improve ComfyUI performance.

How Do You Install and Configure ComfyUI?

With ROCm and PyTorch working correctly, installing ComfyUI becomes straightforward. The process requires attention to dependency management.

Cloning and Setting Up ComfyUI

Ensure your virtual environment remains active (venv) shows in your terminal prompt. If not, run:

source ~/AI/ComfyUI/venv/bin/activate

Clone the ComfyUI repository:

git clone https://github.com/comfyanonymous/ComfyUI.git

cd ComfyUI

Review the requirements file before installation:

cat requirements.txt

The default requirements.txt includes torch, torchvision, and torchaudio entries. Since you installed these packages with ROCm support already, you need to modify the file to prevent reinstalling CPU-only versions.

Edit requirements.txt:

nano requirements.txt

Comment out or remove these lines by adding a hash at the beginning:

# torch

# torchvision

# torchaudio

Save the file. This prevents pip from overwriting your ROCm-enabled PyTorch installation with CPU-only versions.

Install remaining dependencies:

pip install -r requirements.txt

The installation takes 5-10 minutes and includes packages for image processing, workflow management, and various utility functions.

Downloading Essential Model Files

ComfyUI requires checkpoint models to generate images. Without models, the interface loads but cannot create anything.

Create the models directory structure:

mkdir -p models/checkpoints

mkdir -p models/vae

mkdir -p models/clip

Download a starter model like Stable Diffusion 1.5 or SDXL. Visit Hugging Face or Civitai to find models. Place checkpoint files in the models/checkpoints directory.

For example, downloading SD 1.5:

cd models/checkpoints

wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors

This model serves as a good starting point for testing. Later you can add more advanced models like SDXL, Flux, or specialized fine-tunes. For Flux-specific workflows, check the complete Flux LoRA training guide.

Starting ComfyUI with AMD GPU Acceleration

Return to the ComfyUI main directory:

cd ~/AI/ComfyUI/ComfyUI

Launch ComfyUI with AMD GPU support:

python main.py --listen

The --listen flag allows access from other devices on your network. For local-only access, omit this flag.

ComfyUI starts and displays startup messages. Watch for these indicators of successful AMD GPU detection:

Total VRAM: 24576 MB

Device: AMD Radeon RX 7900 XTX

Open your web browser and navigate to:

http://localhost:8188

The ComfyUI interface loads with the default workflow. Load your checkpoint model from the interface and generate a test image to verify everything works correctly.

Optimizing ComfyUI Launch Configuration

Create a launch script for convenient startup with optimized settings:

nano ~/AI/ComfyUI/launch_comfyui.sh

Add this content:

#!/bin/bash

source ~/AI/ComfyUI/venv/bin/activate

cd ~/AI/ComfyUI/ComfyUI

export HSA_OVERRIDE_GFX_VERSION=11.0.0

python main.py --listen --preview-method auto --highvram

Make the script executable:

chmod +x ~/AI/ComfyUI/launch_comfyui.sh

Now start ComfyUI anytime by running:

~/AI/ComfyUI/launch_comfyui.sh

The --highvram flag optimizes memory management for GPUs with 16GB+ VRAM. For cards with less memory, replace with --normalvram or --lowvram flags. Consider that Apatero.com handles all these optimization decisions automatically, providing optimal performance without manual configuration.

What Are Common AMD GPU Issues and Solutions?

Even with careful installation, AMD GPU setups encounter specific problems. Understanding these issues and solutions saves hours of frustration.

GPU Not Detected Issues

Problem: ComfyUI shows CPU-only mode despite ROCm installation.

Diagnosis: Run this test:

python3 -c "import torch; print(torch.cuda.is_available())"

If this returns False, PyTorch cannot see your GPU.

Solutions:

1. Verify HSA_OVERRIDE_GFX_VERSION matches your GPU architecture
2. Check user group membership with groups command
3. Ensure you logged out and back in after adding groups
4. Confirm ROCm packages installed with rpm -qa | grep rocm
5. Try running with explicit environment variables:

HSA_OVERRIDE_GFX_VERSION=11.0.0 python main.py

Out of Memory Errors

Problem: ComfyUI crashes with CUDA out of memory errors during generation.

Diagnosis: Monitor GPU memory usage:

watch -n 1 rocm-smi

This shows real-time VRAM usage as you generate images.

Solutions:

1. Reduce batch size in your workflow to 1
2. Use --normalvram or --lowvram launch flags
3. Lower image resolution for initial testing
4. Enable attention slicing in ComfyUI settings
5. Close other GPU-using applications
6. Consider quantized models that use less VRAM

For high-VRAM workflows like video generation with Wan 2.2, memory management becomes critical.

Slow Performance Compared to Expected

Problem: Generation takes significantly longer than benchmarks suggest.

Diagnosis: Check if GPU actually processes the workload:

Run generation and watch GPU utilization:

rocm-smi --showuse

GPU utilization should stay at 90-100% during generation. Low utilization indicates configuration problems.

Solutions:

1. Verify you're not using CPU fallback mode
2. Check that torch.version.hip exists:

python3 -c "import torch; print(torch.version.hip)"

Should show ROCm version like 6.2.0

3. Ensure proper PyTorch installation with ROCm index
4. Update to latest ROCm packages with sudo dnf update
5. Try different sampling methods (some optimize better for AMD)

Black Image or Artifact Generation

Problem: ComfyUI generates black images or severe artifacts.

Diagnosis: This often indicates precision or compute mode issues.

Solutions:

1. Add --force-fp16 launch flag for mixed precision
2. Try --disable-xformers flag to use standard attention
3. Test with different checkpoint models
4. Verify model file integrity (re-download if needed)
5. Check for model-specific VAE requirements

Some models expect specific VAE files. Missing VAE causes black outputs.

ROCm Version Conflicts

Problem: Error messages about incompatible ROCm library versions.

Diagnosis: Multiple ROCm versions installed or incomplete updates.

Solutions:

1. Remove all ROCm packages:

sudo dnf remove rocm-*

2. Clean package cache:

sudo dnf clean all

3. Reinstall ROCm packages:

sudo dnf install rocm-hip rocm-opencl -y

4. Recreate virtual environment with fresh PyTorch installation

What Performance Can You Expect from AMD GPUs?

Understanding realistic performance expectations helps you optimize your setup and evaluate if everything works correctly.

RX 7000 Series Benchmarks

Based on community testing and real-world usage, here are typical ComfyUI performance metrics:

RX 7900 XTX (24GB VRAM):

RX 7900 XT (20GB VRAM):

Performance typically 10-15% slower than XTX due to reduced compute units and memory bandwidth. Still excellent for professional work.

RX 7800 XT (16GB VRAM):

Handles SD 1.5 and SDXL comfortably. Flux Dev works but requires optimization. Performance roughly 60-70% of RX 7900 XTX.

RX 6000 Series Benchmarks

RX 6900 XT (16GB VRAM):

RX 6800 XT (16GB VRAM):

Performance similar to 6900 XT with 5-10% slower speeds. Excellent value for money.

RX 6700 XT (12GB VRAM):

Works well for SD 1.5 and SDXL. Flux requires careful VRAM management. Consider quantized models for complex workflows.

These benchmarks assume proper ROCm configuration and optimized launch flags. Significantly slower performance indicates configuration issues needing troubleshooting. For comparison, Apatero.com delivers consistent performance regardless of local hardware limitations.

Linux vs Windows Performance Comparison

Linux typically delivers 15-25% better performance than Windows for AMD GPU AI workloads. The advantage comes from better ROCm optimization, lower driver overhead, and more efficient memory management.

Performance Advantages:

• Lower system overhead frees more VRAM for generation
• Better memory allocation reduces generation failures
• Native ROCm support vs unofficial Windows DirectML
• Faster model loading and checkpoint switching
• More stable long-running generation sessions

If you dual-boot, running identical ComfyUI workflows on Linux shows measurable performance improvements over Windows installations.

Frequently Asked Questions

Which Fedora version do I need for AMD GPU ComfyUI installation?

You need Fedora 40 or newer for proper ROCm 6 support. Earlier versions lack the necessary packages in official repositories. Fedora 41 and newer work perfectly with the installation steps in this guide. Check your version with the cat /etc/fedora-release command before starting.

Can I use older AMD GPUs like RX 5000 series or Vega cards?

RX 5000 series (RDNA 1) and Vega architectures work but require different HSA_OVERRIDE_GFX_VERSION values and may have limited support. RX 5700 XT needs 9.0.0 override. Vega 64 needs 9.0.6. Performance lags significantly behind RDNA 2 and 3 architectures. For older cards, expect generation times 2-3x slower than modern GPUs.

Do I need to install AMDGPU driver separately on Fedora?

No, Fedora includes AMDGPU drivers in the kernel automatically. Unlike Ubuntu where separate driver installation is necessary, Fedora handles this through the standard kernel packages. Simply install ROCm runtime packages and configure environment variables as shown in this guide.

Why does PyTorch installation take so long?

PyTorch with ROCm support downloads approximately 3GB of packages including the full PyTorch library, ROCm-compiled extensions, and GPU-optimized libraries. On typical broadband connections this takes 10-15 minutes. The installation then compiles some components which adds another 5 minutes. Total time of 15-20 minutes is normal.

Can I run multiple AI tools besides ComfyUI on the same installation?

Yes, your ROCm and PyTorch installation supports any PyTorch-based AI tool including Automatic1111, InvokeAI, Fooocus, and others. Create separate virtual environments for each tool to prevent dependency conflicts. The system-wide ROCm installation serves all tools while isolated Python environments keep packages organized.

How do I update ComfyUI and custom nodes without breaking AMD GPU support?

Update ComfyUI with git pull in the ComfyUI directory. Update custom nodes through ComfyUI Manager. Never reinstall PyTorch unless specifically needed. If custom node installation attempts to reinstall torch, edit its requirements.txt to comment out torch dependencies before running pip install, just like you did for ComfyUI initially.

What happens if I upgrade Fedora to a new version?

Fedora upgrades typically maintain ROCm packages correctly. Before upgrading, document your HSA_OVERRIDE_GFX_VERSION value and backup your virtual environment. After upgrading, verify ROCm packages with rpm -qa | grep rocm and test PyTorch GPU detection. Occasionally you may need to reinstall ROCm packages after major Fedora version upgrades.

Should I use Docker containers for ComfyUI on Fedora with AMD GPU?

Docker adds complexity for AMD GPU passthrough on Linux. Direct installation as shown in this guide provides better performance and easier troubleshooting. Docker makes sense for production deployments or when running multiple isolated instances, but for desktop use, native installation works better. AMD GPU Docker support lags behind NVIDIA's container toolkit maturity.

How much VRAM do I really need for different AI models?

SD 1.5 runs comfortably on 6GB VRAM. SDXL needs 10-12GB for reliable operation. Flux Dev requires 16GB minimum, 20GB+ recommended. Video generation with Wan 2 needs 20GB+. If your GPU has insufficient VRAM, quantized models and optimization flags help, but severely limited VRAM causes frustrating constraints. 16GB represents the sweet spot for modern AI work.

Can I use AMD CPU and AMD GPU together for AI generation?

ComfyUI uses either CPU or GPU, not both simultaneously for generation. Your AMD CPU handles system tasks, workflow management, and preprocessing, while the GPU performs actual image generation. High-end Ryzen processors help with model loading and batch processing, but generation speed depends entirely on GPU performance once workflows start running.

Next Steps and Advanced Configuration

You now have ComfyUI running on Fedora with full AMD GPU acceleration. This foundation supports endless creative possibilities and advanced workflows.

Start experimenting with different checkpoint models to find styles you enjoy. Explore custom nodes through ComfyUI Manager to extend functionality. Learn workflow techniques that leverage your AMD GPU's capabilities effectively. Master regional prompting techniques for complex compositions.

Consider training custom LoRAs for personalized styles using your local hardware. Your ROCm setup supports training workflows as well as generation. Fedora's stable environment makes it ideal for long training sessions that would be problematic on Windows.

For users who want immediate results without the installation complexity, platforms like Apatero.com offer professionally configured environments with instant access to the latest models and optimizations. But understanding the local installation process provides valuable knowledge about how AI generation tools actually work at the system level.

Remember that the AI image generation landscape evolves rapidly. New models, updated ROCm versions, and improved PyTorch releases bring regular performance improvements. Stay active in ComfyUI and AMD GPU communities to learn about optimization techniques and troubleshooting approaches as the ecosystem develops.

Your Fedora installation with AMD GPU support now matches or exceeds Windows performance while providing greater control over your AI generation environment. The initial setup investment pays dividends through consistent performance and expandability as you explore more advanced ComfyUI workflows and techniques.