ComfyUI on RTX 50 Series (2026): Correct PyTorch, CUDA, Driver and Speed Settings for RTX 5090, 5080 and 5070

When the RTX 50 series launched, getting ComfyUI on an RTX 5090 or 5080 working meant nightly PyTorch builds and “no kernel image is available” errors. In November 2026 that is mostly history: the official portable build ships with a CUDA 13.0 PyTorch that supports Blackwell out of the box. But there are still several ways to end up with a slow or broken setup, such as an old driver, a custom node that quietly downgrades PyTorch, xformers, or using the wrong model format and missing the 4-bit speed boost that only RTX 50 cards have. I run ComfyUI on two RTX 5080 cards, so this guide is the checklist I use: the correct versions, how to check them, which model formats to download, and the settings that actually make Blackwell fast.

Why RTX 50 Cards Needed a Special Setup

RTX 50 cards use NVIDIA’s Blackwell architecture, which has the compute capability sm_120. Code compiled only for older GPUs (up to sm_89 for RTX 40) contains no kernels for it, and that is where the famous message comes from:

CUDA error: no kernel image is available for execution on the device

PyTorch needs to be built with CUDA 12.8 or newer to include sm_120 kernels. The pinned “Nvidia 50 Series (Blackwell) support thread” on the ComfyUI GitHub said exactly this in January 2025: the 50 series needs a PyTorch built against CUDA 12.8. For months that meant nightly builds. Since then stable PyTorch has caught up, PyPI CUDA wheels moved to CUDA 13.0 as the default from PyTorch 2.11, and ComfyUI’s own requirements now say a cu130 build is required for NVIDIA 20 series and newer.

The Correct Versions in November 2026

The ComfyUI docs state that “the Windows portable build currently comes with Python 3.13 and PyTorch CUDA 13.0”. So if you download the current portable package, the right versions are already there. The rest of this guide is about keeping them that way and getting the most out of the card.

RTX 50 Cards and What They Can Run

VRAM decides what fits far more than the GPU generation. Here is a rough guide for the desktop RTX 50 cards, using the model formats explained later:

For measured numbers on a 16 GB card, see my ComfyUI VRAM test on an RTX 5080.

Install ComfyUI for RTX 50 (Portable, Desktop, Manual)

Option 1: Windows portable (recommended)

1. Update your NVIDIA driver first. For a clean start after many driver changes, remove the old one with DDU (Display Driver Uninstaller) in safe mode, then install the new one.
2. Download the latest portable package for NVIDIA from the ComfyUI GitHub (Releases, “portable” .7z for NVIDIA).
3. Extract it to a short path on a fast SSD, for example C:\AI\ComfyUI_windows_portable\. Long paths and OneDrive folders cause trouble.
4. Run run_nvidia_gpu.bat. The first start takes a little longer.

Do not copy an old python_embeded folder over a new one. If you are moving from an old install, copy only ComfyUI\models\, ComfyUI\user\ (your workflows and settings) and the custom nodes you still use, then reinstall those nodes’ requirements. My guide to saving and backing up workflows shows what is inside user\default\.

Option 2: ComfyUI Desktop

The Desktop app sets up its own Python environment with a CUDA build of PyTorch during installation. Pick NVIDIA when it asks for your GPU, choose a base folder on a fast drive, and let it finish. It is the easiest way for beginners, but you have less control over versions.

Option 3: Manual install (git clone + venv)

git clone https://github.com/Comfy-Org/ComfyUI
cd ComfyUI
py -3.13 -m venv venv
.\venv\Scripts\activate
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txt
python main.py

That PyTorch command is the one the ComfyUI system requirements page gives for NVIDIA. Install PyTorch before requirements.txt, so pip does not grab a CPU-only build. On Linux, use python3.13 -m venv venv and source venv/bin/activate; the rest is the same.

Check That Your GPU Is Used Properly

Run this with the same Python ComfyUI uses (.\python_embeded\python.exe for portable, or the activated venv):

python -c "import torch; print(torch.__version__, torch.version.cuda); print(torch.cuda.is_available(), torch.cuda.get_device_name(0), torch.cuda.get_device_capability(0)); print(torch.cuda.get_arch_list())"

A healthy RTX 50 setup shows:

• A version ending in +cu130 (or +cu128), not +cpu.
• True and your card’s name.
• Capability (12, 0).
• sm_120 in the arch list.

When ComfyUI starts, the console also prints the device, the total VRAM and the attention method in use (for example Using pytorch attention). If you see Device: cpu, ComfyUI cannot use your GPU and everything will be extremely slow.

The Two Traps: xformers and Custom Nodes That Downgrade PyTorch

Trap 1: xformers

Older guides tell you to install xformers. On RTX 50 you should not. Prebuilt xformers wheels lagged behind Blackwell for a long time, and installing xformers can make pip remove your PyTorch and install a different build to match it, which can take sm_120 support with it. ComfyUI uses PyTorch’s built-in attention by default, and SageAttention or Comfy Kitchen are faster options when you want more. If xformers is already installed and causing trouble, uninstall it and start ComfyUI with --disable-xformers.

Trap 2: A custom node replaces PyTorch

Some custom nodes list torch (sometimes with an exact version) in their requirements.txt. When the Manager installs them, pip may swap your cu130 PyTorch for a CPU-only or older build. The symptom is that ComfyUI suddenly runs on the CPU or shows “no kernel image” after you install a node. Several users in the official RTX 50 thread warn about exactly this.

To fix it:

1. Run the check command above to confirm the torch build changed.
2. Reinstall the right build: .\python_embeded\python.exe -m pip install --force-reinstall torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130.
3. Find the node that did it: start with --disable-all-custom-nodes, then rename suspect folders in ComfyUI\custom_nodes\ to name.disabled one at a time.
4. Remove the hard torch== pin from that node’s requirements.txt before reinstalling it, or report it to the node’s author.

The safest habit: after installing any node pack, run the one-line check again. My list of must-have ComfyUI custom nodes sticks to well-maintained packs that do not do this.

Model Formats: NVFP4 vs FP8 vs GGUF on Blackwell

This is where RTX 50 owners leave the most speed on the table. Blackwell’s 5th-generation Tensor Cores can run FP4 maths in hardware, and ComfyUI supports NVIDIA’s NVFP4 format through the comfy-kitchen library that newer ComfyUI versions use for fast FP8 and NVFP4 inference.

A published FLUX.1 Dev comparison on an RTX 5090 (CUDA 13, 2048 px), summarised by RunAIHome from Furkan Gozukara’s tests, measured:

• NVFP4: 7.73 it/s
• BF16: 4.53 it/s
• FP8 scaled: 4.21 it/s
• GGUF Q8: 3.54 it/s

So NVFP4 was about 84% faster than FP8 and more than twice as fast as GGUF Q8 in that test. A separate user test on a 16 GB RTX 5060 Ti (FLUX.1 fine-tunes, 1280×960, 28 steps) went from about 1 minute with GGUF or FP8 to 25 seconds with NVFP4. The same tester saw clear quality loss with a home-made NVFP4 Qwen-Image file, so prefer official NVFP4 releases (FLUX.2 dev and LTX-2 have them) over community conversions.

How to use NVFP4 files:

• Put them in ComfyUI/models/diffusion_models/ and load them with the core Load Diffusion Model node. No custom node is needed. Leave weight_dtype on default.
• Text encoders and VAEs stay in their normal folders, ComfyUI/models/text_encoders/ and ComfyUI/models/vae/. My model folder cheat sheet lists them all.
• NVFP4 needs the cu130 PyTorch. Without it, the speed gain largely disappears.

When no NVFP4 file exists for a model, use FP8 scaled if it fits in VRAM and GGUF with the Unet Loader (GGUF) only when it does not. For language models the trade-offs are different; see GGUF quantization explained.

Speed Settings That Work on RTX 50

Once the basics are right, add these one at a time and compare seconds per step on the same workflow:

1. Use the right model format (NVFP4 > FP8 > GGUF, as above). This is the biggest win.
2. Faster attention. Install SageAttention 2.2, whose SageAttention2++ kernels support sm_120, and enable it per workflow with the KJNodes patch node. My step-by-step SageAttention on Windows guide covers the exact wheels. If you do not want to install anything, try ComfyUI’s built-in --use-ck-attention (Comfy Kitchen INT8 attention). Several RTX 50 users found SageAttention helps a lot on long video and little on small images, so test on your own workloads.
3. --fast fp16_accumulation lets matrix multiplies accumulate in FP16 on supported cards. It is experimental and can affect quality slightly, so compare a few images.
4. Keep the model in VRAM. If a model only just fits, close the browser tabs and apps that use GPU memory (Chrome with hardware acceleration, games, OBS). On a 16 GB card a few hundred MB decides whether the model has to be partly offloaded.
5. Power and cooling. Long video jobs keep the card at full load for many minutes. Good airflow keeps clocks stable; if you have crashes under heavy VRAM load, a clean driver install and a full power cycle often fix them.

Every flag is explained in my ComfyUI command line arguments guide. A good starting line for an RTX 50 portable install is:

.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --fast fp16_accumulation

Two RTX 50 Cards: What ComfyUI Can and Cannot Do

My PC has two RTX 5080 cards, so I get asked this a lot. Core ComfyUI runs a workflow on one GPU. Two 16 GB cards do not act like one 32 GB card for a single model. What you can do:

• Run two ComfyUI instances, one per card, with different ports: --cuda-device 0 --port 8188 and --cuda-device 1 --port 8189. Two jobs run in parallel, which doubles throughput for batches.
• Put the text encoder or VAE on the second GPU with ComfyUI-MultiGPU. It adds loaders such as CLIPLoaderMultiGPU and DualCLIPLoaderMultiGPU with a device input, so a big text encoder stays loaded on cuda:1 while the diffusion model gets all of cuda:0. It installs into ComfyUI/custom_nodes/ComfyUI-MultiGPU/ (Manager name: ComfyUI-MultiGPU). For large video models this is often the difference between full GPU speed and offloading.
• Use the second card for an LLM (Ollama or llama.cpp) while ComfyUI uses the first, for prompt writing or captioning.

RTX 50 Errors and Fixes

More general errors are covered in my ComfyUI errors and fixes list.

Frequently Asked Questions

Does ComfyUI work on the RTX 5090 and 5080?

Yes. The current ComfyUI Windows portable ships with Python 3.13 and a CUDA 13.0 PyTorch that supports RTX 50 (sm_120) out of the box. Just keep your NVIDIA driver up to date.

Which PyTorch version do I need for an RTX 50 GPU?

Any PyTorch built with CUDA 12.8 or newer has Blackwell kernels. In November 2026 use the latest stable build from the cu130 index: pip install torch torchvision torchaudio –extra-index-url https://download.pytorch.org/whl/cu130.

Do I still need PyTorch nightly for RTX 50 cards?

No. Nightly builds were needed in early 2025. Stable PyTorch releases now include sm_120, and ComfyUI recommends the latest stable cu130 build.

Should I install xformers on an RTX 50 card?

No. ComfyUI uses PyTorch attention by default, and installing xformers can replace your PyTorch with an incompatible build. Use SageAttention or Comfy Kitchen attention if you want faster attention.

What is NVFP4 and is it worth it?

NVFP4 is NVIDIA’s 4-bit floating-point format that RTX 50 Tensor Cores run in hardware. In a published FLUX.1 Dev test on an RTX 5090 it ran at 7.73 it/s vs 4.21 it/s for FP8. Use official NVFP4 releases where available.

Can ComfyUI use two RTX 50 GPUs together?

Not for one model as a single big pool. You can run one ComfyUI instance per GPU with –cuda-device, or use ComfyUI-MultiGPU to put the text encoder or VAE on the second card.

Why does ComfyUI say no kernel image is available?

Your PyTorch or a custom CUDA extension was compiled without kernels for your GPU’s architecture. On RTX 50 that means a build older than CUDA 12.8. Reinstall PyTorch from the cu130 index.

Final Thoughts

In late 2026, an RTX 50 card is the easiest GPU to run ComfyUI on: use the current portable build, keep the driver new, leave xformers out, and check your torch build after every custom node install. Then spend your effort on the part that really changes speed, which is NVFP4 or FP8 model files plus better attention. From here, set up SageAttention, try the Wan 2.2 16 GB workflow or FLUX 3 Image Klein, and compare local costs with the cloud in my cloud GPU vs RTX 5080 breakdown.

Sources

• ComfyUI docs: system requirements (Python 3.13, cu130, portable build)
• ComfyUI discussion #6643: Nvidia 50 Series (Blackwell) support thread
• PyTorch: PyPI CUDA wheels move to CUDA 13.0 (release 2.11)
• PyTorch 2.14.0 general availability
• RunAIHome: ComfyUI NVFP4 on RTX 50 (FLUX.1 Dev benchmark summary)
• Catapp-Art3D: comfy-kitchen and NVFP4 conversion test on RTX 5060 Ti
• ComfyUI ‘no kernel image’ on RTX 5090 and Blackwell
• ComfyUI-MultiGPU
• ComfyUI changelog