Monthly email

ComfyUI VRAM checker: which model file fits your GPU

Pick an open image or video model and your GPU: which precision to download, what each stage needs, and what is left for generating. Exact file sizes.

Updated Free, and it runs in your browser

Model
Your GPU

The model files of ComfyUI's Wan 2.2 Text to video, A14B template: 4 files, LoRAs not counted

Will it run?

On your RTX 4090

Yes

Loads as it is.

Largest stage
14.5 GB
Your card
24.0 GB
Left for the work
9.5 GB
Download
35.6 GB

Stages: text encoders 6.7 GB · diffusion 14.5 GB. Working memory for generation comes on top and grows with resolution and frame count.

Computed 16 October 2026

Where?

Places that run it

A GPU by the hourYes

Any node and your own setup. An RTX 3090 holds it, from $0.17 an hour on SaladCloud, or $0.50 on RunPod, which runs its own data centres. It bills while it idles.

Read 19 October 2026
13 providers compared
A per-clip APIModel only

RunPod sells Wan 2.2 by the clip, $0.30 for 5 seconds at 1280×720: its model and settings, not your workflow.

Read 9 October 2026
APIs compared

For how much?

One output, at each source’s own settings

  • RunPod's APIA 5-second clip at 1280×720, on its model, not your workflow
    $0.30Read 9 October 2026

Which diffusion file fits this card

Best for this card: the FP8 scaled file, largest stage 14.5 GB.

PrecisionFileLargest stageVerdict
FP1628.58 GB28.8 GBStreams
FP8 scaled · template14.29 GB14.5 GBLoads fully

Wan says: “This command can run on a GPU with at least 80GB VRAM.” (A14B models, Wan's own script). Every Wan 2.2 file, card by card.

Every model file

FileWhat it isSizePut it inGet it
wan2.2_t2v_high_noise_14B_fp8_scaled.safetensorsDiffusion model · FP8 scaled14.29 GBdiffusion_modelsHugging Face
wan2.2_t2v_low_noise_14B_fp8_scaled.safetensorsDiffusion model14.29 GBdiffusion_modelsHugging Face
umt5_xxl_fp8_e4m3fn_scaled.safetensorsText encoder · FP8 scaled6.74 GBtext_encodersHugging Face
wan_2.1_vae.safetensorsVAE · BF160.25 GBvaeHugging Face

Apache 2.0 · Sizes: exact bytes from Hugging Face. NVIDIA cards; FP4 files only on Blackwell.

How the answer is worked out

A ComfyUI workflow runs in stages, and each stage loads only what it needs:

  • The text encoder turns your prompt into embeddings. For several current models it is a full language model of its own, sometimes larger than the image model.
  • A prompt enhancer, in some official templates, rewrites the prompt first. It is a separate model with its own stage.
  • The diffusion model samples the image or video, with the VAE alongside to decode it. Wan 2.2's A14B models are two experts that take turns, so one is on the card at a time.

The largest of those stages is what has to fit. The answer starts from the files ComfyUI's own template downloads for the model, read the way the workflow checker reads a dropped workflow: if they load on your card, it shows what is left for working memory; if not, it names the smaller file of the same model that does. Under the answer, every diffusion file of the model is judged on your card with the best text encoder that fits beside it, so you also see when a higher precision fits. File sizes are the exact byte counts Hugging Face reports for the 109 files ComfyUI loads across these models. Files in Blackwell formats (NVFP4, MXFP8) are offered only to Blackwell cards: RTX 50, RTX PRO 6000 and DGX Spark.

Beside the memory answer: whether Comfy Cloud runs the model's template, for the models whose ComfyUI template we have checked; the cheapest cloud GPU by the hour that holds it; and what one image or clip costs, where a provider prints a price or we measured one ourselves. Each figure carries the date it was read or measured.

What does not fit is not refused: ComfyUI streams weights from system RAM, according to its README. "Streams" in the checker means slower, not impossible.

Every model, one page each

Each model has a page with its full file list, a card-by-card table, what its maker says it needs, documented LoRA training settings, and its licence terms.

Or see them side by side: every image and video model compared. For language models, the LLM checker does the same job. If your card falls short, see every way to run ComfyUI in the cloud, compared by price.

Questions

How do I know which ComfyUI model file fits my GPU?
Look at the largest stage, not the sum of the files. ComfyUI loads the text encoder, runs it, and moves it out when the diffusion model needs the room, so what has to fit is the bigger of the two, plus the VAE with the diffusion model. A file loads fully when that stage stays under 85% of your card's memory, and tightly up to 95%. The checker does that for every file of every model it lists.
What happens if the model does not fit in VRAM?
ComfyUI streams the part that does not fit from system RAM instead of refusing to run. Its README says it can run even the biggest open models on as low as 4 GB of VRAM with 8 GB of RAM this way. It works and it is slower; how much slower depends on your PCIe link and the resolution, so we do not put a number on it.
Can I run Wan 2.2 on a 12 GB card?
Not fully. Even the smallest text-to-video expert, FP8 scaled, needs 14.5 GB at its largest stage, more than a 12 GB card holds, so ComfyUI streams part of it from system RAM. On a 24 GB card the FP8 scaled file loads fully.
Why not just add up the file sizes?
Because the files are not on the card at the same time, and because two of them may never be: Wan 2.2's text-to-video template downloads 35.6 GB, two experts and a text encoder, but its largest stage is 14.5 GB. Adding everything up overstates what you need; looking only at the diffusion file understates it when the text encoder is the larger one, as it is for some models here.
Does the checker estimate working memory?
No. Working memory grows with resolution, frame count and batch size, depends on the attention kernel, and no vendor publishes it per model. The checker shows what is left after the weights and quotes what each vendor says it needs, so you can see both and judge.
  • Files and sizes: Comfy-Org's repackaged repositories and the vendors' own ComfyUI-ready files on Hugging Face, exact byte counts read from the Hugging Face API on 16 October 2026. Template sets: ComfyUI's official workflow templates. A whole workflow, any model: the ComfyUI workflow checker.
  • Card memory: manufacturers' specifications. NVIDIA cards only; ComfyUI also runs on AMD and Apple silicon, where formats and speed differ.
  • Prices: Comfy Cloud's pricing page, read on 16 October 2026; RunPod's Wan 2.2 API, read on 9 October 2026; cloud GPUs by the hour, from the cloud GPU guide, read on 19 October 2026. Measured costs: our own runs on 20 October 2026.
  • Fit rule: a stage loads fully under 85% of usable memory and is tight up to 95%, the same margins the LLM tools use.

The numbers, once a month.

New open models and what they need, price moves, our newest measurements. One email a month; unsubscribe in one click.

Or follow new findings and data changes by RSS.

One email a month. Unsubscribe in one click; your address is used for nothing else. Privacy notice