SDXL VRAM Requirements (2026)
The misleading shortcut is to ask for one SDXL memory minimum without specifying the job. Generating an image, training a LoRA, and fine-tuning the full model do not have the same memory requirements.
Quick answer: choose the workload first, then measure its peak memory. More VRAM gives headroom, but a 24GB card does not automatically make full training feasible.
| Task | Main memory consumers | What to establish before choosing a GPU |
|---|---|---|
| Inference | Loaded models, intermediate tensors, VAE decoding | Base only or base plus refiner; resolution; batch size; offloading |
| LoRA training | Frozen model, activations, adapter gradients and optimizer states | Trainer version, rank, trained modules, precision, checkpointing |
| Full fine-tuning | Trainable model, gradients, optimizer states and activations | Exact training recipe, offload/sharding support, validation peak |
The guidance below is a configuration checklist, not a benchmark or a tested minimum-VRAM certification.
SDXL Inference VRAM Usage
For inference (image generation only), resolution is one variable, not a complete specification. Holding the base model, refiner, ControlNet, and upscaler in VRAM together changes the peak substantially.
Hugging Face's SDXL inference documentation describes CPU model offloading for memory-constrained runs. That changes where weights live; it does not remove the system RAM and transfer-time costs.
On an existing 8GB or 12GB card, test a base-only, single-image workflow with the application's supported memory-saving options before assuming a hardware upgrade is required. Success with that workflow does not establish capacity for training or stacked models. See our RTX 3060 SDXL limits analysis.
SDXL LoRA Training VRAM Requirements
LoRA trains adapter weights rather than all model weights, but still needs the base model and training activations. Rank, text-encoder training, cached latents, and optimizer choice affect whether a run fits; the GPU label alone does not determine batch size.
At 768px
Lower resolution can reduce activation memory relative to the same recipe at 1024px. Start with a per-device batch size of one, record the trainer configuration, and measure a short run including validation. Do not assume that every 12GB card can run every 768px LoRA recipe.
At 1024px
Use the trainer's documented SDXL recipe. Check whether it supports mixed precision, gradient checkpointing, cached embeddings, or a memory-saving optimizer. A 24GB card provides more physical capacity than a 12GB card, but neither batch size nor stability follows from that capacity alone.
For the distinction between adapter training and full-model updates, see the official Diffusers LoRA guide. It covers several model families: a memory or runtime example for SD 1.5 must not be reused as an SDXL requirement.
Troubleshooting: Getting "CUDA out of memory" during training? See our complete fix guide.
When 12GB Fails
Memory pressure increases when:
- Resolution or batch size increases
- ControlNet or additional modules are stacked
- Training activations are retained without checkpointing
- Precision or optimizer settings allocate more memory than the tested recipe
The failure mode is usually:
CUDA out of memory errorIf these changes trigger OOM, the configured workload has exceeded the memory available at that stage. First identify whether it happens during model loading, training, validation, or VAE decoding; each points to a different intervention.
For workflow-level memory management techniques, see the ComfyUI memory optimization guide.
Full Fine-Tuning (Not LoRA)
Full fine-tuning updates many more parameters than LoRA. Budget separately for weights, gradients, optimizer state, and activations. Their byte sizes depend on precision and implementation, so a single multiplier is not a reliable total-memory estimate.
The official Diffusers SDXL training guide documents memory-saving settings for its training script. Use the requirements of the exact recipe you intend to run. Do not interpret a successful LoRA run on 24GB as evidence that full fine-tuning fits, or assume that 80GB removes all constraints.
This is where GPUs like RTX 4090, A100, or H100 become relevant. See RTX 4090 vs A100 vs H100 for a detailed comparison of training capabilities. For a deeper breakdown of the memory formula, optimizer impact, and GPU tier recommendations for SDXL fine-tuning specifically, see the SDXL fine-tuning VRAM guide.
Training Time and Cost Comparison
There is no reproducible training log behind the previous fixed-runtime comparison, so this review removes those timings and the resulting dollar-cost promises.
Estimate a run from measured seconds per step, planned steps, validation, checkpoint saving, and setup time. Then multiply billable hours by the deployment quote, adding storage and other applicable charges. Include retries when comparing cost per completed run.
For inference-heavy workflows, the economics shift further. See the full RTX 4090 cloud cost breakdown.
Calculate your own: Use our GPU cost calculator to estimate expenses for your specific workload.
When Cloud Makes Sense
Cloud can provide a different memory tier when local hardware is limiting the job:
- You're hitting OOM errors weekly and spending more time tuning than training
- Your measured workflow needs more memory than the local card can provide
- You only train occasionally — buying 24GB hardware for sporadic use rarely pays back
Cloud still has finite GPU memory, system RAM, disk, and bandwidth. SynpixCloud's default workflow uses SSH; check software setup requirements, the selected configuration, and stock on the GPU market before topping up.
Choosing the Right VRAM Tier
If you're:
- Using an existing 12GB card — Validate inference or a documented low-memory LoRA recipe first
- Considering 24GB — Compare measured peaks with the additional capacity, including validation
- Running experiments in parallel — Budget for concurrent allocations rather than one run
- Doing full model fine-tuning — Follow recipe-specific memory and sharding requirements
The key is not raw GPU brand. It's usable VRAM headroom.
A faster GPU with insufficient VRAM may require offloading or fail with OOM. Enough VRAM removes that particular constraint, not every possible failure. This is why choosing the right GPU starts with fit rather than TFLOPS alone.
Local vs Cloud Decision
| Scenario | Recommendation |
|---|---|
| Repeated workflow already verified locally | Keep local hardware if runtime is acceptable |
| Measured peak exceeds local capacity | Test a larger memory tier on the same workflow |
| Occasional full fine-tuning | Rent only after checking the trainer's requirements |
| Video generation workflows | Evaluate the video model separately from SDXL |
Many professionals use a hybrid approach: local 12GB for quick experiments, cloud for final training runs. See Cloud GPU vs Local GPU: Real Cost Analysis for the economics.
Decision framework: Should I buy a GPU or use cloud?
Advanced Workflows: Beyond Basic Training
SDXL + ControlNet
ControlNet introduces additional weights and intermediate tensors. Its peak depends on the implementation, resolution, and models kept resident. Measure the combined graph instead of adding fixed GB estimates from unrelated runs.
SDXL + Upscaling
Keeping SDXL and an upscaler resident together increases memory use. Where supported, run the stages sequentially and use tiled processing. Tile size, overlap, and model residency change the peak.
Video Generation (AnimateDiff, SVD)
Video pipelines have their own model, frame-count, resolution, and decoding constraints. An SDXL image-generation memory figure is not a video requirement. Consult the selected video pipeline's documentation and test the intended clip length before choosing hardware.
Memory Optimization Techniques
Use options supported by your application and measure each change; savings are not fixed across workflows:
Gradient checkpointing — Recomputes training activations instead of retaining all of them, trading computation for memory.
Mixed precision (fp16/bf16) — Can reduce some tensor allocations. Follow the trainer's supported precision settings; not every tensor or optimizer state uses the same dtype.
Memory-efficient attention — Use the backend supported by the installed PyTorch and application versions. There is no universal launch flag across tools.
Tiled VAE — Processes decoding in smaller regions where supported; it does not reduce every other stage's memory peak.
Model offloading — Moves model components to system RAM between uses, with transfer overhead that depends on the host and workflow.
System RAM, Storage, and Software Requirements
GPU VRAM and system RAM are separate resources. Offloading can shift the bottleneck to host memory; checkpoints, cached latents, and outputs also need disk space. Record the operating system, GPU driver, PyTorch/CUDA versions, application or trainer version, model, and workflow settings when reporting a requirement. Test loading, execution, validation, and saving—not only a successful first image.
Detailed setup: ComfyUI Memory Optimization Guide
GPU Recommendations by VRAM Tier
12GB — RTX 3060
If you already own this card, test the intended workload with supported memory-saving options before replacing it. See 12GB VRAM GPUs for Stable Diffusion.
24GB — RTX 3090 / RTX 4090
These cards provide more memory than a 12GB card, but have different power and compute characteristics. Validate the training recipe rather than assuming full fine-tuning fits. See 24GB VRAM GPUs for AI Art.
40GB+ — A100 / H100 (Cloud)
Larger-memory configurations are candidates when a measured workload does not fit a smaller card. Check GPU count and memory per GPU rather than treating aggregate multi-GPU VRAM as one memory pool.
Compare side-by-side: GPU comparison tool
Frequently Asked Questions
Is 12GB enough for SDXL 1024 training?
It depends on whether you mean LoRA or full fine-tuning and on the trainer settings. Use a documented recipe and validate the complete run, including validation. This guide does not certify a universal 12GB configuration.
Can I train SDXL on RTX 3060?
Check the trainer's SDXL support and memory-saving settings. A successful inference run on an RTX 3060 does not establish that a particular LoRA or full-training recipe fits.
Does gradient checkpointing reduce VRAM?
Yes, for supported training implementations. It recomputes activations during the backward pass instead of retaining all of them; measure the runtime trade-off on your configuration.
How much VRAM does SDXL use at 1024px?
Resolution alone is insufficient. Specify inference or training, batch size, loaded models, precision, and offloading. Measure the highest allocation across the entire workflow, including decoding or validation.
Final Takeaway
SDXL is not limited by CUDA cores first. It's limited by VRAM.
If you find yourself constantly reducing batch size or resolution to avoid crashes, you're hitting the memory ceiling — not a compute bottleneck. This distinction matters because a faster GPU with less VRAM won't solve the problem.
Choose a GPU with headroom above a verified workflow's peak, then compare completed-run time and total cost. For occasional heavier jobs, evaluate a hybrid local + cloud strategy.
Start with enough VRAM — and you'll spend more time training and less time debugging.
Content reviewed September 12, 2026: separated inference, LoRA, and full fine-tuning; removed unsupported memory, runtime, and cost guarantees.
