.ai

the best open source ai models

Guides

Rankings

FAQ

Upload

Running Stable Diffusion, SDXL and Flux on a Mac (Apple Silicon): Draw Things, ComfyUI and what to expect

Q: Black or grey images

fp16 precision overflow on MPS. Add --force-fp32 for that model, or use the SDXL fp16-fix VAE; in Draw Things switch the model to the 8-bit or fp32 variant.

Q: "MPS backend out of memory"

macOS GPU allocation limit reached before the RAM is full. Raise iogpu.wired_limit_mb, lower resolution, use quantised weights.

Q: A custom node fails to import

It depends on CUDA-only packages. Remove the node or find a Mac-compatible alternative; the core nodes all work.

Q: Very slow first generation in Draw Things

CoreML compilation of the model on first use. Wait once; subsequent runs are faster. Keep the model loaded between runs.

Q: Flux takes 10 minutes per image

Full-precision weights swapping, or an M1/M2 base chip. Use the 8-bit build at 20 steps, or run Flux on the cloud and SDXL locally.

Topic: Apps

By Captain

Published 2026-01-21

Overview

Apple Silicon Macs run image models through Metal (MPS in PyTorch, or Apple's own CoreML path in Draw Things). There is no CUDA, so the memory number that matters is the Mac's unified RAM, shared between the CPU and GPU: a 16 GB MacBook Air can run

SDXL

, a 32 GB machine can run

Flux

in fp8 and small video models, a 64 or 128 GB Mac Studio can load almost anything, slowly. Speed is the trade: an M2 Max takes 30 to 60 seconds for an SDXL image that an RTX 4070 does in 6.

Three tools matter. Draw Things is a free native app (Mac, iPhone, iPad) with a model library,

LoRA

import,

ControlNet

inpainting

and the best Mac performance because it converts models to CoreML; it is the right first choice for most Mac users.

ComfyUI

runs on Mac from source with PyTorch MPS; it supports everything ComfyUI supports, with some nodes needing fp32 and some custom nodes failing on non-CUDA hardware. DiffusionBee is the simplest one-click app, limited to older models.

Because speed is the bottleneck, Mac users lean on the cloud more than PC users: generate drafts on the cloud partners, bring the keepers to Draw Things for inpainting and personal LoRAs, or simply do everything heavy (Flux at full precision, video) on

PirateDiffusion

BitVector

and keep the Mac for browsing this site and editing.

Reference

Name	Type	What it is
8 GB Mac	SD 1.5 only	Draw Things with SD 1.5 fine-tunes at 512x768; SDXL swaps and crawls.
16 GB Mac	SD 1.5 , SDXL	SDXL at 1024x1024 in Draw Things (CoreML 8-bit) or ComfyUI with --force-fp16; Flux via Draw Things 8-bit works but slowly.
32 GB Mac	adds Flux fp8, Z-Image , small Wan	Flux dev 8-bit at 1024 in 1 to 3 minutes on M2/M3 Pro-Max; Wan 2.2 5B short clips.
64-128 GB Mac Studio / MacBook Pro Max	adds FLUX.2 , Qwen Image , Wan 14B	Fits in memory; expect 5 to 15 minutes per Flux.2 image and tens of minutes per video clip.
Draw Things	app	Free, App Store. Model manager, LoRA/ControlNet import, inpainting, upscalers , scripts. CoreML speeds up repeated runs after a first compile.
ComfyUI on MPS	from source	Python 3.12, PyTorch nightly or stable with MPS. Flags: --force-fp16 (M1/M2) or default; --use-split-cross-attention helps memory.
DiffusionBee	app	One-click, SD 1.5/SDXL, limited settings. Fine for a first try.
iogpu.wired_limit_mb	sysctl	Raises the memory macOS lets the GPU allocate (default ~70 percent of RAM). Set to RAM minus 8 GB for large models.

Flux at full speed from your Mac

BitVector Prism runs in Safari: the Flux, FLUX.2 and Qwen models that crawl on Apple Silicon render in seconds on its GPUs. Keep the Mac for Draw Things and editing; send the heavy prompts here.

Try BitVector

Step by step

Check your chip and memory: Apple menu > About This Mac. Find your tier in the table.
Install Draw Things from the App Store. Open it, pick a model from its library (SDXL base or DreamShaper XL for a 16 GB Mac), let it download and convert.
Generate a first image at 1024x1024, 20 steps, DPM++ 2M Karras,
CFG
6. The first run compiles the CoreML model and is slow; later runs are faster.
Import a LoRA from this site: Models > LoRA > Import, choose the .safetensors; Draw Things converts it. Add the trigger word to the prompt.
For ComfyUI: install Homebrew, Python 3.12 and git; git clone ComfyUI; pip install -r requirements.txt with the MPS-enabled PyTorch; run python main.py; load the default workflow as the ComfyUI beginner guide describes.
In ComfyUI on a 16 GB Mac add --force-fp16 and keep batch size 1; use VAE Decode (Tiled) for sizes above 1024.
For Flux on a 32 GB+ Mac use the fp8 or GGUF Q8 build, the fp8 T5 encoder and expect minutes per image; raise the wired limit if you see memory errors.
Keep heavy jobs for the cloud: open any model page, press the PirateDiffusion or BitVector button and run the same prompt there in seconds.

Examples

ComfyUI start commands on Mac

brew install python@3.12 git

git clone https://github.com/comfyanonymous/ComfyUI && cd ComfyUI && pip3 install -r requirements.txt

python3 main.py --force-fp16 --use-split-cross-attention

Raising the GPU memory limit (64 GB Mac)

sudo sysctl iogpu.wired_limit_mb=57344

Same prompt on the cloud from the Mac

/render <flux-dev> a quiet harbour at dawn, fishing boats, mist, 35mm film look /size:1216x832 /steps:24

Tips

Draw Things on an iPhone 15 Pro or newer runs SD 1.5 and small SDXL variants locally; useful for travel, not for volume.
Black or blank images on MPS are almost always fp16 overflow: use --force-fp32 for that model or the fp16-fix SDXL VAE.
Close memory-hungry apps (browsers with many tabs) before generating; unified memory means Safari and the model compete.
Draw Things supports many ComfyUI-era models (Flux,
Z-Image
,
Qwen Image
,
Wan
) earlier than people expect; check its model list before building a ComfyUI setup.
Custom nodes that import CUDA-only libraries (xformers, some face tools) fail on Mac; the ComfyUI node guide marks the common ones.
Benchmarks to set expectations: SDXL 1024x1024, 25 steps: M1 Pro 90-120 s, M2 Max 35-50 s, M3 Max 25-35 s, M4 Max 18-25 s.

Use the 8-bit build at 20 steps, or run Flux on the cloud and SDXL locally.

Video from a MacBook Air

PirateDiffusion generates Wan 2.2, LTX-2 and H3 clips on its servers and delivers them to Telegram on your Mac or iPhone. Thousands of models, unlimited renders, a fixed monthly price.

Try PirateDiffusion

Questions

Should I buy a Mac for AI images?

Buy a Mac for other reasons and enjoy that it can do SDXL; buy an NVIDIA PC if AI images or video are the main purpose. Unified memory capacity is great, speed is not.