How Much VRAM Do You Need for ComfyUI in 2026? I Tested a 16 GB RTX 5080

Short answer: for ComfyUI in 2026, 8 GB of VRAM is the floor, 12 GB is fine for FP8 image models, and 16 GB is the sweet spot for current image models and quantized 14B video models. 24 to 32 GB is for big video models without compromises. But the label on the box is not the number that matters. What matters is whether the model’s weights fit in the VRAM budget ComfyUI actually gets on your PC. I measured this on my RTX 5080 16 GB today: Z-Image Turbo FP8 made a 1024×1024 image in 16.6 seconds. Krea 2 Turbo FP8 missed my budget by just 1.64 GB, and the same size of image took 26 minutes 21 seconds.

How Much VRAM Do You Need for ComfyUI? (Quick Tiers)

ComfyUI itself barely uses any VRAM. The models you load into it do. This is how I’d size a card today, based on the model file sizes in the official Hugging Face repos (see the file size table) and on what I measured on my own card:

VRAM	What runs well	What needs workarounds
8 GB	SD 1.5, SDXL, small turbo models in FP8 or GGUF	Every 2026 flagship model: you’ll be choosing low-bit GGUF files and offloading text encoders all the time
12 GB	FP8 image models with weights up to about 8 GB (Z-Image Turbo FP8, SDXL with ControlNet)	12 to 13 GB FP8 files such as Krea 2 Turbo FP8, all 14B video models
16 GB	Most image models as FP8/INT8 files of about 11 GB or less, plus short video with quantized 14B models	19 GB FP8 files (Qwen-Image 2512), BF16 9B models, long or 720p+ video
24 GB	Almost every image model in FP8, Wan 2.2 14B FP8 at 480p to 640p	BF16 video models, long clips
32 GB	Big image and video models with far fewer compromises	Full-precision 20B+ video models, training

The table is a guide, not a promise. Two people with the same card can get very different results, because the budget ComfyUI gets depends on what else is using the GPU and on your launch flags. That is exactly what my test shows.

What Actually Uses VRAM in a ComfyUI Workflow?

A typical text-to-image graph loads four things, and ComfyUI doesn’t keep them all in VRAM at once. My console log showed the order clearly for a Z-Image Turbo run:

1. Text encoder (the LLM that reads your prompt): ZImageTEModel_ ... loaded completely; 7672.25 MB loaded. Encoding finishes, then it’s moved back to system RAM.
2. Diffusion model (the part that does the steps): Lumina2 ... loaded completely; 5870.77 MB loaded, full load: True.
3. Activations and latents: working memory for each step. This grows with resolution, batch size and, for video, frame count.
4. VAE (turns latents into pixels): only 160 MB of weights here, but decoding a big image needs a lot of working memory.

Two things surprised me. First, for Z-Image Turbo the text encoder (7.67 GB) is bigger than the diffusion model (5.87 GB), so at 1024×1024 the encoding step, not sampling, set the peak. Second, the slowdown only happens when the diffusion model doesn’t fit, because it’s used on every step. A text encoder that spills runs once per prompt, so it costs a few seconds, not minutes.

My RTX 5080 16 GB Test Results

I ran these tests on October 26, 2026 on my own PC through ComfyUI’s API, sampling nvidia-smi every 0.4 seconds and timing each job from ComfyUI’s own execution timestamps. Same prompt for every image (a rainy-night Tokyo ramen stall), 8 steps, CFG 1, official template samplers.

Test	Weights on GPU	Sampling speed	Total time	Peak extra VRAM
Z-Image Turbo FP8, 1024×1024 (first run)	5.87 GB, fully loaded	1.73 it/s	33.2 s	7.6 GB
Z-Image Turbo FP8, 1024×1024 (second run)	5.87 GB, fully loaded	1.75 it/s	16.6 s	7.6 GB
Z-Image Turbo FP8, 1024×1024, batch of 4	5.87 GB, fully loaded	5.7 s/it	63.1 s (15.8 s per image)	8.2 GB
Z-Image Turbo FP8, 1536×1536	5.87 GB, fully loaded	4.96 s/it	55.8 s	7.6 GB
Z-Image Turbo FP8, 2048×2048	5.87 GB, fully loaded	10.4 s/it	100.8 s	10.7 GB
Krea 2 Turbo FP8, 1024×1024	10.89 GB loaded + 1.64 GB offloaded	about 192 s/it	26 min 21 s	card full (15.8 to 15.9 GB of 16.3 GB in use)

“Peak extra VRAM” is the highest total GPU memory reading during the job minus the reading just before it, so it includes the CUDA cache, not only the model. The first Z-Image run was slower because the model files were read from disk. Later runs came from the Windows file cache.

Test Setup

• GPU: NVIDIA GeForce RTX 5080 16 GB (driver 610.88). My PC has two 5080s, and these tests ran on the second one.
• CPU / RAM: Intel Core i7-14700K, 128 GB system RAM, Windows 11.
• Software: ComfyUI 0.38.1 portable, PyTorch 2.11.0 with CUDA 13.0.
• Important caveat: this card isn’t dedicated to ComfyUI. My Voicebox voice server and a background-removal service also use it, and this ComfyUI instance runs with --reserve-vram 3.0, --disable-smart-memory, --disable-dynamic-vram and --disable-async-offload so it plays nicely with them. That’s why ComfyUI logged 10,997 MB usable on a 16 GB card. A clean 16 GB card running stock ComfyUI gets a bigger budget. Many real PCs look more like mine, though: a browser, Discord, a game launcher or a second AI app all take a slice.

Why Did Krea 2 Take 26 Minutes?

The Krea 2 Turbo FP8 diffusion file is 13.14 GB (12.24 GB as Windows counts it) on Comfy-Org’s Hugging Face repo. ComfyUI loaded 10.89 GB of it and kept 1.64 GB in system RAM (loaded partially; 10996.67 MB usable, 10888.67 MB loaded, 1642.05 MB offloaded). After that the GPU showed 100% utilization, total memory stayed pinned at about 15.9 GB of 16.3 GB, and each of the 8 steps took around 192 seconds. Z-Image took 0.57 seconds per step. That’s a slowdown of more than 300x from a 1.64 GB overflow.

Moving 1.64 GB over PCIe 5.0 shouldn’t take minutes, so the transfer alone doesn’t explain it. My best explanation: with the card completely full, the Windows driver started using shared system memory. NVIDIA’s own support article says that since driver 536.40 the driver switches to shared memory “when running close to maxing out GPU memory”, so apps keep running “albeit at lower speeds”. On top of that, this ComfyUI instance has dynamic VRAM and async weight offloading turned off. Current ComfyUI normally has both on, and they exist to make partial offload smoother. I haven’t proven which factor hurt most, so treat this as a likely cause, not a measured one.

The practical lesson is the same either way: a model that almost fits is often as bad as one that doesn’t fit at all. Pick a file that fully fits, or remove other VRAM users first.

How Do Resolution and Batch Size Change VRAM?

• Resolution hits speed before VRAM. 1536×1536 has 2.25x the pixels of 1024×1024 and was 8.6x slower per step (4.96 s vs 0.57 s). Peak VRAM didn’t move, because the text encoder still set the peak.
• 2048×2048 is where VRAM starts to bite. Peak extra VRAM rose to 10.7 GB, and the VAE decode found no free room: the log said loaded partially; 0.00 MB usable ... 159.87 MB offloaded. It still finished in 101 s, because only the small VAE spilled, not the diffusion model.
• Batching is cheap on VRAM. A batch of 4 at 1024×1024 added only about 0.6 GB over a single image and worked out to 15.8 s per image, the same as single runs.

One honest note: when I re-ran the 1024×1024 Z-Image test at the end, it took 33.8 s at 2.44 s/it. Another app was clearly using the GPU at the same time. On a shared GPU your timings will move around too.

Will Popular 2026 Models Fit in 16 GB?

A fast way to check before you download anything: compare the diffusion model file size with the budget ComfyUI gets. These are the actual file sizes of the official ComfyUI repacks I have on disk (Windows GB):

Model file	Diffusion model	Text encoder	Fully fits a ~11 GB budget?
Z-Image Turbo FP8 (z-image-turbo_fp8_scaled_e4m3fn_KJ)	5.74 GB	7.49 GB (qwen_3_4b)	Yes (tested)
Krea 2 Turbo FP8 (krea2_turbo_fp8_scaled)	12.24 GB	4.88 GB (qwen3vl_4b_fp8)	No, short by 1.64 GB (tested)
Wan 2.2 T2V 14B FP8 (high + low noise)	13.31 GB each	6.27 GB (umt5_xxl_fp8)	No, needs offload or GGUF
FLUX.2 Klein 9B (flux-2-klein-9b, BF16)	16.91 GB	15.26 GB (qwen_3_8b)	No
Qwen-Image 2512 FP8 (qwen_image_2512_fp8_e4m3fn)	19.03 GB	8.74 GB (qwen_2.5_vl_7b_fp8)	No

Only the first two rows were tested here. The others are file size arithmetic, and for those models you’ll want a quantized file (INT8, NVFP4 or GGUF) on a 16 GB card. For video, ComfyUI’s own Wan 2.2 14B template includes a note that the FP8 model plus the 4-step LoRA used 89% of VRAM on an RTX 4090D 24 GB at 640×640, so 24 GB is the comfortable tier there. If you’re already fighting out-of-memory errors on video, my MiniMax H3 out-of-memory fixes for 16 GB GPUs go through the video-specific tricks, and my list of the best local AI video models covers which ones are realistic at home.

How Do I Check How Much VRAM ComfyUI Really Gets?

1. Read the console. Every model load prints a line like loaded completely; 10996.67 MB usable, 5870.77 MB loaded, full load: True. “full load: True” is what you want for the diffusion model. “loaded partially … MB offloaded” is your warning.
2. Check idle usage first. Run nvidia-smi before you queue anything. Whatever is already in use (browser, overlays, other AI apps) comes out of your budget.
3. Watch Task Manager. In Performance > GPU, if “Shared GPU memory” climbs while dedicated memory is full, you’ve hit the slow path.
4. Time one step. The progress bar shows it/s or s/it. If a model that should do about 1 it/s shows tens of seconds per step, it isn’t fitting.

How Do I Make a Model Fit in 16 GB or Less?

• Pick the right file first. FP8, INT8 or GGUF versions of the same model are the biggest win. For example, my Qwen-Image 2.1 Turbo 16 GB workflow uses a 7.26 GB INT8 file instead of the full-size one. For 8 GB cards, see my FLUX 3 Image Klein 8 GB settings.
• Close other GPU apps. Each GB they hold is a GB your model can’t use. In my case 1.64 GB made the difference between 16 seconds and 26 minutes.
• Don’t over-reserve. --reserve-vram “reserves” VRAM for your OS and other software (from ComfyUI’s own cli_args.py). Only use it if you share the GPU, and keep it small.
• Keep the defaults unless you need them off. Current ComfyUI enables async weight offload by default on NVIDIA cards and uses dynamic VRAM on supported systems. Flags like --disable-dynamic-vram, --disable-async-offload and --disable-smart-memory trade speed for predictability.
• Consider “Prefer No Sysmem Fallback”. In NVIDIA Control Panel > Manage 3D Settings > Program Settings, add ComfyUI’s python.exe and set CUDA – Sysmem Fallback Policy to Prefer No Sysmem Fallback. NVIDIA says this keeps performance stable “at the risk of a crash”, so you’ll get an out-of-memory error instead of a silent crawl. I didn’t change it on my shared GPU for this test.
• Move the text encoder to the CPU. The core CLIPLoader node has a device option (default or cpu). That frees VRAM at the cost of slower prompt encoding.
• Use tiled VAE decode for big images or video. The core VAEDecodeTiled node decodes in tiles (512 px by default) and, for video, in chunks of frames.
• Lower the resolution or frame count first, not the steps. Turbo models are already at 4 to 8 steps.

Which GPU Should You Buy for ComfyUI in 2026?

For local AI, VRAM capacity matters more than any other spec. This is the current GeForce RTX 50 line-up from NVIDIA’s official comparison page (checked October 26, 2026):

GPU	VRAM	Memory bandwidth	AI TOPS	My take for ComfyUI
RTX 5090	32 GB GDDR7	1,792 GB/s	3,352	The only GeForce with more than 16 GB. Buy it for serious video work.
RTX 5080	16 GB GDDR7	960 GB/s	1,801	Fast 16 GB card (my test card). Same VRAM as the 5070 Ti.
RTX 5070 Ti	16 GB GDDR7	896 GB/s	1,406	The best value 16 GB card if VRAM is your limit.
RTX 5070	12 GB GDDR7	672 GB/s	988	OK for FP8 image models. Tight for new releases.
RTX 5060 Ti	16 GB or 8 GB GDDR7	448 GB/s	759	Only buy the 16 GB version. Slower, but it fits the same models.
RTX 5060 / 5050	8 GB	448 / 320 GB/s	614 / 421	Not recommended for ComfyUI in 2026.

Two notes. A slower 16 GB card beats a faster 12 GB card as soon as the model doesn’t fit on the 12 GB card, because the offload penalty is far bigger than the speed gap. And the rumored RTX 50 Super cards with 18 to 24 GB haven’t been announced by NVIDIA. Tom’s Hardware reports they’re on hold because of 3 GB GDDR7 memory costs, so I wouldn’t wait for them if you need a card now. I haven’t listed prices because they change too much from week to week and country to country. Check current prices before you buy.

How Much System RAM Does ComfyUI Need?

When VRAM is full, offloaded weights and idle models sit in system RAM. During my Z-Image tests the ComfyUI process grew from about 3.1 GB to between 16.7 and 18.2 GB of RAM. That’s for a small image model. My recommendation is 32 GB as a minimum and 64 GB if you run 14B video models or chain several models in one workflow. If RAM runs out, Windows starts paging to disk and everything slows down. Put models on an NVMe SSD too: my first, cold-cache Z-Image run took 33.2 s against 16.6 s once the files were cached.

Download the ComfyUI VRAM Test Workflows

The zip contains the exact two graphs I timed, so you can run the same test on your card and compare:

• 01_Z-Image-Turbo_FP8.json and 01_Z-Image-Turbo_FP8_API.json: 1024×1024, 8 steps, res_multistep, CFG 1, AuraFlow shift 3
• 02_Krea-2-Turbo_FP8.json and 02_Krea-2-Turbo_FP8_API.json: 1024×1024, 8 steps, euler/simple, CFG 1 (official template settings)
• README.txt: every model file, where it goes, its Hugging Face link, and my numbers

Core nodes only, no custom nodes. Before publishing I validated both UI files with a script: valid JSON, every link pointing at existing nodes and slots with matching types, every node type checked against a live ComfyUI 0.38.1 node list, and each UI graph converted back to API format to confirm it matches the graph I actually ran. To test other sizes, change width, height and batch_size on the EmptySD3LatentImage node.

Download ComfyUI VRAM Test Workflows (.zip)

Requirements: a recent ComfyUI (I used 0.38.1) with Krea 2 support, and the model files from Kijai/Z-Image_comfy_fp8_scaled, Comfy-Org/z_image_turbo (text encoder and VAE) and Comfy-Org/Krea-2. Model weights aren’t included.

FAQ

Is 8 GB VRAM enough for ComfyUI?

It’s enough to learn on with SD 1.5, SDXL and small turbo models in FP8 or GGUF. For 2026 models you’ll need low-bit quantized files and CPU offload all the time, so I don’t recommend buying an 8 GB card for ComfyUI today.

Is 16 GB VRAM enough for ComfyUI?

Yes, for most image models in FP8 or INT8 and for short, quantized 14B video. Make sure the diffusion model file actually fits in your free VRAM. On my 16 GB card, Z-Image Turbo FP8 fit and made a 1024×1024 image in 16.6 s, while Krea 2 Turbo FP8 overflowed by 1.64 GB and took 26 minutes.

Why is ComfyUI suddenly extremely slow on my GPU?

Usually because the model only partly fits. Look for “loaded partially … MB offloaded” in the console, and for rising “Shared GPU memory” in Task Manager. Close other GPU apps, use a smaller quantized file, or set NVIDIA’s CUDA Sysmem Fallback Policy to “Prefer No Sysmem Fallback” so you get an error instead of a crawl.

Does the text encoder need to fit in VRAM too?

It’s loaded on its own, before sampling. In my Z-Image test it was the largest single load (7.67 GB), but it only runs once per prompt, so offloading it or running it on the CPU costs seconds, not minutes.

Is 12 GB VRAM enough for AI video in ComfyUI?

For small video models and GGUF versions of bigger ones, yes, with patience. 14B FP8 video models have diffusion files of 13.31 GB each, larger than the whole card, so plan on heavy offloading or a 16 to 24 GB GPU.

Is the RTX 5080 good for ComfyUI?

It’s fast when the model fits (0.57 s per step for Z-Image Turbo at 1024×1024 in my test), but it has the same 16 GB as the cheaper RTX 5070 Ti. If you mainly care about which models fit, the 5070 Ti gives you the same capacity. Only the RTX 5090 goes beyond 16 GB.

Sources

• NVIDIA: Compare GeForce graphics cards (RTX 50 Series specs)
• NVIDIA Support: System Memory Fallback for Stable Diffusion
• ComfyUI source: cli_args.py (VRAM flags)
• Comfy-Org workflow templates (Wan 2.2 14B template VRAM note)
• Comfy-Org/Krea-2 on Hugging Face, Kijai/Z-Image_comfy_fp8_scaled, Comfy-Org/Qwen-Image_ComfyUI, Comfy-Org/Wan_2.2_ComfyUI_Repackaged, black-forest-labs/FLUX.2-klein-9B
• Tom’s Hardware: RTX 50 Super reportedly on hold over GDDR7 pricing
• My own measurements on an RTX 5080 16 GB, October 26, 2026 (ComfyUI console log and nvidia-smi sampling)