Generative AI runtime

Self-host ComfyUI: the VRAM number depends on what you drag onto the canvas

The ComfyUI engine itself barely touches VRAM. What eats it is the weight you pick in the Load Diffusion Model node. Here are the real numbers from SDXL to Flux.2 and Wan 2.2, and which card to rent for each.

ComfyUI · self-hosted

ComfyUI is the node-graph generation engine maintained by Comfy Org, GPL-3.0 licensed, living at github.com/comfyanonymous/ComfyUI. It stopped being "another Stable Diffusion front-end" a long time ago. The current release natively runs SD1.5, SDXL, SD3.5, Flux.1, Flux.2, Qwen Image, Z-Image, Hunyuan Image 2.1, HiDream and Lumina Image 2.0 for stills; Wan 2.1/2.2, LTX-Video 2/2.3/2.5, HunyuanVideo 1.5 and MiniMax-H3 for video; ACE-Step 1.5, Stable Audio 3 and MiniMax Music 3 for audio; plus Hunyuan3D 2.1, TripoSplat, SAM and Depth Anything on the 3D and vision side. The project ships weekly, targeting Monday, with a major stable version roughly every two weeks — the v0.30 through v0.33 run all happened inside the last few weeks.

The environment layer is pickier than most people expect. Comfy Org recommends Python 3.13 (3.12 as the compatibility fallback; 3.14 runs but breaks some custom nodes), PyTorch 2.7 as an absolute floor with newer strongly preferred, and a cu130-or-later PyTorch build is mandatory on NVIDIA 20-series and above. requirements.txt also pins a batch of packages hard — comfyui-frontend-package==1.49.6, comfyui-workflow-templates==0.11.46, comfy-kitchen==0.2.31, comfy-aimdo==0.4.13 — and the docs explicitly tell you not to upgrade them on your own. Assembling that stack on your Windows daily driver is frequently more painful than installing it cleanly on a rented Linux box.

The bigger problem is how steep the VRAM curve is. Z-Image-Turbo at 6B officially fits comfortably in 16GB of consumer VRAM. Qwen-Image in bf16 is a single 40.9GB file. Wan 2.2's I2V-A14B is two fp16 expert shards at roughly 28GB each. Same ComfyUI window, an 8GB-to-80GB spread. No single local card covers that range — but NexGPU has 1,175 verified rentable nodes across 51 countries and regions, 2,498 GPUs, 75 GPU models, up to 14 GPUs per node and 2,152GB max node VRAM, metered per second with no minimum and no quota request. Test SDXL on a 3090 today, run Qwen-Image bf16 on an A100 tomorrow, without editing a single node.

01 —

What each model line actually costs you in VRAM

The engine sits at v0.33.x, but it is never the engine that decides which card you rent.

Version	Parameters	VRAM	Context	Notes
Z-Image-Turbo	6B	Officially fits comfortably within 16GB of consumer VRAM	8 NFEs (about 9 steps) per image	Apache 2.0, strong bilingual English/Chinese text rendering, absurdly few steps. The cheapest honest way to prove your ComfyUI install works end to end.
SDXL 1.0 / SD3.5 Large	3.5B UNet / 8B	SDXL fp16 checkpoint ~7GB, runs on an 8GB card; SD3.5 Large fp16 ~16GB	1024×1024 native	The line with the deepest LoRA, ControlNet and IPAdapter ecosystem. Wire up and debug your graph here — it is the cheapest place to be wrong.
Flux.1 dev	12B	fp8_e4m3fn weights ~12GB / bf16 ~24GB, plus the T5-XXL text encoder and VAE	1024–2048 resolution	ComfyUI's own example page spells it out: setting weight_dtype to fp8 on the Load Diffusion Model node halves memory usage with a tiny quality cost. fp8 on a 24GB card is the mainstream configuration today.
Flux.2 dev	32B	bf16 weights ~64GB; Black Forest Labs also ships a 4-bit quantised build aimed at RTX 4090 / RTX 5090 class consumer cards	High-resolution single and multi-reference generation	A 32B rectified flow transformer under the FLUX Non-Commercial License, natively supported in ComfyUI. If you want bf16, stop looking at 24GB cards.
Qwen-Image	20B MMDiT	bf16 40.9GB / fp8_e4m3fn 20.4GB, paired with qwen_2.5_vl_7b_fp8_scaled as text encoder	1328×1328 and other native ratios	Measured by Comfy Org on an RTX 4090D 24GB: fp8 sits at about 86% VRAM, ~94s for the first image and ~71s steady state, dropping to ~34s with an 8-step lightx2v LoRA. The most useful benchmark on this page.
Wan 2.2 / HunyuanVideo 1.5 (video)	TI2V-5B / T2V-A14B / 8.3B	Wan2.2 5B fp16 ~10GB and officially fits 8GB with ComfyUI's native offloading; T2V-A14B fp8 scaled ~7GB each ×2; I2V-A14B fp16 ~28GB each ×2; HunyuanVideo 1.5 needs a minimum of 14GB with model offloading on	480p / 720p, upscalable to 1080p	A14B means two experts — high-noise and low-noise — swapped in turn: peak VRAM counts one, but disk and load time count both. Video is the one workload in ComfyUI that will genuinely fill an 80GB card.

02 —

Which card to rent, matched to the weights you load

NexGPU list rates, metered per second and priced per hour. Compute billing stops the moment the instance stops.

SDXL / SD3.5 and Z-Image-Turbo, or just wiring up a graph and tuning node parameters
RTX 3090 24GB$0.193/GPU-hour
The cheapest 24GB card on the network — plenty for the whole SDXL family plus Z-Image-Turbo, and three hours of graph-wrangling costs about half a dollar.
Day-to-day production on Flux.1 dev fp8, Qwen-Image fp8 and Wan 2.2 TI2V-5B
RTX 4090 24GB$0.540/GPU-hour
Ada with native fp8, the same class as the 4090D 24GB Comfy Org benchmarked on — so you can cost your work directly off their 71-seconds-per-image number.
Flux.1 dev at full bf16, Wan 2.2 A14B with both experts resident, HunyuanVideo 1.5 at 720p without offloading
RTX A6000 48GB$0.817/GPU-hour
48GB means you never trade image quality for memory, and you never pay the offloading tax of shuffling weights between CPU and GPU every step.
Qwen-Image bf16 at the full 40.9GB, Wan 2.2 I2V-A14B fp16 at 28GB ×2, or several concurrent queues
A100 SXM4 80GB$1.088/GPU-hour
80GB is the threshold where the diffusion backbone, text encoder and VAE all fit with activation headroom to spare, and SXM4 bandwidth holds up under long video sequences.

03 —

From bare instance to first image, in four steps

NexGPU gives you SSH, Jupyter, a web terminal, a REST API and a CLI, plus 2,000+ prebuilt images including ComfyUI and PyTorch.

01
Boot an instance and install ComfyUI
Pick the prebuilt ComfyUI image and you can skip this entirely. Installing by hand, use an isolated virtual environment — the official docs are blunt about it: ComfyUI's dependencies conflict with other things on the system. Note the cu130 wheel index; anything from the NVIDIA 20-series up requires it.
```
git clone https://github.com/comfyanonymous/ComfyUI.git && cd ComfyUI && pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130 && pip install -r requirements.txt
```
02
Start the server and bring port 8188 to your browser safely
ComfyUI listens on 127.0.0.1:8188 by default, so starting it on a remote box gives you nothing locally. The clean answer is not to expose it publicly but to tunnel: ssh -L 8188:localhost:8188 <user>@<node>, then open localhost:8188 at home. If you genuinely need --listen 0.0.0.0, set the ComfyUI-Manager security level in config.ini to normal- or strong first.
```
python main.py --listen 127.0.0.1 --port 8188 --enable-manager
```
03
Put the weights in the directories ComfyUI expects
ComfyUI is strict about layout: full checkpoints in models/checkpoints, standalone diffusion weights in models/diffusion_models, T5-XXL or Qwen2.5-VL in models/text_encoders, VAEs in models/vae, LoRAs in models/loras. Keep the models on a persistent volume and point at it with extra_model_paths.yaml so a fresh instance never re-downloads 20GB.
```
comfy model download --url <huggingface-url> --relative-path models/diffusion_models
```
04
Downshift when VRAM is tight, or drive ComfyUI headless
When memory is tight, work down the list: --lowvram (text encoders to CPU), --novram (aggressive offloading), --reserve-vram 1 and --vram-headroom to leave the OS room, --fp8_e4m3fn-unet to load the diffusion model in fp8 directly, --cpu-vae to move decoding off the card. With memory to spare, go the other way with --highvram or --gpu-only. Attention backends worth trying: --use-sage-attention, --use-flash-attention, --use-ck-attention. For headless batch work, use HTTP: POST /prompt with the API-format workflow JSON, GET /history/{prompt_id} for results, GET /view for artefacts, WebSocket /ws for progress, GET /system_stats for device and memory state.
```
python main.py --lowvram --reserve-vram 1 --fp8_e4m3fn-unet --use-sage-attention
```

What a ComfyUI image actually costs

Take Comfy Org's own measurement on a 24GB card. Qwen-Image fp8 runs about 71 seconds per image at steady state. Rent an RTX 4090 24GB at $0.540/GPU-hour and one hour gets you 3600 ÷ 71 ≈ 50 images, so $0.540 ÷ 50 ≈ $0.0108 each. Add the 8-step lightx2v acceleration LoRA and each image drops to roughly 34 seconds — about 105 images an hour, or ≈ $0.0051 each, half a cent per picture. If you are still wiring nodes and testing parameters rather than producing anything, drop to an RTX 3090 24GB at $0.193/GPU-hour: three hours of fiddling is $0.579. Storage is separate: Qwen-Image fp8 at 20.4GB plus the Qwen2.5-VL text encoder and VAE lands around 25GB, and at the $0.414/GB-month median that is ≈ $10.35/month for as long as the volume exists — while compute billing stops the second you stop the instance. Pulling those 50 images home is roughly 100MB, so egress at the $0.0081/GB median is ≈ $0.0008. No minimum, no setup fee, no quota request.

04 —

Frequently asked questions

How much VRAM does ComfyUI need? Will it run on an 8GB card?

The engine's own overhead is small; the VRAM goes entirely to the model you load. 8GB runs SDXL and Wan 2.2 TI2V-5B via native offloading. 16GB comfortably runs Z-Image-Turbo. 24GB is the sweet spot for Flux.1 dev fp8 and Qwen-Image fp8. For Qwen-Image bf16 at 40.9GB or Flux.2 dev in bf16, 48GB is the floor and 80GB is where it stops hurting. Rather than buying a card sized for your heaviest occasional job, rent per second on NexGPU: RTX 3090 24GB from $0.193/GPU-hour up to A100 SXM4 80GB at $1.088/GPU-hour, same workflow, different machine.

Does ComfyUI support multiple GPUs? Can one big model be split across two cards?

No — ComfyUI does not do tensor parallelism for a single model. What it gives you is device placement: --cuda-device selects the card (it also accepts "all") and --default-device sets the default, so you can park the diffusion model and the text encoder on different GPUs. Real horizontal scaling means one process per card behind a queue. NexGPU nodes go up to 14 GPUs and 2,152GB of VRAM per node, so you can stand up a row of ComfyUI workers on one machine instead of assembling a cluster.

How do I open a remote ComfyUI in my local browser?

ComfyUI binds to 127.0.0.1:8188 by default, and that is a deliberate safety default. The recommended route is an SSH tunnel — ssh -L 8188:localhost:8188 <user>@<node>, then browse to localhost:8188 with no public port open at all. If you must use --listen 0.0.0.0, move the ComfyUI-Manager security level off weak to normal- or strong; normal- exists precisely to block high-risk features on non-loopback listeners. Every NexGPU instance ships with SSH, Jupyter and a web terminal, so the tunnel is one command.

I installed a few custom nodes and now ComfyUI won't start. How do I find the culprit?

This is ComfyUI's number one failure mode, and the project warns about it directly: the update_comfyui_and_python_dependencies script reinstalls every dependency, which can overwrite packages you configured by hand and break custom nodes pinned to specific versions. Debug in order: --disable-all-custom-nodes to confirm it is a node problem at all, then --whitelist-custom-nodes to bisect the suspects. When repairing dependencies, use the exact versions in requirements.txt rather than upgrading things like comfyui-frontend-package yourself. The other advantage of renting: if you truly wreck it, destroy the instance and start clean in under a minute, without contaminating your main machine.

Can ComfyUI be used as a headless backend API?

Yes, and for production that is the right way to use it. Export the canvas graph in API format, then POST /prompt to submit, GET /history/{prompt_id} for results, GET /view to download outputs, POST /upload/image to feed inputs, WebSocket /ws for live progress, GET /object_info for every node definition and GET /system_stats for device and memory state. Add --disable-api-nodes to run fully offline with every closed-source partner node switched off. NexGPU exposes its own REST API and CLI too, so provisioning, mounting and teardown all script cleanly.

Is ComfyUI free? How does it relate to Comfy Cloud and ComfyUI Desktop?

ComfyUI itself is GPL-3.0, open source and free, maintained by Comfy Org on a weekly cadence with a stable major roughly every two weeks. ComfyUI Desktop is the official desktop wrapper, Comfy Cloud is their hosted paid service, and the partner / API nodes call closed models like Nano Banana and Seedance on a metered basis — all of which --disable-api-nodes turns off. Running it on your own card removes that subscription layer entirely: on NexGPU you pay per second for compute, the models and workflows stay yours, and support is bilingual over Telegram with no ticket queue.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.