Intel Arc Pro B60 for Stable Diffusion: SDXL, Flux.1, and ControlNet on 24 GB ECC

Can the Intel Arc Pro B60 Run Stable Diffusion?

Yes — fully, at production quality. The Intel Arc Pro B60 runs Stable Diffusion 1.5, SDXL, and Flux.1 (Schnell, Dev) through Intel’s IPEX-XPU PyTorch backend and the OpenVINO inference runtime. Both Automatic1111 and ComfyUI support Intel Arc in 2026, and the B60’s 24 GB ECC GDDR6 gives you more VRAM than almost any other card at this price.

The one constraint: Intel Arc doesn’t support CUDA. Libraries that depend on CUDA-specific kernels — xformers attention, some AnimateDiff temporal kernels, TensorRT acceleration — won’t run. Everything built on standard PyTorch operations works fine. For image generation specifically, that covers SD 1.5, SDXL, Flux.1, ControlNet, IP-Adapter, and LoRA workflows without any compromises.

For a ready-to-go environment, see Stable Diffusion hosting. To compare all options across budget and VRAM, see best GPU for Stable Diffusion.

VRAM Math for SD 1.5, SDXL, and Flux

For a detailed VRAM breakdown by model and resolution, see Stable Diffusion VRAM requirements.

Automatic1111 Setup on Arc Pro B60

Automatic1111’s WebUI supports Intel Arc through the IPEX backend. On a fresh GigaGPU Arc Pro B60 server — Intel GPU drivers and oneAPI Base Toolkit are pre-installed:

# Install Intel XPU PyTorch wheel
pip install torch torchvision torchaudio \
  --index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
pip install intel-extension-for-pytorch

# Clone Automatic1111
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui
cd stable-diffusion-webui

# Launch with Intel Arc flags
TORCH_DEVICE=xpu ./webui.sh --use-ipex --opt-sdp-attention --listen

The --opt-sdp-attention flag enables PyTorch’s scaled dot-product attention, which maps well to the B60’s XMX matrix engines and gives meaningful throughput improvement over the default attention path. Skip --xformers — it’s NVIDIA-only and the --use-ipex path is faster on Intel Arc anyway.

Drop SDXL or SD 1.5 checkpoints into models/Stable-diffusion/ and ControlNet preprocessor models into extensions/sd-webui-controlnet/models/ as normal.

ComfyUI Setup on Arc Pro B60

ComfyUI offers two Intel Arc paths: IPEX-XPU (broader node support) and OpenVINO (better throughput on Flux.1).

IPEX-XPU (recommended starting point):

git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install torch torchvision torchaudio \
  --index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
pip install intel-extension-for-pytorch
pip install -r requirements.txt
python main.py --use-xpu --listen 0.0.0.0 --port 8188

OpenVINO node (for Flux.1 or maximum efficiency):

cd custom_nodes
git clone https://github.com/openvinotoolkit/ComfyUI-OpenVINO
cd ComfyUI-OpenVINO && pip install -r requirements.txt

With the OpenVINO node active, ComfyUI converts your checkpoint to OpenVINO IR on first run (~2 minutes, then cached). See the full ComfyUI on B60 setup guide for a detailed walkthrough.

Flux.1: The B60’s Strongest Workload

Flux.1 Dev is where the B60 most clearly beats cards with less VRAM. The full FP16 pipeline components:

• Flux transformer (12B params): ~12 GB
• T5-XXL text encoder: ~5 GB
• CLIP-L encoder: ~0.5 GB
• VAE: ~0.3 GB
• Working memory (attention activations, 1024×1024): ~6 GB

Total: ~24 GB — right at the B60’s ceiling. The recommended production path for Flux.1 Dev on the B60 is Q4 GGUF via the GGUF loader: the transformer compresses to ~7 GB, reducing total pipeline memory to ~13 GB and leaving 11 GB of working headroom. Generation speed improves too — the XMX engines handle INT4 matrix ops efficiently.

Flux.1 Schnell is the easier choice at 24 GB: the 4-step model’s total FP16 footprint is ~14 GB, leaving 10 GB of headroom. No GGUF required.

ControlNet and IP-Adapter Stacking

The B60’s 24 GB makes it one of the most capable cards for ControlNet stacking at this price:

• Single ControlNet (any preprocessor): adds ~2–3 GB; the B60 handles it with 13 GB to spare on top of SDXL.
• Double ControlNet (e.g. depth + canny): ~5 GB total addon; still comfortable at 24 GB.
• IP-Adapter (standard): ~1 GB; trivial addition.
• IP-Adapter Plus (ViT-H): ~2 GB; fits with double ControlNet simultaneously on 24 GB — something 16 GB cards can’t do.

For ControlNet preprocessor models (depth estimation, OpenPose, etc.) that run on CPU, the B60’s host AMD Ryzen 7/9 with up to 128 GB DDR5 handles preprocessing without impacting GPU memory.

LoRA Stacking

LoRA adapters are small — typically 0.1–0.3 GB each depending on rank and base model. On SDXL (8 GB base VRAM), the B60 can hold:

• 6–8 LoRAs simultaneously without any swapping
• Style, character, and concept LoRAs all resident at the same time
• Mixed SDXL + ControlNet + 4 LoRAs: ~14 GB total — well within 24 GB

Compared to 16 GB cards (RTX 5080 at £189/mo), the B60’s 24 GB gives you 8 extra GB for LoRA stacks and ControlNet combinations — at £60/mo less.

Generation Speed Estimates

Speed estimates are based on Battlemage Xe2 compute specs and available IPEX-LLM benchmarks. Actual performance varies with scheduler, sampler, and exact model weights. The OpenVINO path for Flux.1 may improve as Intel releases updated XPU-optimised kernels throughout 2026.

B60 vs RTX 3090 for Stable Diffusion

The RTX 3090 is ~20–25% faster per image on SD 1.5 and SDXL — its 936 GB/s bandwidth (vs 456 GB/s on the B60) pays off in the VAE decode step and attention cache reads. For users who need maximum image throughput, the 3090 is worth the £30/mo premium. For users whose bottleneck is VRAM capacity (ControlNet stacking, Flux.1 Dev, running image gen alongside other models), the B60 delivers the same capability at lower cost. See the full B60 vs RTX 3090 comparison.