Best Local Image Generation Models (2026): Picks by VRAM, Mac and Licence

The best local image generation model for most people in October 2026 is Z-Image-Turbo: 6B parameters, Apache 2.0, and its card says it fits a 16 GB GPU. FLUX.2 [klein] 4B is the other permissive pick at about 13 GB. Qwen-Image-2.1 and the 32B FLUX.2 [dev] are licensed for non-commercial use only, and Ollama removed its experimental image generation in August 2026.

Local image generation moved quickly in 2026. Black Forest Labs, Alibaba, Baidu, Krea and Ideogram all published open weights this year, and their licences diverged: some are Apache 2.0, some cap commercial use at a revenue threshold, and the newest Qwen release, like the larger FLUX.2 models, is for non-commercial use only. This guide covers what exists in October 2026, checked against Hugging Face model cards, licence files and runtime documentation on 14 October 2026. Sizes are published weight files in gigabytes. There are no speed figures, because vendors measure on different hardware and settings and their numbers are not comparable.

For models that read images rather than create them, see our guide to local vision models. Licence terms get their own section below, and our open-weight licensing checklist covers the general questions to ask.

Quick picks by VRAM and platform

The open-weight image models that matter in October 2026

Most models in the table also need a text encoder and a VAE alongside the image model. The encoder is often a small language model in its own right: Qwen3 4B for Z-Image and FLUX.2 [klein] 4B (8.04 GB in BF16), Qwen3-VL 8B for Qwen-Image-2.1, a Mistral Small encoder of 18.03 GB in FP8 for FLUX.2 [dev]. Tools such as ComfyUI move these between VRAM and system RAM as needed, which is why the image model is usually what decides the card.

A few newer releases are worth watching but sit outside the table. Boogu-Image-0.1 (10B, Apache 2.0) describes itself as a research project rather than an official release, and Ming-Image-0.1-Design (6B, MIT) was validated on a single GPU with 80 GiB of memory.

Licences: which models you can use commercially

• Apache 2.0 or MIT, commercial use allowed: Z-Image and Z-Image-Turbo, FLUX.2 [klein] 4B, Qwen-Image-2512, ERNIE-Image, LongCat-Image, HiDream-O1-Image and GLM-Image. SDXL, from 2023, uses the royalty-free CreativeML Open RAIL++-M licence with a list of prohibited uses.
• Free below a revenue threshold: Stable Diffusion 3.5 is free for commercial use by organisations and individuals with under $1M in annual revenue, with an enterprise licence above that. Krea 2 sets the same $1M line but counts all affiliated entities over a trailing twelve months, and its definition of commercial use covers outputs as well as the model.
• Non-commercial: Qwen-Image-2.1 and its Turbo checkpoint switched from the Apache 2.0 of earlier Qwen-Image releases to the Qwen Research License, which allows research or evaluation only; commercial use needs a separate licence from the licensor, and Qwen-Image-2.1 Pro and Turbo are also sold as APIs on Alibaba Cloud Model Studio. FLUX.2 [dev] and FLUX.2 [klein] 9B use the FLUX Non-Commercial License, although the [dev] card says generated outputs may be used for commercial purposes. Ideogram 4 is released under a non-commercial licence.
• Restricted by territory: HunyuanImage-3.0’s licence does not apply in the European Union, the United Kingdom or South Korea, forbids using the model or its outputs there, and requires a separate licence for companies with more than 100 million monthly active users.

Black Forest Labs sells self-hosted commercial licences in tiers: Builder covers the [klein] models for 10,000 images a month, and Platform adds FLUX.2 [dev] and [klein] Base 9B for 100,000 images a month. Its licensing page publishes no prices. This section is general information, not legal advice; have counsel review any licence before production use.

Best local image generation model for 8 and 12 GB GPUs

Black Forest Labs sizes FLUX.2 [klein] 4B at about 13 GB, so smaller cards rely on quantised weights and offloading:

• 8 GB. FLUX.2 [klein] 4B in FP8 is a 4.07 GB file from Black Forest Labs, and ComfyUI offers a 3.85 GB FP4 build of its text encoder that can sit in system RAM. SDXL, released in 2023, is the fallback, with a 5.14 GB FP16 UNet.
• 12 GB. Z-Image-Turbo’s INT8 build from ComfyUI is 6.20 GB, and FLUX.2 [klein] 4B fits in BF16 at 7.75 GB with the encoder offloaded. Stability says Stable Diffusion 3.5 Medium needs 9.9 GB excluding its text encoders, which suits a 12 GB card if your revenue keeps you inside the free licence.

ComfyUI’s README claims its weight streaming can run even the largest open models on 4 GB of VRAM with 8 GB of system RAM. Streaming trades time for memory, so treat it as a way to try a model, not a reason to skip a card upgrade. Our GPU buying guide compares the cards at each tier.

Best local image generation model for 16 GB VRAM

Sixteen gigabytes is where the permissive models run at full precision. Z-Image-Turbo is the default pick: its card says it fits comfortably within 16 GB, it needs eight sampling steps, and it renders English and Chinese text. FLUX.2 [klein] 4B is the alternative at about 13 GB, with image editing and multi-reference input in the same model.

For non-commercial work, Qwen-Image-2.1 and its eight-step Turbo checkpoint come within reach through ComfyUI’s 7.26 GB INT8 image model and 6.31 GB quantised text encoder. The model generates at 2048 × 2048 natively, can output transparent RGBA images and accepts up to ten reference images for editing. Krea 2 has a 13.14 GB FP8 build if you qualify for its revenue threshold.

To run Z-Image-Turbo from Python with Diffusers:

1. Install a CUDA build of PyTorch, then the libraries:

pip install git+https://github.com/huggingface/diffusers
pip install transformers accelerate

2. Generate an image:

import torch
from diffusers import ZImagePipeline

pipe = ZImagePipeline.from_pretrained("Tongyi-MAI/Z-Image-Turbo", torch_dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()  # moves each component to the GPU only while it runs

image = pipe(
    prompt="A ceramic mug on an oak desk beside a window, soft morning light, product photo",
    height=1024,
    width=1024,
    num_inference_steps=9,  # nine steps give eight transformer passes on Turbo
    guidance_scale=0.0,     # the card says Turbo runs without guidance
).images[0]
image.save("mug.png")

In ComfyUI, the same model ships as a built-in workflow template, which is the quicker route if you prefer a visual editor. The VRAM tiers here mirror our language-model guide by graphics memory, so a single card can be planned for both.

24 GB, 32 GB and server-class GPUs

24 GB opens up the larger permissive models. Baidu says ERNIE-Image and its eight-step Turbo version run on 24 GB consumer GPUs. HiDream-O1-Image is 16.37 GB in BF16 under MIT. GLM-Image, which pairs a 9B autoregressive generator with a 7B diffusion decoder for text-heavy images, needs about 23 GB with CPU offloading, and LongCat-Image about 17 GB. HunyuanImage-2.1, a 17B model that only generates at 2K, needs 24 GB with FP8 and offloading, under the same territorial licence as HunyuanImage-3.0.

32 to 48 GB suits Qwen-Image-2512, the 20B Apache 2.0 model: 20.43 GB in FP8 and 40.86 GB in BF16. FLUX.2 [dev] is 35.46 GB even in ComfyUI’s FP8 build. Black Forest Labs’ own example for an RTX 4090 uses a 4-bit model with the text encoder running remotely, which shows how tight a 24 GB card is for it.

Servers. HunyuanImage-3.0 is an 80B mixture-of-experts model with 13B active parameters, and Tencent lists at least three 80 GB GPUs for it. For shared serving, Qwen’s repository lists day-one support for Qwen-Image-2.1 in vLLM-Omni and SGLang, the GLM-Image card documents an SGLang server, and Tencent publishes vLLM acceleration for HunyuanImage-3.0.

Best local image generation model for Mac

Macs share one pool of unified memory, so the budget is the same one our Mac model guide uses: about 80% of installed memory. The figures below are BF16 weights for the image model, text encoder and VAE from each official repository, before working memory for the image itself, which grows with resolution.

Z-Image-Turbo’s official files store the image model in 32-bit precision; at BF16 it matches the 20.52 GB of the Z-Image base model.

Four ways to run them:

• ComfyUI Desktop supports Apple silicon through PyTorch’s Metal backend. Its documentation notes that ComfyUI does not use Apple’s MLX framework.
• mflux, an MIT-licensed community project, implements models natively in MLX: Z-Image, FLUX.2 [klein] 4B and 9B, Qwen-Image-2.1, Krea 2, Ideogram 4, ERNIE-Image and others, with built-in quantisation.
• Draw Things runs on Mac, iPhone and iPad; the free edition generates on the device and works offline, and a $8.99 monthly tier adds cloud compute.
• DiffusionBee is listed alongside Draw Things as a local app on the Krea 2 and Ideogram 4 model cards.

On a 16 GB Mac, mflux’s 8-bit mode is the simplest start:

uv tool install --python 3.13 mflux
mflux-generate-z-image-turbo --prompt "A lighthouse on a cliff at dusk" --steps 9 --seed 42 -q 8

Runtimes: ComfyUI, Diffusers and Ollama

ComfyUI is the node-based editor most of these models target at release. It is GPL-3.0, runs on Windows, Linux and Apple silicon, and has official workflow guides for FLUX.2 [dev] and [klein] 4B, Qwen-Image-2512 and 2.1, Z-Image and Z-Image-Turbo, HiDream-O1-Image, Krea 2, Ideogram 4 and Boogu-Image. Its documentation says there is no official Docker image, so container deployments rely on community images you vet yourself.

Diffusers is the Python route: most cards above ship a pipeline class, including ZImagePipeline, Flux2KleinPipeline, QwenImage21Pipeline, GlmImagePipeline and LongCatImagePipeline. Several new models need Diffusers installed from source.

Ollama is not an option today. It added experimental image generation in January 2026, starting with Z-Image Turbo and FLUX.2 Klein on macOS and on Linux with CUDA, and opened it to its generate API. Version 0.32.6 on 4 August 2026 temporarily removed the feature, and release notes up to 0.40.4 on 12 October 2026 do not mention its return.

How VDF AI fits

A single ComfyUI workstation serves one designer well. When many staff need images, the questions change: who may generate what, where prompts and outputs are kept, and who reviews an image before it reaches a customer.

VDF AI answers those questions for its own image generation agent, which turns a plain description into a detailed prompt and an image. Generated images are stored under the requesting user with an audit log, access follows role-based permissions, and policies in VDF AI Networks can allow or block image generation for each workflow. If images must never leave your network, confirm which image model your deployment will call before you switch the tool on.

For the language models around that work, VDF AI Router can list an Ollama server or another on-premises deployment beside whichever cloud models your policy allows, and switching on air-gap mode confines routing to the local endpoints.