The honest answer is that ComfyUI itself needs very little, and the models you load decide the GPU. SD 1.5 and SDXL run on 8 to 10 GB cards. FLUX.1, Qwen-Image and Wan 2.2 5B are sized for 24 GB cards. Wan 2.2 A14B at 720P and FLUX.2 [dev] are the ones their makers size for 80 GB cards. ComfyUI's offloading lowers every one of those minimums, at the cost of speed and system RAM. Every QuantaCloud GPU has at least 48 GB, so the real choice is which card runs your workflow without offloading.
VRAM by model#
The rule I follow is to add up the files a workflow loads and compare the total with the published figure for the model. The file totals below come from the byte sizes on Hugging Face, and the published figures from each model's own docs or ComfyUI's.
| Workflow | Files ComfyUI loads (our calculation) | Published VRAM figure | QuantaCloud GPU I would start on |
|---|---|---|---|
| SD 1.5 | One 4.27 GB checkpoint | At least 10 GB for the original Stable Diffusion v1 code (CompVis) | RTX A6000 |
| SDXL 1.0 | One 6.94 GB checkpoint | 8 GB (Stability AI) | RTX A6000 |
| FLUX.1 [schnell], fp8 checkpoint | One 17.24 GB checkpoint | No official figure | RTX A6000 |
| FLUX.1 [dev], 16-bit | 34.17 GB: model, T5-XXL, CLIP-L and VAE | Model file about 23 GB, halved by an fp8 weight type (ComfyUI docs) | RTX A6000 |
| Qwen-Image, fp8 | 30.07 GB: model, text encoder and VAE | ComfyUI measured 86% use of a 24 GB RTX 4090D | RTX 6000 Ada or L40S, or an RTX A6000 with the fp8mixed file |
| Qwen-Image-Edit-2511, fp8mixed | 30.17 GB: model, text encoder and VAE | No official figure | RTX 6000 Ada or L40S, or an RTX A6000 with the INT8 file |
| Z-Image Turbo, 16-bit | 20.69 GB: model, Qwen3 4B text encoder and VAE | Fits a 16 GB card (Tongyi) | RTX A6000 |
| FLUX.2 [klein] 4B, fp8 | 12.45 GB: model, Qwen3 4B text encoder and VAE | About 13 GB on its model card, about 8 GB in its README (Black Forest Labs) | RTX A6000 |
| FLUX 3 Image Klein, template files | 17.75 GB: INT8 model, INT8 text encoder, 4-bit prompt upsampler and VAE | 31 GB in BF16 and 26 GB in FP8 with Black Forest Labs' reference code, plus about 28 GB for the upsampler | RTX A6000 |
| HiDream-I1 Full, fp8 | 33.32 GB: model, four text encoders and VAE | More than 16 GB in fp8, more than 27 GB at full precision (ComfyUI docs) | RTX 6000 Ada or L40S, where its plain fp8 file stays fp8 |
| Krea 2 Turbo, fp8 | 18.64 GB: model, Qwen3-VL 4B text encoder and VAE | No official figure | RTX A6000 |
| Wan 2.2 TI2V-5B (video) | 18.14 GB: fp16 model, fp8 text encoder and VAE | 24 GB for 720P (Wan), about 8 GB with ComfyUI's offloading | RTX A6000 |
| Wan 2.2 T2V-A14B (video), fp8 | 35.58 GB: two experts, text encoder and VAE | 80 GB for 720P, with peaks of 41.3 GB at 480P and 59.8 GB at 720P in Wan's own code | A100 80GB, H100 or RTX PRO 6000 Blackwell |
| FLUX.2 [dev] | 71.38 GB: fp8mixed model, bf16 text encoder and VAE | An H100-equivalent GPU for Black Forest Labs' reference script | RTX PRO 6000 Blackwell or H200 NVL |
| SeedVR2 7B, fp16 (video upscaling) | 16.98 GB: model and VAE | 24 GB for the 16-bit files without memory optimizations (the custom node's docs) | RTX A6000 for 1080p, RTX PRO 6000 Blackwell for 4K |
The totals are weights only. Activations come on top and grow with resolution, frame count and batch size, which is why Wan's figure climbs from 41.3 GB at 480P to 59.8 GB at 720P while the files stay the same. The totals are also a worst case, because ComfyUI does not need every file on the GPU at once: it loads weights when a step needs them and evicts older ones under memory pressure. The FLUX, FLUX.2, Qwen-Image, Qwen-Image-Edit, Z-Image Turbo, Wan 2.2 and SeedVR2 guides list every file and where it goes, and loading models on a new instance has a script that downloads a set in one command. Open-source image generation models compares the image models' licences and 16-bit and 8-bit totals side by side, and GGUF models in ComfyUI covers the one case where a quantized GGUF file helps on a 48 GB card. For video with its soundtrack, LTX-2.5 in ComfyUI loads 39.71 GB of INT8 files, which is 36.98 GiB against a 48 GB card's 41.39 GiB budget, and Lightricks asks for a GPU with at least 32 GB.
How offloading changes the minimum#
The one feature that changed the answer is DynamicVRAM, which Comfy added to its stable releases for NVIDIA GPUs in March 2026. When a layer's weights do not fit on the GPU, ComfyUI copies them over for that one layer and carries on, instead of stopping with an out-of-memory error. Comfy's own benchmark ran Wan 2.2's two 14B experts, 56 GB of fp16 weights, at 320 x 320 and 81 frames on an RTX 5060, an 8 GB card, with 32 GB and 64 GB of system RAM. In ComfyUI v0.37.0 it is on by default on NVIDIA GPUs with PyTorch 2.8 or newer, and the startup log says DynamicVRAM support detected and enabled.
The memory flags you find in older guides now behave differently:
| Flag | What it does in ComfyUI v0.37.0 |
|---|---|
| None | DynamicVRAM: weights load when needed and spill to system RAM under pressure |
--highvram | Keeps models in GPU memory after use, and turns DynamicVRAM off |
--gpu-only | Stores and runs everything, text encoders included, on the GPU, and turns DynamicVRAM off |
--novram | The option for when low-VRAM mode is not enough, and it turns DynamicVRAM off |
--lowvram | Does nothing while DynamicVRAM is on. Without it, runs the text encoders on the CPU |
--reserve-vram 8 | Leaves 8 GB of GPU memory for other software on the same card, such as Ollama |
--disable-dynamic-vram | Returns to the older loading, which estimates memory before it loads a model |
Offloading moves the requirement rather than removing it. Weights that leave the GPU sit in system RAM or are read back from disk, and every copy crosses PCIe, so each step takes longer. On QuantaCloud the configurations differ more in RAM than in GPU memory: in the 2026-09-27 catalog an RTX A6000 1x came with 24 to 64 GB of RAM, an RTX PRO 6000 1x with 144 GB and an H200 NVL 1x with 180 GB. Check the RAM of an offer before you count on offloading a large model.
Precision is the other lever, and the GPU's architecture decides whether it saves memory. ComfyUI computes in FP8 only on compute capability 8.9 or higher, which on QuantaCloud means the RTX 6000 Ada, L40, L40S, H100, H200 NVL and RTX PRO 6000. On the Ampere cards, the RTX A6000 and A100, ComfyUI converts a plain fp8 file to 16-bit as it loads whenever the 16-bit copy fits. Qwen-Image's 20.43 GB fp8_e4m3fn file therefore becomes about 40.86 GB of weights on an A6000, the size of its bf16 file. Files published as fp8_scaled or fp8mixed carry per-layer scaling data and stay fp8 on every GPU, so the 20.53 GB qwen_image_fp8mixed file is the one to download for an A6000. FP8 vs FP16 vs BF16 explains the formats.
Which QuantaCloud GPU runs each workflow#
The rule I follow is to pick the smallest card that holds the whole workflow without offloading, and to treat offloading as a fallback rather than a plan.
| QuantaCloud GPU | Memory | FP8 compute in ComfyUI | What I would run on it without offloading |
|---|---|---|---|
| RTX A6000 | 48 GB | No (Ampere) | SD 1.5, SDXL, FLUX.1 at 16-bit, Z-Image Turbo, FLUX.2 [klein], Qwen-Image from the fp8mixed file, Qwen-Image-Edit-2511 from the INT8 file, Wan 2.2 5B |
| RTX 6000 Ada, L40, L40S | 48 GB | Yes (Ada) | The same, with plain fp8 files at half their 16-bit memory |
| A100 80GB | 80 GB | No (Ampere) | Wan 2.2 A14B at 720P, and FLUX.2 [dev] on paper with about 7.1 GiB to spare, because its fp8mixed layers stay fp8 |
| H100 PCIe | 80 GB | Yes (Hopper) | Wan 2.2 A14B at 720P, and FLUX.2 [dev] on paper with about 6.8 GiB to spare |
| RTX PRO 6000 Blackwell | 96 GB | Yes, plus NVFP4 | FLUX.2 [dev] as ComfyUI ships it, Wan 2.2 A14B with room to spare, and SeedVR2 7B upscaling to 4K |
| H200 NVL | 141 GB | Yes (Hopper) | Everything above, with room for larger batches and longer clips |
Live prices per GPU-hour:
| GPU | Memory | From | Available now |
|---|---|---|---|
| RTX A6000 | 48 GB | $0.48/GPU-hr | Yes |
| RTX 6000 Ada | 48 GB | $0.78/GPU-hr | Yes |
| L40 | 48 GB | $0.94/GPU-hr | Yes |
| L40S | 48 GB | $1.09/GPU-hr | Yes |
| A100 SXM4 80GB | 80 GB | $1.50/GPU-hr | Yes |
| H100 PCIe | - | Not listed | No |
| RTX PRO 6000 Blackwell | 96 GB | $2.16/GPU-hr | Yes |
| H200 NVL | 141 GB | $3.43/GPU-hr | Yes |
The ComfyUI template runs on any of them, and the price is the same with or without it. The H100 PCIe and H200 NVL rows apply when the catalog lists those cards, and for a standing render setup on hardware the catalog does not list, send a capacity brief and we quote a build to your spec in writing. ComfyUI runs each model on one GPU, so a 2-GPU configuration does not hold a bigger model: ComfyUI with more than one GPU covers what a second card is for.
Launch ComfyUI on an RTX A6000Licenses decide more than VRAM#
The license of the model you pick decides what you may do with it, and the Hugging Face mirror you download from changes nothing.
| Model | License | Commercial use of the model |
|---|---|---|
| SDXL 1.0 | CreativeML Open RAIL++-M | Allowed, and its use restrictions pass on to anyone you share it with |
| FLUX.1 [schnell] | Apache-2.0 | Allowed |
| FLUX.1 [dev] | FLUX.1 [dev] Non-Commercial License | Outputs may be used commercially. The model itself needs a license from Black Forest Labs |
| FLUX.2 [dev] | FLUX Non-Commercial License | Only with a license from Black Forest Labs |
| Qwen-Image | Apache-2.0 | Allowed. The newer Qwen-Image-2.1 is under a research-only license |
| Qwen-Image-Edit-2511 | Apache-2.0 | Allowed |
| Z-Image Turbo and Z-Image | Apache-2.0 | Allowed |
| FLUX.2 [klein] 4B | Apache-2.0 | Allowed. The 9B [klein] models are under the FLUX Non-Commercial License |
| FLUX 3 Image Klein | FLUX Kommunity License | Non-commercial use, plus commercial images for users under USD 5 million in gross annualized revenue |
| HiDream-I1 | MIT | Allowed. Its Llama 3.1 8B text encoder comes with Meta's Llama 3.1 Community License |
| Krea 2 | Krea 2 Community License | Only below USD 1 million in company-wide annual revenue, and this covers the images too |
| Stable Diffusion 3.5 | Stability AI Community License | Free below USD 1 million in annual revenue, with registration |
| Wan 2.2 | Apache-2.0 | Allowed |
| SeedVR2 | Apache-2.0 | Allowed |
Treat the table as a summary and read the license on the model card before you build a product on a model.
Check what your own workflow uses#
The one thing I always check is the peak during the real job, at the resolution and batch size I will actually run. Over SSH, watch the card while ComfyUI generates:
nvidia-smi --query-gpu=memory.used,memory.total --format=csv -lms 500
ComfyUI reports its own view, including the system RAM that offloading relies on:
curl -s http://127.0.0.1:8188/system_stats | python3 -m json.tool
The response lists vram_total and vram_free for the GPU, ram_total and ram_free for the VM, and the ComfyUI and PyTorch versions. If a workflow still runs out of memory, fixing CUDA out of memory orders the fixes by what they cost, and how much VRAM you need covers LLMs and training on the same cards.
Frequently asked questions#
Can ComfyUI run on 8 GB of VRAM?
Yes, for SD 1.5 and SDXL, and with offloading for much larger models. Comfy's own benchmark ran Wan 2.2 A14B at 320 x 320 on an 8 GB RTX 5060, at the cost of speed and system RAM.
How do I pick a GPU for Stable Diffusion in the cloud?
Start from the files your workflow loads. The card I would rent first is the 48 GB RTX A6000, which holds SD 1.5, SDXL and FLUX.1 at 16-bit with room to spare. Move to an Ada card such as the L40S when you want fp8 files at half their memory, and to the RTX PRO 6000 Blackwell, or the H200 NVL when the catalog lists it, for FLUX.2 [dev] and Wan 2.2 A14B at 720P.
Does ComfyUI need an NVIDIA GPU?
No. ComfyUI also runs on AMD, Intel Arc and Apple Silicon GPUs, and on the CPU with --cpu, slowly. Every QuantaCloud GPU is NVIDIA.
How much system RAM does ComfyUI need?
There is no official figure. ComfyUI maps model files into memory, so RAM works as a cache: with enough RAM, offloaded weights come back from RAM, and with too little they are read again from disk, which is slower. Match RAM to the models you expect to offload.
My decision rule: add up the files, pick the smallest card that holds them with room for activations, and let offloading rescue a workflow rather than define it. For most people that means ComfyUI on an RTX A6000, an Ada card such as the L40S when fp8 files matter, and the RTX PRO 6000 Blackwell, or the H200 NVL when the catalog lists it, for FLUX.2 [dev] and Wan 2.2 A14B at 720P. Running ComfyUI on a cloud GPU covers the setup, and the ComfyUI page has the live GPU picker.