TRANSPARENT BY DESIGN

How we estimate VRAM

These are ESTIMATES, not benchmark measurements. We make the assumptions visible so you can judge whether they match your workload.

Units, headroom & fit status

Memory estimates and capacity comparisons use GiB (1,073,741,824 bytes). File sizes in bytes are divided by this value. Hardware names retain their published labels. A nominal capacity is used as a GiB planning value when exact device bytes are unavailable. Total = subtotal × (1 + safety margin). The margin is 12%.

Green: total including margin fits. Yellow: the subtotal fits without margin, or a lighter configuration fits with margin. Red: neither the selected workload nor the fallback configurations checked by the estimator fit. Yellow suggestions come from the same fit functions used by the calculator; a fallback is not a guarantee of backend support.

Available memory per device is its capacity times its usable fraction. Apple unified memory generally uses a 75% planning budget unless a model-specific capacity is listed. A sharded LLM must satisfy the allocation on each device. An ordinary ComfyUI workflow must fit each active stage on one device. Additional devices can run independent copies when the stages fit.

LLM inference

weights bytes = parameters × bits per weight / 8. Measured GGUF rates come from the llama.cpp Llama 3.1 8B reference file, including its mixed tensor types and metadata. The shared FP16/BF16 option uses the FP16 reference rate. Other checkpoints can differ. NVFP4 counts an 8-bit scale per 16 packed weights. Nominal formats model the packed payload only. Generic Q1–Q7 widths describe storage scenarios and do not specify an available checkpoint or inference kernel. NVFP4 block format ↗

KV bytes = 2 × KV layers × KV heads × head dimension × context × batch × bytes per element. The factor 2 represents keys and values. Grouped-query attention uses KV heads rather than all attention heads. Hybrid models use the recorded KV-cache layer count when available; linear-attention state is approximated within runtime overhead.

runtime GiB = first-GPU overhead + extra-GPU overhead × max(0, GPU count − 1). Inference subtotal is weights + KV cache + runtime. Context is capped at the model limit and the calculator maximum.

Effective weight precision

QuantizationBits / weight
FP16 / BF1616.0005 bpw · FP16 GGUF reference
FP88 bpw · Nominal bit width
INT88 bpw · Nominal bit width
NVFP66 bpw · Nominal bit width
NVFP44.5 bpw · Includes block scale
INT44 bpw · Nominal bit width
Q8_08.5008 bpw · Measured GGUF
Q6_K6.5633 bpw · Measured GGUF
Q5_K_M5.7036 bpw · Measured GGUF
Q4_K_M4.8944 bpw · Measured GGUF
Q3_K_M3.996 bpw · Measured GGUF
Q2_K3.1593 bpw · Measured GGUF
Q77 bpw · Nominal bit width
Q66 bpw · Nominal bit width
Q55 bpw · Nominal bit width
Q5_K_S5.5704 bpw · Measured GGUF
Q4_K_S4.6672 bpw · Measured GGUF
Q44 bpw · Nominal bit width
Q3_K_L4.2979 bpw · Measured GGUF
Q3_K_S3.6429 bpw · Measured GGUF
Q33 bpw · Nominal bit width
Q22 bpw · Nominal bit width
Q11 bpw · Nominal bit width

KV cache storage

TypeBytes / element
FP162
FP81
FP40.5
INT40.5
NVFP40.5625
Q8_01.0625
Q4_00.5625

Quantized KV blocks include a scale value; they are larger than a simple 1-byte or half-byte approximation.

Full fine-tuning, LoRA and QLoRA

Full fine-tuning budgets 18 bytes per parameter for mixed-precision AdamW, including 2 for BF16 weights, 4 for master weights, 4 for gradients and 8 for moments. Activations, runtime and headroom are added separately. Multi-GPU training assumes weights, gradients and optimizer states are sharded. Hugging Face ↗

LoRA freezes BF16 base weights and trains adapters. QLoRA freezes NF4 base weights. Both use the adapter and activation estimates below.

QLoRA base weights use double-quantized NF4 at 4.126953125 bits per weight. Inference quantization and KV controls do not apply in QLoRA mode. We assume gradient checkpointing, BF16 activations and Adam optimizer states for LoRA adapters.

LoRA applies to q, k, v, o, gate, up and down projections. Let h = hidden size, q = attention heads × head dimension, k = KV heads × head dimension, and m = h × 3.5. trainable parameters = rank × layers × [(h + q) + 2(h + k) + (q + h) + 3(h + m)].

adapter + optimizer bytes = trainable parameters × 16, covering BF16 weights, BF16 gradients, an FP32 master copy and two FP32 Adam moments. activation bytes = batch × sequence length × hidden size × 2 × (layers + 16). The activation assumption keeps one BF16 hidden state per layer plus approximately 16 hidden widths for the active layer being recomputed.

Subtotal = NF4 base weights + adapter and optimizer + activations + QLoRA runtime + additional GPU overhead. Actual training memory depends strongly on the implementation, target modules and checkpointing policy.

Shared constants

Safety margin12%
LLM runtime overhead0.75 GiB
Each additional GPU overhead0.3 GiB
QLoRA runtime overhead1.5 GiB
QLoRA NF4 bits / weight4.126953125
LoRA bytes / trainable parameter16
Assumed MLP / hidden ratio3.5
Apple usable fraction0.75

Diffusion, images & video: staged peak

ComfyUI runs a workflow in stages and its memory manager moves idle models to system RAM between them (observed in the SDXL measurement below: Unloaded partially: 3056.88 MB freed). The GPU therefore needs the largest stage, not the sum of every model:

  • Text encode = text encoders on GPU + inference reserve
  • Sampling = diffusion model + sampling activations + inference reserve
  • VAE decode = VAE + decode activations + inference reserve

total = max(stages) × (1 + 0.12). The result card shows every stage and marks the peak. The inference reserve is ComfyUI’s minimum_inference_memory(), 0.8 GiB (source). Weight memory comes from exact source file bytes divided by 1,073,741,824; CPU text encoder offload contributes zero GPU memory, and requested FP8 text encoders fall back individually to FP16 where no FP8 file is recorded.

Keep all models resident in VRAM (off by default, resident=1 in the link) models ComfyUI’s --highvram-style behaviour: every stage also carries every other model’s weights, so the requirement becomes all weights + the largest activation + reserve.

Activation formulas (ComfyUI’s own memory planner)

Coefficients are not fitted by us: they are the constants ComfyUI uses to decide what to load, read from its source at commit 1e719279f5. Activations are 2-byte (BF16/FP16) even when weights are FP8. Divide each spatial dimension by the VAE compression ratio of the checkpoint (8, 16 or 32). Video uses floor((frames − 1) / temporal compression) + 1 latent frames. Mochi uses 6 and LTX-Video uses 8.

  • Sampling: batch × latent elements × 2 bytes × 0.01 × memory_usage_factor MiB, ComfyUI’s memory_required() at the one-conditioning-at-a-time minimum the sampler falls back to (minimum_memory_required).
  • VAE decode (per batch item, as ComfyUI sizes decode batches to free memory): SD/SDXL/SD3/Flux 2178 × h × w × 64 × 2 bytes (source); Wan 2.1 (2200 if ≤4 latent frames else 7000) × h × w × 64 × 2 (source); CogVideoX 2800 × max(2, (t − 1) × 4 + 1) × h × w × 64 × 2 (source) applied to one 2-latent-frame chunk, because ComfyUI’s CogVideoX decoder rolls through the video in chunks (source).
  • If an untiled decode does not fit, ComfyUI retries with tiled decoding automatically (source), so a VAE-only overflow is yellow with a tiled suggestion ( 64 latent pixels per 2D tile, 256 output pixels per 3D tile).

These are ComfyUI’s planning estimates, which its authors mark as conservative in places. They do not model custom nodes (block swap, WanVideoWrapper), attention kernels without PyTorch SDPA, or fragmentation. Exact source default resolutions are preserved, including those outside the 16-pixel input grid.

Calibration table

Modelmemory_usage_factorVAE decode formulaPublic measurement cross-check
FLUX.1 [dev]3.1KL VAE

I use FLUX[DEV] fp8 ... With 1024 x 1024 and a long prompt, consumption does not exceed 14 GB of VRAM (RTX 4090, Forge f2.0.1) Forge, not ComfyUI. Our FP8 sampling stage at 1024x1024 is 12.88 GiB before margin (11.08 GiB weights + 0.99 GiB activations + 0.8 GiB reserve), i.e. ~13.8 GB, consistent with the <=14 GB report; 14.4 GiB with margin fits a 16 GB card. Source

FLUX.1 [schnell]3.1KL VAENo public measurement found; ComfyUI planner constants only.
Stable Diffusion XL Base 1.00.8KL VAE

1024x1024 | 1.47 it/s | ... | VRAM Peak ~5.6GB; All resolutions ran with `full load: True` (RTX 4060 Laptop 8GB, ComfyUI v0.15.0, SDXL-based WAI-Illustrious) Our SDXL FP16 sampling stage at 1024x1024 is 5.84 GiB before margin (4.78 GiB UNet + 0.26 GiB activations + 0.8 GiB reserve) and 6.54 GiB with margin, slightly above the measured ~5.6 GB peak, so the estimate errs high and an 8 GB card is green. Source

Stable Diffusion 3.5 Large1.6KL VAENo public measurement found; ComfyUI planner constants only.
Wan 2.1 T2V 14B2.3042Wan 2.1

Sampling 81 frames at 448x800 ... Transformer blocks on cuda:0: 11557.82MB ... Max allocated memory: max_memory=17.285 GB (RTX 4090, ComfyUI-WanVideoWrapper, Wan2.1 14B I2V ATI, 10 of 40 blocks swapped to CPU) Different node pack and an I2V variant. Max allocated minus on-GPU blocks leaves ~6 (log units) for activations, the loaded CLIP vision model and non-block weights; our sampling activations for 448x800x81 are 5.29 GiB. Same order, so a fully loaded FP8 14B run (13.31 GiB) needs ~20 GiB and fits a 24 GB card. Source

Wan 2.1 T2V 1.3B0.6913Wan 2.1

its lightweight version requires only 8GB of VRAM to run (ComfyUI docs, Wan2.1 tutorial) With the FP8 text encoder at 832x480, 81 frames our peak stage (text encode) is 7.92 GiB with margin and the VAE decode stage 6.99 GiB, so an 8 GB card is green; with the FP16 text encoder the verdict suggests text encoders on CPU. Source

CogVideoX 5B2CogVideoXNo public measurement found; ComfyUI planner constants only.
SDXL Turbo0.8KL VAENo public measurement found; ComfyUI planner constants only.
Playground v2 512px Base0.8KL VAENo public measurement found; ComfyUI planner constants only.
Playground v2 1024px Aesthetic0.8KL VAENo public measurement found; ComfyUI planner constants only.
Playground v2.5 1024px Aesthetic0.8KL VAENo public measurement found; ComfyUI planner constants only.
RealVisXL V4.00.8KL VAENo public measurement found; ComfyUI planner constants only.
RealVisXL V5.00.8KL VAENo public measurement found; ComfyUI planner constants only.
DreamShaper XL 1.00.8KL VAENo public measurement found; ComfyUI planner constants only.
DreamShaper XL v2 Turbo0.8KL VAENo public measurement found; ComfyUI planner constants only.
Juggernaut XL v90.8KL VAENo public measurement found; ComfyUI planner constants only.
SDXL-Lightning-1step0.8KL VAENo public measurement found; ComfyUI planner constants only.
SDXL-Lightning-2step0.8KL VAENo public measurement found; ComfyUI planner constants only.
SDXL-Lightning-4step0.8KL VAENo public measurement found; ComfyUI planner constants only.
SDXL-Lightning-8step0.8KL VAENo public measurement found; ComfyUI planner constants only.
Latent Consistency SDXL0.8KL VAENo public measurement found; ComfyUI planner constants only.
FLUX.1 Krea [dev]3.1KL VAENo public measurement found; ComfyUI planner constants only.
Stable Diffusion 3.5 Large Turbo1.6KL VAENo public measurement found; ComfyUI planner constants only.
Qwen-Image1.8Wan 2.1No public measurement found; ComfyUI planner constants only.
Qwen-Image-25121.8Wan 2.1No public measurement found; ComfyUI planner constants only.
HunyuanImage 2.18.7HunyuanImage 2.1No public measurement found; ComfyUI planner constants only.
HunyuanImage 2.1 Distilled8.7HunyuanImage 2.1No public measurement found; ComfyUI planner constants only.
Z-Image-Turbo2.8KL VAENo public measurement found; ComfyUI planner constants only.
CogVideoX 2B2CogVideoXNo public measurement found; ComfyUI planner constants only.
Mochi 1 Preview2Mochi 1No public measurement found; ComfyUI planner constants only.
HunyuanVideo T2V 720p1.8HunyuanVideoNo public measurement found; ComfyUI planner constants only.
HunyuanVideo 1.5 T2V 480p4HunyuanVideo 1.5No public measurement found; ComfyUI planner constants only.
HunyuanVideo 1.5 T2V 720p4HunyuanVideo 1.5No public measurement found; ComfyUI planner constants only.
HunyuanVideo 1.5 T2V 480p CFG Distilled4HunyuanVideo 1.5No public measurement found; ComfyUI planner constants only.
Wan 2.2 TI2V 5B1.3825Wan 2.2No public measurement found; ComfyUI planner constants only.
LTX-Video 0.9.1 (2B)5.5LTX-VideoNo public measurement found; ComfyUI planner constants only.
LTX-Video 0.9.5 (2B)5.5LTX-VideoNo public measurement found; ComfyUI planner constants only.
LTX-Video 0.9.7-dev (13B)11LTX-VideoNo public measurement found; ComfyUI planner constants only.
LTX-Video 0.9.7-distilled (13B)11LTX-VideoNo public measurement found; ComfyUI planner constants only.
LTX-Video 0.9.8-13B-distilled (13B)11LTX-VideoNo public measurement found; ComfyUI planner constants only.

Data sources & limitations

Architecture values come from Hugging Face config.json files and parameter counts from the Hugging Face API safetensors metadata. Component weight sizes come from file listings. Each model guide links its exact sources and last verification date.

VRAM estimates run locally. The directory uses dated specifications and prices and can refresh the trending list from OpenRouter. A memory verdict is not a throughput, compatibility or hardware purchase recommendation. Verify actual usage with your target backend and leave room for other applications, the display and system allocations.