Image generation model

Stable Diffusion local deployment: 4GB to 48GB, and a card for every tier

VRAM demand across SD 1.5, SDXL and SD 3.5 spans more than a factor of ten. This page lines up each variant's real footprint against the NexGPU machine that runs it and what that machine costs per hour.

Stable Diffusion · self-hosted

Stable Diffusion has never been one model — it is a lineage whose generations barely resemble each other. SD 1.5 is a 0.9B UNet at a native 512×512 under CreativeML OpenRAIL-M. SDXL 1.0 swaps in a 3.5B base plus a refiner in an ensemble-of-expert-denoisers pipeline, goes native 1024×1024, and moves to the more permissive OpenRAIL++-M. SD 3.5 replaces the architecture entirely with an MMDiT multimodal diffusion transformer — 8.1B for Large, 2.5B for Medium — under the Stability AI Community License, which is free for research and for commercial use below $1M annual revenue and requires an enterprise agreement above it. Ignore the articles claiming SD4 has shipped: Stability's own news page shows Stable Audio 3.0, Brand Studio, and label partnerships through 2025 and 2026, and the stabilityai org on Hugging Face has no image weights newer than 3.5.

What actually determines the card you need is usually not the backbone — it is the text encoder stack. SD 1.5 carries a single CLIP ViT-L; SDXL carries CLIP-L plus OpenCLIP-G, under 1B combined. The SD 3 line adds T5-XXL, and that one encoder is 4.7B parameters, roughly 9.5GB resident in fp16. That is exactly why Stability's published figure for SD 3.5 Medium reads "9.9 GB of VRAM (excluding text encoders)" — count the encoders and the bill doubles. The community answer is the fp8_e4m3fn_scaled T5, and ComfyUI's own guidance is blunt about it: use t5xxl_fp16.safetensors if you have more than 32GB of RAM, otherwise use t5xxl_fp8_e4m3fn_scaled.safetensors. The packed sd3.5_large_fp8_scaled.safetensors squeezes the 8B backbone and all three encoders to just over 11GB, which is the only reason a 24GB card is in play at all.

The ecosystem picture deserves honesty too. LoRAs, ControlNets, IP-Adapters and the vast library of community checkpoints still sit overwhelmingly on SDXL and SD 1.5. SD 3.5 ships only three official ControlNets — canny, depth and blur — and has a far thinner fine-tune population, while newer open weights like FLUX.2 dev and Qwen-Image have opened a separate front on prompt adherence and legible in-image text. No single version wins outright, so in practice you run the same prompt set through SDXL, SD 3.5 Large and Large Turbo before committing. That is the worst possible reason to buy a GPU. NexGPU has 1,175 verified rentable nodes and 2,498 GPUs across 75 models in 51 countries and regions, with 2,000+ prebuilt images including ComfyUI, Stable Diffusion, AUTOMATIC1111 and PyTorch — metered per second, no minimum, no setup fee, no quota request.

01 —

Versions and what they actually need

One lineage, an order of magnitude apart in VRAM — pick the wrong tier and you rent the wrong card

Version	Parameters	VRAM	Context	Notes
Stable Diffusion 3.5 Large	8.1B (MMDiT)	bf16 backbone ~16GB; full pipeline with fp16 T5-XXL ~26GB; sd3.5_large_fp8_scaled all-in-one ~11–12GB	1MP native (1024×1024) \| CLIP 77 tokens + T5 256 tokens	The flagship open weight in the SD line. The official diffusers example runs 28 steps at guidance 3.5. Only three official ControlNets exist — canny, depth, blur — and they go in models/controlnet.
Stable Diffusion 3.5 Large Turbo	8.1B (adversarial diffusion distillation)	Same tier as Large; ~11GB via the fp8 all-in-one	1MP \| ComfyUI recommends 4 steps at CFG 1.2	Usable frames in four steps, which makes it the prompt-sweep and live-preview model. Lock the composition here, then re-run the winner through Large at 28 steps — both share the same text encoders on disk.
Stable Diffusion 3.5 Medium	2.5B (MMDiT-X)	9.9GB per Stability, excluding text encoders; ~12–14GB with the sd3.5_medium_incl_clips_t5xxlfp8scaled bundle	0.25–2MP (roughly 512×512 to 1440×1440) \| CLIP 77 + T5 256 tokens	The only 3.5 variant designed for consumer cards. Positional embeddings were extended to 384×384 and training stepped 256 → 512 → 768 → 1024 → 1440, so a 1440 long edge is native rather than an upscale.
SDXL 1.0 (base + refiner)	3.5B base; 6.6B for the full base+refiner pipeline	Runs at ~8GB in fp16, comfortable at 10–12GB; another ~6GB to keep the refiner resident	1024×1024 native \| two encoders, 77 tokens each	Ensemble denoising: base handles the first ~80% of steps, refiner finishes. The deepest LoRA / ControlNet / IP-Adapter ecosystem of any generation, and CreativeML Open RAIL++-M carries no revenue threshold.
SDXL Turbo	3.5B (ADD distilled)	~8GB in fp16	512×512 \| 1–4 steps, CFG disabled (set to 0)	The real-time tier — a usable image in a single step. Built for interactive canvases, draw-as-you-generate tools and live filters, trading fidelity for latency.
Stable Diffusion 1.5	0.9B UNet	~4GB in fp16; 2–3GB with --lowvram	512×512 native \| single CLIP ViT-L encoder, 77 tokens	Old but far from dead, under CreativeML OpenRAIL-M. Note the original runwayml/stable-diffusion-v1-5 repo was deleted — point at the sd-legacy mirror stable-diffusion-v1-5/stable-diffusion-v1-5 or your old scripts will 404.

02 —

Which card to rent

Matched honestly to VRAM — no 48GB workload squeezed onto a 24GB card

Everyday SD 1.5 / SDXL generation and LoRA training
RTX 3090 24GB$0.193/GPU-hr
The cheapest 24GB on the network. SDXL fp16 backbone, refiner, ControlNet and the fp16-fix VAE all stay resident with room to spare, and an overnight batch run costs under five dollars.
Fast iteration on the SD 3.5 Medium or Large fp8 bundles
RTX 4090 24GB$0.540/GPU-hr
sd3.5_large_fp8_scaled lands around 11GB, so 24GB leaves headroom for batching — and Ada has native FP8 tensor cores, so those weights run in hardware rather than emulation.
SD 3.5 Large at full bf16 backbone plus fp16 T5-XXL, no quantisation
RTX A6000 48GB$0.817/GPU-hr
16GB of backbone, 9.5GB of T5, plus ControlNet and activations all resident at once. 48GB is the lowest tier that never touches enable_model_cpu_offload, so throughput is not gated on host transfers.
Full fine-tuning, DreamBooth and multi-resolution bucket training on SDXL or SD 3.5
A100 SXM4 80GB$1.088/GPU-hr
80GB holds optimizer states and gradients without trading speed for gradient checkpointing, and SXM4 interconnect keeps multi-GPU scaling clean — up to 14 GPUs in a single node.

03 —

Four steps to a running SD 3.5

Using the prebuilt ComfyUI image, from boot to first image

01
Start the instance and tunnel the ComfyUI port
Pick the ComfyUI or PyTorch image at console.nexgpu.net and choose a card from the table above. Once it is up, forward the port over SSH and open 127.0.0.1:8188 locally — that is the remote ComfyUI. If you would rather not touch a terminal, the console also gives you Jupyter and a web terminal.
```
ssh -p <port> root@<node>.nexgpu.net -L 8188:127.0.0.1:8188
```
02
Accept the Community License and pull the 8B backbone
The SD 3.5 repos are gated on Hugging Face. You must accept the Stability AI Community License in the browser first, then download with a token, or you get a flat 401. If VRAM is tight, grab sd3.5_large_fp8_scaled.safetensors instead — the encoders are baked in and you can skip step three entirely.
```
hf auth login && hf download stabilityai/stable-diffusion-3.5-large sd3.5_large.safetensors --local-dir /workspace/ComfyUI/models/checkpoints
```
03
Add the three text encoders — this is the step that sets your VRAM bill
CLIP-L, OpenCLIP-G and T5-XXL belong in ComfyUI/models/text_encoders. T5 at fp8_e4m3fn is about 5GB; at fp16 it is about 9.5GB, and that single choice decides whether the pipeline fits a 24GB card. On SDXL, this step becomes pairing it with madebyollin/sdxl-vae-fp16-fix, or the VAE overflows to NaN in fp16 and you get black images.
```
hf download stabilityai/stable-diffusion-3.5-large text_encoders/clip_l.safetensors text_encoders/clip_g.safetensors text_encoders/t5xxl_fp8_e4m3fn.safetensors --local-dir /workspace/ComfyUI/models
```
04
Render the first image, or stand up a service
In ComfyUI the stock SD3.5 workflow is enough: 28 steps at CFG 3.5 for Large, 4 steps at CFG 1.2 for Large Turbo. To wire it into your own backend, use the diffusers StableDiffusion3Pipeline and add enable_model_cpu_offload when memory gets tight. Stop the instance when you are done — compute billing stops immediately and the weights stay on storage for next time.
```
python -c "import torch; from diffusers import StableDiffusion3Pipeline; p=StableDiffusion3Pipeline.from_pretrained('stabilityai/stable-diffusion-3.5-large', torch_dtype=torch.bfloat16).to('cuda'); p('a neon-lit noodle stall in Chongqing at night', num_inference_steps=28, guidance_scale=3.5).images[0].save('out.png')"
```

What one full production round costs

Say you are producing a batch of product concept images. First, two hours on an RTX 4090 24GB ($0.540/GPU-hr) running the sd3.5_large_fp8_scaled bundle to sweep prompts and tune ControlNet: 2 × 0.540 = $1.08. With the direction locked, three hours on an RTX A6000 48GB ($0.817/GPU-hr) for the real batch at bf16 backbone plus fp16 T5-XXL: 3 × 0.817 = $2.451. Keep a 30GB model volume for the weights — sd3.5_large is about 16.5GB, fp16 T5 about 9.5GB, plus a few SDXL checkpoints and LoRAs — at $0.414/GB-month that is 30 × 0.414 = $12.42 for a full month, or 12.42 × 5 ÷ 30 = $2.07 if you keep it five days. Export 2GB of finished images at $0.0081/GB = $0.016. Total: 1.08 + 2.451 + 2.07 + 0.016 ≈ $5.62 for a complete multi-version comparison plus final render. Two things to remember: compute is metered per second and priced per hour, so it stops the instant you stop the instance, while storage keeps billing until the volume is destroyed — clear out the checkpoints you no longer need once the comparison is done.

04 —

FAQ

What is the latest Stable Diffusion version? Is SD4 real?

The newest open weights are still Stable Diffusion 3.5 — Large at 8.1B, Large Turbo, and Medium at 2.5B. Stability AI's own news page through 2025 and 2026 lists Stable Audio 3.0, Brand Studio and label partnerships with Universal and Warner; the most recently updated image models in the stabilityai org on Hugging Face are AMD NPU ports of SD 3.5 and SDXL. There are no image weights past 3.5. The articles announcing "SD4 with native 4096×4096" are fabricated SEO content — do not size hardware against them. If you want to check for yourself, an RTX 3090 on NexGPU is $0.193/GPU-hr; running 3.5 and SDXL side by side beats reading ten reviews.

How much VRAM does Stable Diffusion actually need locally?

Four tiers. SD 1.5 in fp16 is about 4GB, or 2–3GB with --lowvram. SDXL in fp16 runs at about 8GB and is comfortable at 10–12GB, plus roughly 6GB more to keep the refiner resident. SD 3.5 Medium is 9.9GB by Stability's own figure excluding text encoders, or 12–14GB in practice with the fp8 encoder bundle. SD 3.5 Large is 11–12GB via the fp8 all-in-one, or around 26GB at bf16 with fp16 T5-XXL. On NexGPU those map to Tesla T4 16GB at $0.298, RTX 3090 24GB at $0.193, RTX 4090 24GB at $0.540 and RTX A6000 48GB at $0.817 per GPU-hour — and if you pick wrong, you stop the instance and start the right one.

Can a 24GB RTX 4090 run SD 3.5 Large?

Yes, with quantisation. The simplest path is ComfyUI's sd3.5_large_fp8_scaled.safetensors, which packs the backbone and all three encoders to just over 11GB — 24GB leaves room to batch. Through diffusers, NF4 quantisation via bitsandbytes plus enable_model_cpu_offload gets you there as well. What does not fit in 24GB is the uncompromised path: bf16 backbone with fp16 T5-XXL. For that you want an RTX 5090 32GB ($0.723/GPU-hr) or an RTX A6000 48GB ($0.817/GPU-hr). NexGPU has both, and switching tiers is just booting a different instance.

Should I use SDXL or SD 3.5?

It comes down to ecosystem versus quality and licensing freedom. SDXL 1.0 has many times the LoRAs, ControlNets, IP-Adapters and community checkpoints, and CreativeML Open RAIL++-M carries no revenue threshold — for stylisation, character consistency and migrating an existing workflow it is still the answer. SD 3.5 Large is clearly stronger on prompt adherence and in-image text, but ships only three official ControlNets and its Community License caps free commercial use at $1M annual revenue, above which you need an enterprise agreement. The realistic move is running the same prompt set through both before deciding — two RTX 3090s in parallel on NexGPU costs under $0.40 an hour, which is cheaper than arguing about it.

Why are my SDXL outputs pure black, or throwing NaN?

This is SDXL's most famous trap: the original VAE has internal activation values large enough to overflow in fp16, which turns them into NaN and decodes to a black frame. Two fixes. Swap in madebyollin/sdxl-vae-fp16-fix, which was finetuned to scale down internal weights and biases while keeping the final output the same, specifically for fp16. Or pass --no-half-vae in AUTOMATIC1111 or Forge to run the VAE in fp32, at the cost of some extra VRAM. A 24GB card on NexGPU handles the second option without breaking a sweat, and ComfyUI and AUTOMATIC1111 are both in the 2,000+ prebuilt images, configured and ready at boot.

runwayml/stable-diffusion-v1-5 is gone. Where do I get SD 1.5 now?

RunwayML pulled that repo from Hugging Face, so every old script and Dockerfile pointing at runwayml/stable-diffusion-v1-5 now 404s. The standard replacement is the sd-legacy mirror at stable-diffusion-v1-5/stable-diffusion-v1-5 — same model, still 0.9B at 512×512 under CreativeML OpenRAIL-M, just a different repo id. SD 1.5 needs only about 4GB in fp16, so on NexGPU a Tesla P40 24GB ($0.214/GPU-hr) or RTX 3090 24GB ($0.193/GPU-hr) makes batch generation extremely cheap. Support is bilingual over Telegram with no ticket queue if the mirror path gives you trouble.

Start building on NexGPU

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