Flux + ComfyUI on Apple Silicon with Hardware Acceleration — 2025

Generated with the Q6 K GGUF variant of the Flux.1 Dev model using an improved CLIP-L text encoder

Flux.1 plus ComfyUI make a great combination for generating AI art yourself. ComfyUI is powerful, but also **straightforward to setup, and you don’t need to be a developer to use it**.

When I wrote the 2024 edition of this article, Flux.1 was new, and not very well understood. In that article I focus of dispelling some of the myths around running Flux.1 on Apple silicon, and highlighting the trade-offs with the different scheduler nodes.

I briefly cover some of those myths again in this edition, but the majority of this article is focused on helping folks figure out which combination of Flux.1 model, text encoders, and caching are right for their Mac.

Q: Can Flux.1 Run on Apple Silicon?

Yes. The hero image for this article was produced on an M1 Max MacBook Pro with 32GB of shared memory.

You can run both the Flux.1 Dev or Flux.1 Schnell models on Apple Silicon. Dev is a distilled model for non-commercial applications. Schnell is an open source model that can generate images more quickly, but at a lower quality.

Which version you can use depends on your Mac hardware.

Flux.1 is memory hungry beast. If you want to generate images whilst using your Mac for other things, then you’ll need at least 24GB of memory. If you’re only using your Mac for generating images then you can get good results with just 16GB.

Macs with a Max chip offer the best performance. The Max chip has more GPU cores than the the equivalent regular chip, which means more GPU cores are available for image generation.

You’ll also need at least 30GB of storage free.

Q: Does ComfyUI Need to Run in CPU Only Mode?

No. When Flux.1 was release last year there were quite a few posts where folks said they had to run ComfyUI in CPU only mode using the --cpu flag.

Reading back, it appears advice appears to have come from folks who weren’t being able to get the reduced (fp8) versions of the Dev and Schnell models to work, and concluded that the only way to get Flux to work was to run ComfyUI in CPU only mode.

All versions of the Dev and Schnell can be run on Apple Silicon, with the correct configuration.

Q: Does PyTorch Need to be Downgraded?

No. You can generate images using a recent (torch-2.6.0 or later) version of PyTorch.

Q: Does the Full Flux.1 Dev Model Work on Apple Silicon?

Yes, but you’ll need at least 48GB memory, and a Max chip. If you have less memory, and fewer GPU cores then you should expect the full model to take an hour or more to generating an image!

ComfyUI needs 32GB+ of memory to run the full (fp32), or pruned (fp32) versions of the Dev and Schnell models. If your Mac has less than 48GB of memory, it will spend a lot of time swapping between memory and storage.

Generated with Flux.1 Dev (pruned fp32, 15.9GB) model with 25 steps in 47 minutes (M1 Max + 32GB)

The Schnell model is 1.5x quicker because it requires fewer steps, but I find the result far less pleasing.

Generated with Flux.1 Schnell (pruned fp32, 15.9GB) model with 10 steps in 19 minutes (M1 Max + 32GB)

How to Make Sense of the Options

There are a whooping 425+ options if you choose Flux.1 Dev, or 360+ usable options if you choose Flux.1 Schnell.

Generating an image with Flux requires 4 models. The Flux.1 model itself, two text encoder models, and a VAE (variational autoencoder) model to convert the output from Flux.1 into an image.

There are currently (March 2025) 13 different variants of Flux.1 Dev ranging in size from 4GB to 24GB, 11 different variants of Flux.1 Schnell (4GB to 24GB), and more than 14 different text encoder models. There two other Flux.1 Schnell variants but their output is too low quality to consider.

Thankfully, there is just one VAE model.

The Flux.1 GGUF Quantizations — Fast and Lean

If you’re lucky enough to have a Mac with 48GB+ then you can use you can use a full (fp32) 23GB model, the pruned (fp32) 16GB model, or the reduced (fp8) 17GB model.

Don’t worry if, like me, your Mac is less well endowed. There are a range of smaller GGUF quantized variants ranging in size from 4GB for the 2-bit Q2K variant, up to 13GB for the 8-bit Q8 variant.

Comparing the options

The prompt I’m using for this comparison was inspired by an image by kenpm on civitai.com.

[embed]Image posted by kenpm Edit descriptioncivitai.com

One of the features that makes Flux.1 standout from earlier models like SDXL, is the ability to include (English) text in a prompt, and have that text reproduced in the generated image.

So, I’ve reworked the original prompt to include a wooden sign with the text “Flux.1 + Apple Silicon 2025”.

• Prompt: macro wildlife photography, photorealistic bunny sitting next to an old wooden sign, dewy grass, wildflowers. The sign has the text “Flux.1 + Apple Silicon 2025” written on it in white paint. The paint is faded. The is sunrise breaking through the light fog. masterpiece, closeup low angle, depth of field, desaturated, film grain, low quality
• Guidance: 3.5 (Dev), 1 (Schnell)
• Steps: 25 (Dev), 10 (Schnell)
• Seed: 224098356445355
• Workflow: flux-gguf-basic-workflow-v2.json

As a baseline, I’m using the pruned variants of the Flux.1 Dev, and Flux.1 Schnell, respectively.

Flux.1 Dev fp8 variant

Flux.1 Dev pruned fp32 variant vs Flux.1 Dev fp8 variant

I’ve included the 17GB fp8 variant in the comparison for completeness. I think it produces a slightly better result than the 16GB pruned fp32 variant.

The images are almost identical, but being picky, the fp8 version gets my vote. The upper most flower and flower bud on the left of the fp32 image look odd (fake) with the flower bud appearing to float without a stem.

Flux.1 Dev Q8 8-bit GGUF quantization (12.7GB)

Flux.1 Dev pruned fp32 variant vs Flux.1 Dev Q8 (8-bit) GGUF quantization variant

The image generated with the 8-bit Q8 GGUF quantized variant looks nearly identical to the Dev baseline image. Which is pretty amazing given it only took a fifth of the time to generate. This is almost entirely down to the model fitting into the physical memory on my Mac, thus eliminating the need for swapping.

There is less detail in the flowers, and the flower is missing from the bottom of the sign. However, the killer difference is that “Silicon” is misspelt as “Silcon” in the Q8 image.

Spoiler: we’ll look at how to fix the misspelling in the next section.

Flux.1 Dev Q6 K 6-bit GGUF quantization (9.86GB)

Flux.1 Dev pruned fp32 variant vs Flux.1 Dev Q6 K (6-bit) GGUF quantization variant

The image generated with the 6-bit Q6 K GGUF quantized variant is almost practically identical to the Q8 image, including the misspelling of “Silicon”.

Flux.1 Dev Q4 KS 4-bit GGUF quantization (6.81GB)

Flux.1 Dev pruned fp32 variant vs Flux.1 Dev Q4 KS (4-bit) GGUF quantization variant

The image generated with the Q4 KS GGUF quantized variant has the same issue with misspelling as the Q6 and Q8 images.

Overall the Q4 image is less well developed. For example, the rabbit is more chunky, and it’s legs and hind quarters are less detailed and obscured by new, larger flowers.

Spoiler: in the next section, we’ll look at a one click change to improve the image.

Flux.1 Dev Q2 K 2-bit GGUF quantization (4.03GB)

Flux.1 Dev pruned fp32 variant vs Flux.1 Dev Q2 K (2-bit) GGUF quantization variant

The image generated with the 2-bit Q2 K GGUF quantized variant is markedly different to the baseline image.

The word “Silicon” is spelled correctly, but the text has changed to block capitals. The rabbit looks reasonably natural, but lacks detail. The sun is gone, and the sign, flowers, grass, etc all have a distinctly unnatural look.

Flux.1 Schnell fp32 pruned (15.9GB)

Flux.1 Dev pruned fp32 variant vs Flux.1 Schell pruned fp32 variant

The image generated with the pruned fp32 variant of Flux.1 Schnell looks radically different to the Dev baseline image. Overall its much darker, and ugly in comparison.

The rabbit’s pose is less appealing. The flowers are obtrusive, and depth of field is a bit “wonky”. For example the petals on the white flower beneath the sign are too in focus given it’s position.

The text is largely correct, but the typography is messy and inconsistent. The words are correctly spelled, but there is an extra “+” between Flux.1 and Apple.

Flux.1 Schnell fp8 (17.2GB)

Flux.1 Schell pruned fp32 variant vs Flux.1 Schell pruned fp8 variant

The image generated with the fp8 variant looks practically identical to the pruned fp32 Schnell (baseline) image.

Flux.1 Dev GGUF quantizations

I don’t want to spend too much time on the Schnell images. Apart from the image generated with the 2-bit Q2 K variant, the images generated with the GGUF quantizations are largely all the same.

Flux.1 Schell pruned fp32 variant vs Flux.1 Schell Q8, Q6 K, Q4 KS, and Q2 K GGUF quantization variants

The image generated with the 8-bit Q8 GGUF quantized variant only has a few minor differences from the baseline image. “Silicon” is misspelt, and the “S” is obscured by the rabbit’s ear. The extra “+” on the sign has changed to an “@”.

The 4-bit Q4 KS image is missing the large, distracting flower from the bottom right. The sign has gained some more extra character — fullstops after the words “Apple” and “Silicon”. The second “i” in “Silicon’ has returned, but the letter obscured by the rabbit’s ears doesn’t look like an “S”.

The 2-bit Q2 K image has visible generation artifacts. A pattern of squares that affects the entire image, but is most visible on the rabbit’s fur and also around the sun.

Take Aways

I suggest using the Dev model, unless the license terms prevents from doing so. The Dev model produces superior results, and in the following sections we’ll look at how to reduce generation times by as much as a half.

The GGUF variants allow you to use the Flux.1 Dev model on Macs even with relatively low physical memory. These variants struggle a bit when generating images that include text, but this is straightforward to fix.

For brevity I’ve skipped the 3-bit and 5-bit GGUF variants. I suggest you start by trying the Q6 K variant, if that works well (not using swap memory) then you could try the Q8 variant.

If your Mac is using swap memory whilst running the Q6 K variant, then I you can progressively work through the 5-bit quantizations starting with the Q5.1 variant, then the 4-bit quantizations starting with the Q4.1 variant, and if necessary the Q3 KS variant.

Whilst I can run the Q8 variant on my Mac, I found the 7.53GB Q4.1 variant gave me the best trade-off between image quality, generation time, and still being able to use my Mac for other things.

My guide to running ComfyUI on Apple Silicon from Scratch includes details of how to download and use the GGUF variants.

Text Encoders Influence the Final Image

The influence of the text encoders on the final image is often ignored by folks. This is not surprising. There is lots of talk (and hype) about this model or that model, and about how to structure a prompt (so called “prompt engineering”). There is far less talk, and thus far less understanding about the influence of the text encoders.

The issue with the misspelling of “Silicon”, and the absence, misplacement, or duplication of the non-alphanumeric characters in the sign text cause by an issue with how the prompt is interpreted.

I had similar issues when I was generating the hero image for the previous edition of the article. I solved it then by tweaking the guidance value and the number of steps, but it puzzled me. After doing some research it turned out to be a problem with the CLIP-L text encoder.

Generated with Flux.1 Dev Q6 K GGUF quantization using the default (CLIP-L) text encoder (left), and a purpose tuned text encoder (right)

As an analogy, think how you would describe your favourite painting, or photograph to an archivist who may not have seen it before. It’s important that you try to describe it in a way that makes it straightforward for the archivist to find it in their archive.

Now imagine that the you and the archivist understand the same language, but the archivist has a much more limited vocabulary than you do. So you need to limit your description to words and phrases that the archivist understands.

Lastly, imagine that that the archivist doesn’t fetch work from the archive themself, but instead uses a runner. The runner cannot understand the prompt, so the archivist has to translated into a language the runner understands.

That’s pretty much how text prompts work. Flux.1 is the archive, the text encoders are the archivist, and the prompt is the description. The text encoders convert the words in your prompt into tokens. Those tokens are in turn converted into numbers, and it’s those numbers that are used to guide the Flux.1 model.

To do this, Black Forest Labs recommend using a combination of OpenAI’s CLIP-L (clip-vit-large-patch14) text encoder, and Google’s T5 v1.1 XXL text encoder for Flux.1.

Staying with the analogy, instead of trying to fix the text by tweaking the description (prompt), we can replace the archivist (CLIP-L) with a different archivist (text encoder model) that understands the importance of the image containing the precise text.

An improved version of CLIP-L that understands prompts with text

As I understand it, CLIP-L doesn’t understand that the text in quotes in the prompt isn’t supposed to be tokenized. This isn’t so surprising. The CLIP-L model is a general purpose machine vision model that predates Flux.1.

Images generated with Flux.1 Dev Q8, Q6 K, Q4 KS, and Q2 K GGUF quantizations, showing text fixed using the ViT-L-14-TEXT-detail-improved-hiT-GmP-TE-only text encoder

To fix the text, I’m using a variant of CLIP-L (ViT-L-14-TEXT) that has been specifically tuned for use with prompts that contain text in quotes. It does this without impacting the quality of the generated image, and is only 80MB larger than the original CLIP-L.

Note that the fix does not work so well with the 4-bit GGUF quantizations, for some reason. It does work with the 3-bit, and the 5-bit GGUF quantizations.

You can download the improved text encoder here, and then use Finder to move the downloaded files to ComfyUI/models/clip.

My guide to running ComfyUI on Apple Silicon from Scratch includes details of how to download and install the text encoders.

The images with embedded workflows are posted on civitai.com.

T5 XXL GGUF quantizations

Blackforest Labs recommend that you use the 16-bit variant of T5 XXL if you have 32GB+ of memory available, otherwise they recommend using the 8-bit variant.

T5 XXL is huge with the 16-bit variant weighing in at a hefty 9.79GB. The 8-bit variant is a more manageable 4.89GB.

The text encoders only run once at the beginning of the workflow, so the 8-bit variant should be fine in most cases. If you are short of memory, then there are GGUF quantizations starting from 2.1GB, that you can use without significantly affecting the quality of your generated images.

Images generated with Flux.1 Dev Q8 GGUF quantization variant using the T5 XXL text encoder GGUF quantization variants

Reducing Generation Time with TeaCache

Generating images on a Mac is slow. Painfully (10+ minutes) slow. Instead of using the faster but lower quality Flux.1 Schnell model, you can use caching to reduce generation times by up to a half.

Timestep Embedding Aware Cache (TeaCache) offers a way to reduce generation times by 50% — 100%. The caching is not lossless. You will notice a difference between an image generated with TeaCache, and one generated without.

Images generated with Flux.1 Dev Q8 GGUF quantization variant using no TeaCache (left), TeaCache set to 0.25 with 25 steps (centre), and TeaCache set to 0.25 with 26 steps (right)

I really like the paw up pose caused by adding the TeaCache but unfortunately the text isn’t perfect. There is also a loss of detail in some of the flowers, the sign post is shorter, the wood texture looks less realistic, and the rabbit looks less well fed — skinnier and it’s fur is a bit lacklustre.

The text can be fixed by increasing the steps from 25 to 26, but doing so also restores the rabbit’s original pose.

Overall, using TeaCache reduces the generation time by around a third but it can have a adverse impact on the image quality. These changes are less noticeable with illustration style image, for photo realistic style images I use TeaCache to speed up the generation of my draft images, and then disable it when I generate the final image.

Images generated with Flux.1 Dev Q8 GGUF quantization variant using no TeaCache (left), TeaCache set to 0.40 with 25 steps (centre), and TeaCache set to 0.40 with 28 steps (right)

Increasing the TeaCache strength from 0.25 to 0.4 only reduces the generation time by a further 17s. The text remains correct but the rabbit looses it’s front legs. The sign post is shorter and appears thicker at the top than it does at the bottom, and the wood texture looks less realistic

Increasing the steps from 25 to 28 restore the rabbit’s legs but again it looks less well fed.

Take Aways

You can generate AI images with Flux.1 on Apple Silicon, but very few of us have a Mac powerful enough to run the full Flux.1 Dev model.

Instead, you will can mix-and-match the smaller GGUF quantizations of the Dev or Schnell models, and the T5 XXL text encoder to fit your mac.

Personally, for photo realistic images I prefer to use the Dev model with TeaCache, rather than the Schnell model. I’ve seen some great realistic images folks have generated using the Schnell model, but on closer investigation those images often use 20–40 steps which negates any speed benefit.

Generating AI images yourself using Flux.1 and ComfyUI can be great fun. ComfyUI also allows you to go further than just text-to-image prompting, and explore the world of image-to-image prompting.

If you’d like to try it for yourself, but don’t know where to start then I suggest my guide to ComfyUI on Apple Silicon from Scratch — 2025.

Useful Links

Flux.1 Dev

• flux1-dev-fp32-pruned (15.91GB)
• flux1-dev-fp8 (17.2GB)
• Flux.1 Dev GGUF quantizations (4.03GB–12.7GB)

Flux.1 Schnell

• flux1-schnell-fp32-pruned (15.9GB)
• flux1-schnell-fp8 (17.2GB)
• Flux.1 Schnell GGUF quantizations (4.01GB–12.7GB)

Text Encoders

• clip_l, t5xxl_fp16, t5xxl_fp8_e4m3fn
• ViT-L-14-TEXT-detail-improved-hiT-GmP-TE-only

Example Workflows

• flux-gguf-basic-workflow-v2.json
• flux-gguf-basic-workflow-with-teacache-v2.json