ComfyUI on a 12GB RTX 3060: Install + Stable Diffusion Throughput 2026

ComfyUI runs well on a 12GB RTX 3060 for the price tier — SDXL at 1024×1024 fits comfortably in VRAM, SD1.5 flies, and Flux workflows work with a bit of offloading. Install takes about 20 minutes: grab the portable Windows build from the official repo, unzip, drop a checkpoint into models/checkpoints/, and run run_nvidia_gpu.bat. On Linux, git clone, install the CUDA-matched PyTorch wheel, pip install -r requirements.txt, and python main.py. The rest of this article walks the fast path, benchmarks the numbers, and shows you exactly where the 12GB budget cracks.

Why a 12GB card is the practical entry point for local ComfyUI

The RTX 3060 12GB is the cheapest currently-produced GeForce card with enough VRAM to load SDXL end-to-end without constant offload thrash. That single fact is what keeps it relevant nearly five years after launch. 8GB cards can technically run SDXL, but every workflow becomes a tuning exercise: tiled VAE, model CPU-offload, lower resolutions, tiny batches. On the 3060 12GB, most SDXL work runs at defaults, and Flux workflows are tractable rather than punishing.

Compared to the current-gen RTX 4060 8GB, the 3060 12GB gives up compute and gains 4GB of headroom. For gaming that trade is a wash. For local image generation it is decisive: image models are memory-bound, not compute-bound, on consumer cards. Running out of VRAM does not slow you down 20% — it either forces offload (5–10× slowdown) or crashes the node. The 3060 12GB stays out of that trap for the workflows most people actually run.

As of 2026, MSI's Ventus 3X 12G OC (B08WRP83LN) is the sweet-spot pairing: three-fan cooler, no coil whine complaints in recent listings, and 12GB GDDR6 on a 192-bit bus giving 360 GB/s memory bandwidth. That bandwidth number is the ceiling on SDXL sampling speed for this card. You cannot buy your way past it without moving to a card with more or faster VRAM, so it sets the baseline for every benchmark below.

If you already own a 3060 12GB, this article confirms you have a working ComfyUI machine and shows you how to squeeze it. If you are shopping, you now know why 12GB matters more than the die generation on the sticker.

Key takeaways

• SDXL at 1024×1024, batch size 1, standard workflow: ~7.2 s/image on the 3060 12GB after warm cache. VRAM peak: ~9.4 GB.
• SD1.5 at 512×512, batch 4, DPM++ 2M Karras 20 steps: ~1.4 s/image. VRAM peak: ~5.1 GB.
• Flux.1-dev in fp8 with model offload: ~28 s/image at 1024×1024. VRAM peak: ~11.8 GB (right at the ceiling).
• Install path is deterministic: portable build on Windows, venv on Linux. CUDA mismatch is the top failure — pin PyTorch to the version that matches your driver's CUDA runtime.
• CPU host matters for load times, not sampling. A Ryzen 7 5800X cuts SDXL model-load from ~14 s to ~6 s vs a slow chipset SATA SSD.
• Storage matters too: putting your checkpoints on an NVMe SSD like the WD_BLACK SN770 shaves another 3–4 seconds off cold loads for large SDXL models.

What you'll need

Before you clone anything, gather the following. Anything missing here becomes a "why doesn't this work" thread on Reddit later.

Hardware:

• RTX 3060 12GB (not the 8GB variant — the 8GB card is a different SKU and will bottleneck SDXL and Flux)
• A capable CPU host. Ryzen 5 3600 or better; we tested on a Ryzen 7 5800X
• 32GB system RAM (16GB works but Flux fp8 offload will pressure it)
• NVMe SSD for models/ — WD_BLACK SN770 or equivalent
• 750W or better PSU (the 3060 pulls up to ~170W under sustained sampling)

Software:

• Windows 11 22H2+ or a modern Linux distro (Ubuntu 22.04/24.04, Arch, Fedora 40+)
• NVIDIA driver 550.x or newer (2026-era drivers ship CUDA 12.4 runtime by default)
• Python 3.10, 3.11, or 3.12. Skip 3.13 — several custom nodes still lag on wheels
• Git (for clone-install path)
• A checkpoint file. Start with SDXL Base 1.0 from Hugging Face for a known-good baseline

Model files to grab first:

• sd_xl_base_1.0.safetensors (~6.9 GB) — the canonical SDXL baseline
• v1-5-pruned-emaonly.safetensors (~4.3 GB) — SD1.5 for fast iteration
• A VAE if your workflow needs one — sdxl_vae.safetensors (~335 MB)

Everything else can wait until your first workflow runs end-to-end.

Step-by-step install (Windows and Linux fast path)

Windows (portable build, 10 minutes)

The portable build is unambiguously the right answer on Windows. It bundles Python and torch, so a CUDA-runtime mismatch is impossible.

1. Download the latest portable release from the ComfyUI GitHub releases page. Look for ComfyUI_windows_portable_nvidia.7z.
2. Extract with 7-Zip. Do not extract into C:\Program Files\ or any path containing spaces. Use C:\AI\ComfyUI\ or similar.
3. Drop your SDXL and SD1.5 .safetensors files into ComfyUI\models\checkpoints\.
4. If you have a separate VAE, drop it into ComfyUI\models\vae\.
5. Double-click run_nvidia_gpu.bat. A terminal opens; when you see To see the GUI go to: http://127.0.0.1:8188, open that URL.
6. On first run, the default workflow appears. Click Queue Prompt. If you get an image, you are done.

If step 6 errors with CUDA out of memory on the default workflow, your driver is fine — the default resolution just pushed too high. Drop the resolution to 512×512 and retry.

Linux (clone + venv, 15 minutes)

1. Install prerequisites: sudo apt install python3.11 python3.11-venv git (adjust for your distro).
2. git clone https://github.com/comfyanonymous/ComfyUI.git && cd ComfyUI
3. python3.11 -m venv venv && source venv/bin/activate
4. Install the PyTorch build matched to your CUDA runtime. Check nvidia-smi top-right for the CUDA version, then use the pip URL from pytorch.org. For CUDA 12.4: pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
5. pip install -r requirements.txt
6. Drop your checkpoints into models/checkpoints/.
7. python main.py --listen 127.0.0.1 and open http://127.0.0.1:8188.

If sampling is CPU-slow (multiple minutes per image), torch is installed but not seeing CUDA. python -c "import torch; print(torch.cuda.is_available())" should print True. If it prints False, your torch wheel is CPU-only — reinstall from the CUDA index URL above.

Spec-delta: what fits in 12GB and what forces offload

The table below reflects real workflow VRAM peaks measured with nvidia-smi dmon while sampling. "Fits clean" = under 11GB peak with default nodes. "Fits with offload" = requires --lowvram or model CPU-offload. "Doesn't fit" = crashes or unusable speed.

The pattern: everything up to SDXL with one small ControlNet is comfortable. Everything Flux is on the edge. Anything requiring loading two large models simultaneously (base + refiner in parallel, SDXL + big ControlNet, training) requires offload tricks and slows down a lot.

VRAM budgeting on a 3060 12GB

Three levers move VRAM consumption up or down. Learn them, and most out-of-memory errors go away.

Batch size is linear. If a batch-1 SDXL run peaks at 9.4 GB, a batch-2 run peaks near 11 GB. On this card, batch 1 is the safe default for SDXL and batch 4 is the safe default for SD1.5. Push higher only when you know the exact ceiling for your workflow.

Resolution is worse than linear because the latents and attention maps scale with area. Going from 1024×1024 to 1536×1536 more than doubles VRAM. On a 3060 12GB, 1024×1024 is the sweet spot for SDXL. 1152×896 or 896×1152 (SDXL's trained aspect ratios) also fit comfortably. Above that, add tiled VAE or accept offload.

Model choice dwarfs the other two. SD1.5 leaves 7GB of headroom. SDXL leaves 2.5GB. Flux fp8 leaves ~0.2GB. Pick the smallest model that gets the aesthetic you want. Many production workflows still use SD1.5 with a strong LoRA precisely because the headroom lets you stack ControlNet, IPAdapter, and Reactor without touching offload.

Node choice matters at the margin. Use ComfyUI's built-in VAE Decode (Tiled) when you need 1536×1536 or larger. Use Load Diffusion Model with weight_dtype=fp8_e4m3fn for Flux instead of the default fp16 loader. Prefer nodes that stream weights rather than duplicating them.

Benchmark: iterations/sec and s/image on a 3060 12GB

Measured on a 3060 12GB, Ryzen 7 5800X, 32 GB DDR4-3600, ComfyUI June 2026 build, NVIDIA driver 555.xx, Windows 11 24H2. All numbers are steady-state after cache warmup — first-run numbers are 2–3× slower due to CUDA kernel compilation and model load.

Two things stand out. SDXL Turbo at 1.6 s/image is genuinely fast — you can iterate on prompts as fast as you can type. And Flux.1-dev at 28 s/image is the "productivity floor" — usable for one-off finals, painful for exploration.

For reference, a Ryzen AI Max+ 395 with unified memory sits between these tiers on Flux — slower per-image than a 3060 12GB on SDXL but able to hold larger models without offload. See our full comparison of the Strix Halo APU vs the RTX 3060 12GB for local LLM and diffusion work for the tradeoff analysis.

Model load time vs sampling time — where the CPU actually helps

Model load is disk-bound and CPU-bound. Sampling is GPU-bound. Confusing the two leads to bad upgrade decisions.

Cold-start SDXL load times on the same 3060 12GB, changing only the host:

The GPU sampling time in all four cases is identical. The CPU and storage only affect how quickly weights move from disk to VRAM. If you swap workflows constantly (SDXL → SD1.5 → LoRA A → LoRA B), a fast NVMe like the WD_BLACK SN770 and a modern CPU pay off. If you stay in one workflow all day, they do not.

Warm reload — reusing an already-loaded model — is essentially free on any host because ComfyUI keeps the model in VRAM between queues. That is why the "load once, queue 40 prompts" pattern is so much faster than "queue one prompt, close ComfyUI, restart".

Common gotchas

CUDA version mismatch. By far the most common. Symptom: torch installs, but torch.cuda.is_available() returns False, or sampling is CPU-slow. Fix: reinstall torch from the CUDA index URL matching your driver's CUDA runtime. On modern NVIDIA drivers (550+), pip install torch --index-url https://download.pytorch.org/whl/cu124 is right. If you skip the --index-url, you get the CPU-only wheel from PyPI.

Custom node install failures. ComfyUI Manager makes this look easy until a node has a native extension. Symptom: pip install errors mentioning cl.exe (Windows) or gcc (Linux). Fix on Windows: install Visual Studio Build Tools with the C++ workload. Fix on Linux: sudo apt install build-essential python3.11-dev.

Out-of-memory mid-workflow. Symptom: torch.cuda.OutOfMemoryError after several queues. Cause: a previous node held VRAM you thought was freed. Fix: add a Free Memory node between heavy stages, or restart the workflow between very different workloads. --lowvram at launch is the sledgehammer if this keeps happening.

Model download stalls at 99%. Hugging Face throttles anonymous downloads on large files. Fix: create an HF token, huggingface-cli login, then re-download. Or use --resume-download in huggingface_hub calls.

Nodes silently ignore GPU. Symptom: sampling is slow even though nvidia-smi shows the GPU idle. Cause: a node forced CPU mode (usually a text-encoder loader with device="cpu"). Fix: check node parameters in the workflow JSON — anything with an explicit device override.

Wrong PyTorch on Windows portable. The portable build ships its own Python and torch. Do not pip install new torch into it — you will break it. Custom nodes should install into ComfyUI\python_embeded\Scripts\pip.exe, not your system pip.

When the 3060 12GB is enough — and when to upgrade

Stay on a 3060 12GB if:

• Your main workflows are SDXL, SD1.5, and SDXL Turbo
• You accept ~7 s/image for SDXL and don't need sub-second exploration
• You aren't training LoRAs (or you accept using a cloud runner for training)
• You want the lowest-cost path to real local diffusion

Upgrade if:

• You live in Flux.1-dev and 28 s/image is unbearable
• You want to run SDXL and Flux comfortably side-by-side (need 16GB+)
• You want to train LoRAs on-device (need 16GB+ with --gradient_checkpointing)
• You want to combine SDXL with heavy ControlNet + IPAdapter + FaceID stacks

The natural upgrade targets in 2026 are the RTX 4070 Ti Super (16GB), RTX 5070 Ti (16GB), and — if budget allows — a used RTX 3090 (24GB). The 3090 remains the value pick for VRAM-hungry workflows because $700–$900 used gets you 24GB and beats a 4070 Ti Super on Flux by a wide margin. See our Qwen 3.8 open-weights sizing on the same 3060 12GB if you're also considering local LLM work on this card.

Verdict matrix

Run ComfyUI on a 3060 12GB if: you're new to local diffusion, you want to learn without spending $700+ on a GPU, your primary output is SDXL or SD1.5, and Flux is a "nice to have" rather than the main use case.

Upgrade to 16–24 GB if: Flux.1-dev is your daily driver, you're stacking multiple heavy conditioning models, you want to run diffusion and local LLMs simultaneously, or you want to train LoRAs on-device.

Skip the 3060 8GB entirely: the same die with 4GB less VRAM cannot run SDXL cleanly. If a 3060 is your budget ceiling, the 12GB variant is not a "nice upgrade" — it is the only version worth buying for this use case.

Bottom line

The RTX 3060 12GB, paired with a modern host and an NVMe SSD, is a legitimate local-diffusion machine in 2026. SDXL at ~7 s/image, SD1.5 at ~1.4 s/image, and Flux at ~28 s/image cover the vast majority of hobbyist and prosumer workflows without offload gymnastics. Install is a 15-minute exercise if you follow the portable-build path on Windows or match your PyTorch wheel to your CUDA runtime on Linux. The gotchas are well-known and the community documentation is mature. If you already own the card, ComfyUI works. If you're shopping for the cheapest working entry point to local image generation, a MSI RTX 3060 12GB on a Ryzen 7 5800X with a WD_BLACK SN770 NVMe is a build that will still be relevant in 2028.

Related guides

• RTX 3060 12GB vs RTX 4060 for 1080p Gaming: The VRAM Question
• llama.cpp Vulkan vs CUDA on a 12GB RTX 3060: Which Backend Wins?
• Qwen 3.8 Open Weights on a 12 GB RTX 3060: What Actually Fits
• Strix Halo vs RTX 3060 12GB: Unified Memory or Discrete VRAM?

Citations and sources

• ComfyUI — official GitHub repository — the canonical source for release binaries, workflow examples, and node reference documentation.
• TechPowerUp GPU Database — GeForce RTX 3060 — memory bus, bandwidth, TGP, and die-level specifications used in the bandwidth ceiling analysis above.
• NVIDIA CUDA Toolkit — CUDA runtime and driver compatibility reference used to pin the PyTorch install to a matching CUDA build.