Running FLUX AI Image Generation Locally on a MacBook Pro M4 Max
← Back to Home

Essay

Running FLUX AI Image Generation Locally on a MacBook Pro M4 Max

A practical, no-fluff guide to installing and running the FLUX image model entirely on-device on Apple Silicon. Covers ComfyUI, DrawThings and Diffusers, memory budgets on the 36 GB and 128 GB M4 Max, prompt tricks and typical generation times.

Lei Xia · 6 min read

Why bother running it on your own laptop

Remote image APIs are cheap and fast, so why go through the trouble of running an image model locally on a MacBook Pro M4 Max? Three reasons keep coming up in my day-to-day work:

  • Privacy. Nothing about the prompt, the reference image or the output ever leaves the machine. If you are doing early product design, client mockups or anything under an NDA, that alone is worth the setup.
  • Iteration speed. Once the model is warm, an M4 Max can push out a 1024x1024 image in seconds, with zero rate limits and no per-image cost. You can burn 400 generations testing a prompt idea and it costs you nothing but battery.
  • Learning. Understanding what actually happens when a diffusion model runs on the Neural Engine, the GPU and the CPU is the fastest way to stop treating these models as magic.

A quick note on the name: there is no image model called "Fury AI". The model that is on everyone's laptop this year is FLUX from Black Forest Labs — most likely what you were asking about. Everything below targets FLUX.1, but the same setup works for SDXL, Stable Diffusion 3.5, Qwen-Image and the newer FLUX.2 previews.

What the M4 Max actually gives you

The M4 Max is the sweet spot for local image generation on macOS. It matters because diffusion models are memory-hungry, not just compute-hungry.

  • GPU: up to 40 cores with hardware ray tracing and a much wider memory pipe than the M3 Max. Around 546 GB/s of unified memory bandwidth on the top bin.
  • Unified memory: 36 GB, 48 GB, 64 GB or 128 GB. All of it is addressable by the GPU. On an Nvidia rig, the equivalent number is your VRAM, and 24 GB of VRAM is a very expensive card.
  • Neural Engine: 16 cores, useful for some CoreML-converted models but not the main path for FLUX today.

Rule of thumb for FLUX.1 on Apple Silicon:

  • 36 GB M4 Max: run FLUX.1-schnell (4-step, fp8 or int4) comfortably; FLUX.1-dev in fp8 with the CPU used as an overflow, expect longer times.
  • 48 GB and up: FLUX.1-dev in fp8 or bf16 fits without swapping and gives the best quality/speed balance.
  • 64 GB / 128 GB: you can keep the model, a LoRA stack, a ControlNet and a VAE all resident at once, and generate 2048x2048 or short video with Wan/Hunyuan without the fan even spinning up.

The three paths, in order of least to most fiddly

There are three sensible ways to run a local image model on an M4 Max. Pick one based on what you actually want to do.

1. Draw Things — zero-config, App Store

If you just want to generate images tonight without touching a terminal, install Draw Things from the Mac App Store. It is a native Metal-optimised app maintained by liuliu, it downloads FLUX / SDXL / SD3.5 checkpoints for you, and it is genuinely fast on M-series.

  • Open Draw Things, go to Models, download FLUX.1 [schnell] (fastest) or FLUX.1 [dev] (higher quality, slower, non-commercial licence).
  • Set the sampler to Euler A for schnell (4 steps) or DPM++ 2M for dev (20–28 steps).
  • Resolution: start at 1024x1024. The M4 Max handles 1536x1536 without complaint.

Use this if you want a great UI, LoRA support, inpainting, and no configuration.

2. ComfyUI — the node-based standard

If you want the same workflows the rest of the internet is sharing, install ComfyUI. It is a node graph editor for diffusion pipelines and it runs natively on Apple Silicon through PyTorch MPS.

bash
# Prereqs: Xcode Command Line Tools + Homebrew + Python 3.11
brew install python@3.11 git git-lfs
git lfs install

# Clone and set up ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
python3.11 -m venv .venv
source .venv/bin/activate

# PyTorch nightly gives the best MPS performance right now
pip install --pre torch torchvision torchaudio \\
  --index-url https://download.pytorch.org/whl/nightly/cpu
pip install -r requirements.txt

# Download FLUX.1 [schnell] (Apache 2.0, commercial-friendly)
mkdir -p models/unet models/vae models/clip
huggingface-cli download black-forest-labs/FLUX.1-schnell \\
  flux1-schnell.safetensors --local-dir models/unet
huggingface-cli download black-forest-labs/FLUX.1-schnell \\
  ae.safetensors --local-dir models/vae
huggingface-cli download comfyanonymous/flux_text_encoders \\
  clip_l.safetensors t5xxl_fp8_e4m3fn.safetensors --local-dir models/clip

# Launch — MPS is picked automatically on Apple Silicon
python main.py --force-fp16

Then open http://127.0.0.1:8188 in your browser, drag in the official FLUX workflow JSON from the Comfy examples repo, and hit Queue Prompt. First run compiles kernels and downloads the T5 encoder; expect ~90 seconds cold. Warm runs on FLUX.1-schnell at 1024x1024 land around 8–14 seconds per image on an M4 Max 40-core / 48 GB.

Tips that matter on Apple Silicon:

  • Use the fp8 version of the T5 text encoder (t5xxl_fp8_e4m3fn.safetensors), not the fp16 one, unless you are on 64 GB or more. It cuts encoder memory in half with no visible quality loss.
  • Set PYTORCH_ENABLE_MPS_FALLBACK=1 in your shell so any operator not yet on MPS quietly runs on CPU instead of crashing.
  • The first generation after every model swap is slow because Metal kernels are being compiled. Keep the same checkpoint loaded and iterate on prompts.

3. Diffusers + MLX — the scriptable path

When you want to embed image generation in your own tool, drive it from Python. Hugging Face Diffusers works on MPS out of the box, and Apple's MLX framework has a mlx-flux port that squeezes even more performance out of the Neural Engine and GPU together.

python
# pip install --upgrade diffusers transformers accelerate safetensors
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16,
)
pipe.enable_attention_slicing()
pipe.to("mps")

image = pipe(
    prompt="a serene mountain lake at sunrise, cinematic, 35mm film",
    guidance_scale=0.0,          # schnell wants 0.0
    num_inference_steps=4,       # schnell is a 4-step model
    max_sequence_length=256,
).images[0]

image.save("out.png")

If you want the absolute fastest inference and are comfortable with a fresh framework, look at mlx-flux and mflux on GitHub. Both compile FLUX into MLX-native graphs and, on the same 48 GB M4 Max, cut FLUX.1-schnell down to around 5–7 seconds per 1024x1024 image.

Prompting FLUX so you actually get what you want

FLUX is a different beast to SDXL. Two habits will save you a lot of frustration:

  1. Write full sentences, not tag soup. FLUX uses the T5 text encoder, which understands language, not danbooru tags. A close-up portrait of an elderly Chinese fisherman at dawn, weathered hands mending a net, soft golden light beats chinese, old man, fisherman, morning, portrait, cinematic, hands, net, 4k.
  2. Keep CFG low. For FLUX.1-schnell use guidance_scale=0.0. For FLUX.1-dev, 3.5 is the default sweet spot. Cranking it up like you would on SDXL just fries the image.

Text inside images is FLUX's party trick — it can actually render short strings of readable text. If you need paragraphs of legible text, jump to Qwen-Image, which was purpose-built for that.

Realistic performance numbers on M4 Max

On a 14" M4 Max with 40 GPU cores and 48 GB unified memory, running macOS 15:

  • Draw Things, FLUX.1-schnell, 1024x1024, 4 steps: 6–9 seconds per image warm.
  • ComfyUI, FLUX.1-schnell fp8, 1024x1024, 4 steps: 8–14 seconds per image warm.
  • ComfyUI, FLUX.1-dev fp8, 1024x1024, 20 steps: 45–70 seconds per image.
  • Diffusers on MPS, FLUX.1-schnell bf16, 1024x1024, 4 steps: 12–18 seconds per image.
  • mflux (MLX), FLUX.1-schnell, 1024x1024, 4 steps: 5–7 seconds per image.

Memory pressure is the thing to watch. If your unified memory sits at 90%+ and you see the Activity Monitor "swap used" number climb, drop to fp8 weights, reduce resolution, or upgrade the memory tier on your next machine.

Where I actually land in daily use

For concept work and client sketches I keep Draw Things open on one desktop and ComfyUI on another. Draw Things wins for the first fifty explorations of a prompt — it is faster to iterate on because the UI is a proper Mac app. When I have found the composition I want, I flip to ComfyUI to lock in a LoRA, add a ControlNet, and produce the final variants. Whenever the pipeline needs to be automated — for example, generating hero images for blog posts inside a bigger tool — I reach for Diffusers or mflux and script it.

The M4 Max is the first Apple laptop where none of this feels like a compromise. If you have been paying OpenAI or Midjourney for images that never leave the cloud, this is the year to run the model yourself.

More Articles