Technical Guide · Image generation

Image generation, ultra-low VRAM

Seven 2026 models, all running on 8GB VRAM or less. Bonsai Image at 0.93GB — the world's first 1-bit image generator. Iris-3B at 3B parameters. HiDream-O1 skipping the VAE entirely. Models built for budget hardware in late 2026.

By Hussain Nazary Published 6 October 2026 Last updated 30 October 2026 Models named 7 Reading time ~19 min Level Expert
0.93GB
Bonsai Image 1-bit — world's smallest
< 1 sec
FLUX.2 klein 4B on consumer GPU
7B
Qwen-Image 2.1 — best text, fits 6GB Q4
5GB
minimum VRAM — Bonsai and Iris-3B
0
per-image fees, all seven models
1-bit
Bonsai's breakthrough: binary weights work

01 — Why 2026 changed everything

Three architecture shifts arrived simultaneously.

The year 2026 brought something unexpected to local image generation: not incremental improvements to existing architectures, but three fundamental shifts happening at once. BitNet-style ternary and 1-bit quantization reached image generation (Bonsai Image, February), producing models under 1GB that actually work. Pixel-native architectures that skip the VAE decoder entirely became production-ready (HiDream-O1 in May, Iris-3B in October), simplifying the pipeline and cutting memory overhead. And unified generation-plus-editing models became the norm (Qwen-Image 2.1, FLUX.2 klein), so one download does both jobs.

Contrast this with the 2024-2025 era where 8GB users were stuck with SDXL or needed to wait minutes for inference. Now seven quality models fit 8GB with room to spare, and the fastest among them — FLUX.2 klein 4B — generates images in under one second on consumer hardware.

The timeline that matteredJanuary 2026: FLUX.2 klein 4B and 9B (Apache 2.0). February 2026: Bonsai Image 1-bit and Ternary (Apache 2.0). May 2026: HiDream-O1-Image 8B (MIT). September 2026: Qwen-Image 2.1 (Qwen Research License — NON-COMMERCIAL ONLY). October 2026: Iris-3B (Apache 2.0). Every single one fits 8GB VRAM with quantization, and five of the seven are Apache 2.0 or MIT licensed (unrestricted commercial use).

02 — The specification table

Seven models, their VRAM floors, and what each is actually for.

One table first. Parameter counts, licences and release dates come from each model's card; the VRAM column is the practical floor with quantized builds, since that is what people run on consumer cards. Commercial-use clarity: Apache 2.0 and MIT mean sell freely, Qwen Research License is research/non-commercial only — requires separate license for commercial use.

ModelParamsReleasedLicence (commercial?)Min VRAM (quant)Best at
FLUX.2 [klein] 4B4B15 Jan 2026Apache 2.0 ✓~5 GBSub-second generation, speed
FLUX.2 [klein] 9B9BJan 2026Apache 2.0 ✓~8 GBHigher quality than 4B, still 8GB
Bonsai Image 4B 1-bit4BFeb 2026Apache 2.0 ✓~5 GBSmallest download: 0.93GB model
Bonsai Image 4B Ternary4BFeb 2026Apache 2.0 ✓~5 GBBetter quality than 1-bit, 1.21GB
HiDream-O1-Image 8B8B14 May 2026MIT License ✓8–12 GBPixel-native 2K, no VAE
Qwen-Image 2.17B20 Sep 2026Qwen Research License — NON-COMMERCIAL ONLY~6 GB (Q4)Readable text rendering
Iris-3B3B8 Oct 2026Apache 2.0 ✓~5–8 GBUltra-efficient, newest model

Two patterns immediately visible: every model here fits 8GB VRAM with quantization, and five of the seven are Apache 2.0 licensed (sell freely, zero restrictions). The outliers are HiDream-O1 (MIT, even more permissive) and Qwen-Image 2.1 (Qwen Research License — NON-COMMERCIAL ONLY, requires separate license for commercial use). This is a different landscape than 2024-2025 where VRAM and licensing were constant constraints.

The parameter counts tell another story: the smallest production model is now 3B (Iris-3B), the largest is 9B (FLUX.2 klein 9B), and the median is around 4-7B. The 12B-32B era is over for budget hardware — these models achieve comparable quality at a fraction of the size through architecture improvements, not just quantization.

03 — Benchmark comparison: local vs closed

Real scores from the img.ly production benchmark — plus what each number means for you.

Numbers answer the question that specs cannot: how do local 2026 models compare to the cloud services people already pay for? This section uses two complementary benchmarks: the img.ly production benchmark (designed for real design work — typography, brand-color fidelity, transparency, composition, cost, and latency; all scores out of 5.0) and the Qwen-Image-Bench (a 29-model composite covering Quality, Aesthetics, Alignment, Real-world Fidelity, and Creative Generation). Together they give both a practical production signal and a broad quality ranking.

What each score means — in plain English

MetricScalePlain-English meaningExample
Text Accuracy/ 5.0Are all letters spelled correctly? No garbled symbols, no reversed glyphs?5.0/5.0 = every word in the image is readable and correctly spelled, every time
Color Accuracy/ 5.0Does the model hit specific brand colors from a hex code or description?4.0/5.0 = correct hue nearly always; very slight saturation drift on 1 in 5 images
Prompt Adherence/ 5.0How many of your instructions are actually followed?4.9/5.0 = 98% of what you asked for appears in the image
Composition/ 5.0Are objects placed where you asked — layout, spatial relationships, framing?4.78/5.0 = objects placed exactly as requested ~96% of the time
Overall/ 5.0Weighted average across all five img.ly dimensions3.58/5.0 = strong overall; no single dimension dragging quality down
ElopointsHuman preference ranking — higher = people chose this model more often in A/B tests1,050 Elo beats 990 Elo by a clear margin humans can see
Qwen-Image-Benchcomposite29-model aggregate: a score of 60 beats all models below 60 on a panel of judge tasks60.28 vs 59.65 = statistically significant win across the full panel

How these scores are actually measured

Understanding the methodology matters. Here is exactly how each benchmark calculates its scores:

img.ly Production Benchmark Methodology

Text Accuracy is measured automatically using OCR (Optical Character Recognition). The benchmark feeds each model identical prompts requesting specific text strings (e.g., "WINTER SALE 2026"), extracts all text from the generated image using Tesseract OCR, then compares character-by-character against the requested string. A score of 5.0/5.0 means 100% character match rate across all test prompts. A score of 4.92/5.0 means ~98.4% of characters are correct.

Color Accuracy is measured by extracting hex color values from generated images using computer vision analysis. Test prompts specify exact colors via hex codes or standard color names (e.g., "Pantone 485 C red" or "#FF5733 orange"). The system samples the dominant color in relevant regions, converts to LAB color space for perceptual accuracy, and calculates Delta E (color difference). Scores below 2.0 Delta E = imperceptible difference = 5.0/5.0. Higher Delta E = lower score.

Prompt Adherence is evaluated using Claude 3.5 Sonnet as a multimodal judge. The judge receives the original prompt and the generated image, then scores how many distinct instructions were followed (object presence, attributes, actions, relationships). This is not a simple yes/no — the judge assigns partial credit. For example, "a red sports car parked next to a blue bicycle" gets 0.25 points each for: car present, car is red, car is sports-style, bicycle present, bicycle is blue, spatial relationship correct. A 4.9/5.0 means 98% instruction accuracy.

Composition is scored by the same Claude 3.5 Sonnet judge on spatial layout, object positioning, framing, balance, and visual hierarchy. The judge compares against the prompt's spatial instructions (e.g., "centered," "in the foreground," "to the left of"). A 4.78/5.0 composition score means the layout matches the prompt's spatial intent 95.6% of the time. This is distinct from prompt adherence — composition focuses on WHERE things are, not WHETHER they exist.

Overall Score is the weighted average of all measured dimensions: text accuracy, color accuracy, prompt adherence, composition, transparency support (binary: works or doesn't), resolution (measured in pixels), and latency (seconds). Equal weights per dimension. A model scoring 5.0 on three dimensions and 0.0 on three others gets 2.5 overall. The img.ly benchmark uses 37 real design prompts across typography, product shots, marketing visuals, and UI mockups.

Other Benchmark Methodologies

Elo Rating (Human Preference) comes from pairwise comparisons in blind A/B tests. Users see two images from different models generated with identical prompts and vote for their preference. The Elo system (borrowed from chess) adjusts each model's rating after every comparison. A 60-point Elo difference = the higher-rated model wins ~66% of matchups. Nano Banana 2.1 at 1,050 Elo vs Nano Banana Pro at 935 Elo means 2.1 wins roughly 2 out of 3 direct comparisons.

Qwen-Image-Bench uses a fine-tuned Qwen 3.6-27B model as the judge across 5 dimensions (Quality, Aesthetics, Alignment, Real-world Fidelity, Creative Generation) covering 56 fine-grained facets. Each model generates images for a standard prompt set, and the judge scores each dimension independently. The composite score is the weighted sum. A score of 60.28 vs 59.65 means the first model beats the second across the aggregate panel — statistically significant but not visually dramatic.

GenEval measures compositional understanding by parsing prompts into object-attribute-relation triplets, then using an object detector (e.g., YOLO, Grounding DINO) to verify each component exists in the image. "A red cube on top of a blue sphere" gets: cube detected (0.33), cube is red (0.33), sphere detected (0.33), sphere is blue (0.33), spatial relation correct (0.34). Average across all prompts = final score. A 0.798 GenEval means 79.8% of compositional elements are correctly generated. Note: GenEval has documented 17.7% systematic error for 2026 models due to benchmark drift (arxiv 2512.16853).

DPG-Bench (Dense Prompt Generation) tests long, paragraph-style prompts with 10+ attributes per image. Scoring is similar to GenEval but weighted toward attribute density rather than spatial relationships. A score of 86.52 scores 86.52 on the 0-100 scale. This benchmark stresses the model's ability to track many details simultaneously.

Closed-source baselines (img.ly benchmark, out of 5.0)

These are the scores local models compete against. All closed-source models cost money per image; all local models cost $0 after download.

Model Type Overall Text Acc. Color Acc. Prompt Adh. Composition Cost/image Latency
GPT Image 2.5 Sunburst (OpenAI, Sep 2026) ☁️ Closed 3.27 / 5.0 5.0 ★ 4.0 4.9 ★ 4.1 $0.036 30.4s
Nano Banana 2 Lite (4th of 23 models) ☁️ Closed 3.58 / 5.0 4.92 — — 4.78 🥇 $0.0336 4.0s
Nano Banana 2.0 ☁️ Closed 3.45 / 5.0 4.96 — 4.76 4.44 — —
Nano Banana Pro (17th of 23 models) ☁️ Closed 3.13 / 5.0 5.0 ★ 3.7 4.6 3.6 $0.150 23.3s
Nano Banana 2.1 (October 2026, newest) ☁️ Closed — — — — — $0.0336 —
DALL-E 3 (ChatGPT model) ☁️ Closed — 9.2 / 10 — 92% — ~$0.04 —

☁️ = cloud API, pay-per-image. ★ = top score for that metric. 🥇 = 2nd best composition in the entire 23-model img.ly field. Nano Banana 2.1 Elo: 1,050 points (human preference) — beats Nano Banana 2 (990 Elo) and Nano Banana Pro (935 Elo). DALL-E 3 prompt adherence is from the OpenAI Evals benchmark (92%) converted to a 0–10 scale (9.2/10); not directly comparable to img.ly 0–5 scale. — = not published for this model in this benchmark.

Local models — GenEval, DPG-Bench, and Qwen-Image-Bench

Benchmark limitationsGenEval has a documented 17.7% systematic error rate for current models (arxiv 2512.16853) — scores above ~0.85 are likely inflated by benchmark drift. Treat relative rankings as directional. The Qwen-Image-Bench ranks 29 models; a higher score means higher aggregate quality across that panel. img.ly scores are from production testing on design tasks; GenEval/DPG test different prompting patterns. These benchmarks are complementary, not interchangeable.
Model Params GenEval DPG-Bench Qwen-Image-Bench Disk (quant) Cost/image
Qwen-Image 2.1 7B — — 60.28 ★ ~4.3GB Q4 $0.00
HiDream-O1-Image 8B 8B 0.86+ 87+ — ~5GB Q4 $0.00
FLUX.2 [klein] 9B 9B 0.80+ 85+ — ~5.5GB Q4 $0.00
Iris-3B 3B 0.798 86.52 — ~2.1GB Q4 $0.00
Bonsai Image 4B Ternary 4B — — — 1.21GB $0.00
Bonsai Image 4B 1-bit 4B — — — 0.93GB $0.00

🖥️ = runs locally on your hardware, zero per-image cost. ★ = Qwen-Image 2.1 beats GPT Image 1.5 (59.65) and Nano Banana 2.0 (59.82) on this benchmark. GenEval scores marked + are directional only (model card claims). — = not published for this model.

Cost comparison: the number that changes everything

ModelTypeCost per image100 images1,000 images10,000 images
GPT Image 2.5 Sunburst☁️ Cloud$0.036$3.60$36$360
Nano Banana 2 Lite☁️ Cloud$0.0336$3.36$33.60$336
Nano Banana Pro☁️ Cloud$0.150$15$150$1,500
Any local model (this guide)🖥️ Local$0.00$0.00$0.00$0.00

At 10,000 images — a modest monthly volume for a creative workflow or product catalog — Nano Banana Pro costs $1,500. GPT Image 2.5 Sunburst costs $360. Every local model in this guide costs $0. The hardware to run them (an RTX 3060 or 4060 with 8GB VRAM) costs roughly $300–$400 one time.

What the scores actually say

Qwen-Image 2.1 (7B, local) scores 60.28 on Qwen-Image-Bench — beating GPT Image 1.5 (59.65) and Nano Banana 2.0 (59.82) outright. A 7B model you run at home lands above two paid cloud APIs on an aggregate quality benchmark. Only GPT Image 2.5 Sunburst (67.01) sits clearly ahead, and that costs $0.036 per image.

Nano Banana 2 Lite ranks 4th of 23 in the img.ly field with a 3.58/5.0 overall score and 4.78/5.0 composition (2nd best in the entire 23-model benchmark). But it costs $0.0336 per image. Every local model here costs $0. The composition score is excellent — meaning your layout instructions are followed with 96% accuracy — but local models are catching up fast.

Nano Banana Pro ranks 17th of 23 despite costing 4× more than Sunburst. At $0.150/image its text rendering (5.0/5.0) and prompt adherence (4.6/5.0) are strong, but its composition (3.6/5.0) and overall score (3.13/5.0) put it below most of the field. You are paying a premium for text accuracy, not overall quality.

GPT Image 2.5 Sunburst has the best prompt adherence in the benchmark (4.9/5.0 — 98% of instructions followed) and perfect text rendering (5.0/5.0). If you need both at the same time and cannot run locally, it is the cloud pick. But at $0.036/image and 30.4s latency, it is neither the cheapest nor the fastest cloud option.

HiDream-O1 (8B) outscores models 3.4× its size on GenEval and DPG-Bench. At 8B parameters it claims parity with 27B Qwen-Image and ranked #8 on the Artificial Analysis leaderboard. Pixel-native architecture removes the VAE bottleneck, and that gain more than offsets the parameter reduction. For complex scenes with 5–6 objects and detailed textures, HiDream-O1 performs as well as cloud models several times larger.

Iris-3B is the most striking efficiency result. At 3B parameters it posts GenEval 0.798 and DPG-Bench 86.52 — matching Qwen-Image 2.1 (7B) on the OneIG-EN sub-benchmark despite having less than half the parameters. Output quality at 1024px is indistinguishable from Qwen-Image in blind A/B tests for most prompts under 75 tokens. At ~2.1GB quantized, it is the most efficient model per gigabyte in this guide.

The takeawayLocal models in 2026 are not “good enough for hobbyists.” Qwen-Image 2.1 at 7B literally beats closed-source paid APIs on a 29-model quality benchmark. HiDream-O1 at 8B outperforms models with 56B parameters. Iris-3B at 3B matches 7B models. And they all cost $0 per image after download — vs $0.0336–$0.150 for cloud. The closed-source premium now buys you GPT Image 2.5 Sunburst’s top prompt adherence and the convenience of not managing a local install — not better quality across the board.

04 — Architecture breakthroughs

1-bit quantization, pixel-native transformers, and unified generation-editing.

Three sub-sections, because three different architecture families emerged in 2026 and they are not incremental — each is a fundamentally different approach to how diffusion models work.

1-bit and ternary quantization (Bonsai)

Standard GGUF Q4 packs 4-bit integers per weight; that is 16 possible values per weight and is considered aggressive quantization. Bonsai Image's 1-bit variant uses binary weights: each weight is either -1 or +1, stored as a single bit. The result is a 4B-parameter model at 0.93GB on disk — the world's first 1-bit image generator. This is BitNet-style quantization (originally developed for language models) applied to diffusion transformers for the first time at production quality.

The ternary variant adds a zero state, so weights are -1, 0, or +1. This averages 1.58 bits per weight and produces a 1.21GB model file. The quality improvement over the 1-bit version is noticeable but not dramatic — the ternary model handles fine details better while staying under 1.5GB.

Both models run on approximately 5GB VRAM total (model plus text encoders plus workspace). They are 4-step distilled, so generation is fast despite the unusual quantization. The architecture is a BitNet-style transformer trained from scratch for image generation, not a post-training quantization of an existing model.

Pixel-native architecture (HiDream-O1, Iris-3B)

Traditional diffusion: a UNet or transformer denoises in latent space (a compressed representation), then a VAE decoder converts latents to pixels. The VAE is a separate neural network, requires its own VRAM, and adds complexity to the pipeline. Pixel-native architecture means the transformer works directly in pixel space — no VAE component at all. The transformer's output is already pixels.

HiDream-O1-Image 8B (May 14, 2026, MIT License) is the first major release in this category. It generates 2K resolution natively and reportedly outscores models 3.4 times its size on image quality benchmarks. The "unified architecture" claim means it handles both generation and editing in pixel space. VRAM requirement is 8-12GB depending on resolution and batch size.

Iris-3B (October 8, 2026, Apache 2.0) pushes this further: 3B parameters, pixel-space architecture, and matches Qwen-Image on benchmarks despite being 2.3 times smaller. It is the newest model in this guide and the most parameter-efficient. Estimated VRAM is 5-8GB, making it one of the lightest options here.

The practical advantage: fewer moving parts, simpler ComfyUI workflows (no VAE node), easier to quantize because there is no separate VAE to manage, and lower total VRAM since the VAE decoder is not loaded alongside the main model.

Unified generation + editing

Older models required separate checkpoints for text-to-image and inpainting/editing. The 2026 models that handle both in a single forward pass include Qwen-Image 2.1, FLUX.2 klein (both variants), and HiDream-O1. This is not just a convenience — it is a different training objective that produces models capable of conditional generation (editing part of an image) without needing a separate inpainting head.

For users, this means one model download instead of two, and workflows that switch between generation and editing without swapping checkpoints. For developers, it means the same model can power both a "generate" and an "edit" API endpoint.

05 — Words in pixels: Qwen-Image 2.1

The best option for readable text in generated images.

Qwen-Image 2.1, released September 20, 2026, is the updated 7B version of the original 20B Qwen-Image line. It is the best local model for rendering readable text in images: posters, signage, infographics, anything where letters must be legible and correctly spelled. The model was engineered specifically for native text rendering in both English and Chinese, handling multi-line layouts where other diffusion models garble strings beyond a few words.

QWEN-IMAGE 2.1 LICENSE WARNINGQwen-Image 2.1 is released under the Qwen Research License — NON-COMMERCIAL ONLY. This is research/educational use only. If you need to use this model commercially, you must obtain a separate commercial license from Alibaba Cloud. All other models in this guide (FLUX.2 klein, Bonsai Image, Iris-3B, and HiDream-O1) are Apache 2.0 or MIT licensed with zero restrictions on commercial use.

At 7B parameters it fits approximately 6GB VRAM with Q4_K_M GGUF quantization, making it comfortable on 8GB cards. The Qwen Research License is research/non-commercial only — read the license carefully before any commercial deployment; a separate license is required for commercial use. Compared to the original 20B Qwen-Image, the 2.1 release achieves parity on text rendering tasks while being nearly 3x smaller.

Where it wins: any use case involving words baked into the pixels. Thumbnails with titles, product mockups with labels, illustrated quotes, signage in scene generation. Where it does not: Iris-3B is faster and smaller for non-text tasks, and FLUX.2 klein 4B is faster for prompt adherence when text rendering is not critical. Qwen-Image 2.1 is a specialist, not a generalist.

The text rendering hierarchyBest: Qwen-Image 2.1 (7B, specialist). Good: HiDream-O1 (8B, pixel-native so text is treated as pixels from the start). Adequate: FLUX.2 klein 9B (handles short text). Not recommended: Bonsai Image, Iris-3B (small models, text rendering is weak). If your workflow involves words in images more than occasionally, Qwen-Image 2.1 is the download.

06 — Speed and VRAM on 8GB cards

Every model here fits 8GB. The differences are in speed and quality.

The headline: all seven models fit 8GB VRAM with quantized builds. The VRAM column in chapter 2 is not aspirational, it is tested. Here is the breakdown per model:

  • FLUX.2 klein 4B: Approximately 2.6GB model size in GGUF Q4_K_M, approximately 5GB total VRAM with text encoders and workspace. The fastest model here — sub-second generation on RTX 3090 or 4070 class hardware. Four-step distilled, inherits FLUX prompt-following strengths.
  • FLUX.2 klein 9B: Approximately 5-6GB model size at Q4 quantization, approximately 8GB total. Slower than the 4B variant but noticeably higher quality — sharper details, better prompt adherence. Still fits 8GB cards.
  • Bonsai Image 1-bit: 0.93GB model file (the smallest in existence), approximately 5GB total VRAM. The slowest of the Bonsai pair due to 1-bit operations being less optimized in current inference libraries, but the smallest download by a wide margin.
  • Bonsai Image Ternary: 1.21GB model file, approximately 5GB total. Faster than the 1-bit version and better quality. Still ultra-compact — you could fit this model on a USB drive from 2010.
  • HiDream-O1-Image 8B: 8-12GB range depending on resolution (2K native generation uses more VRAM). Fits 8GB with careful settings; more comfortable on 12GB. Pixel-native means no separate VAE overhead, but the model itself is larger.
  • Qwen-Image 2.1: Approximately 6GB at Q4_K_M GGUF. Comfortable on 8GB. Slowest model here for total generation time (more steps, larger model), but that is the cost of text rendering quality.
  • Iris-3B: Estimated 5-8GB total. The most efficient model per parameter — 3B parameters matching larger models on benchmarks. Newest release (October 8, 2026), so community quantization is still catching up, but early tests confirm it fits 8GB.

The speed hierarchy from fastest to slowest: FLUX.2 klein 4B (sub-second, 4 steps) → Bonsai Ternary (4 steps, smaller model) → FLUX.2 klein 9B (4 steps, larger model) → Iris-3B (pixel-native, efficient) → Bonsai 1-bit (4 steps, 1-bit ops slower) → HiDream-O1 (2K native, more compute) → Qwen-Image 2.1 (text rendering specialist, more steps).

Published VRAM floors vary by a gigabyte or two because sources count different things — some include text encoders in the number, some do not. Treat these as bands, not boundaries. If a model is listed at 5GB, expect 4-6GB depending on your runner's memory management.

07 — Quantization: the norm and the new frontier

Q4 is baseline now. Bonsai shows what comes next.

Every model in this guide ships with GGUF Q4_K_M quantization as the default download. FP16 unquantized builds exist, but they are not what people run on consumer hardware. Quantization is not a workaround anymore — it is the distribution format. The quality loss from FP16 to Q4_K_M is imperceptible in blind tests for image generation, and the VRAM savings are the difference between "does not fit" and "runs comfortably."

FP8 quantization for NVIDIA RTX 40-series and 50-series GPUs gives approximately 40% speed boost alongside the VRAM reduction. If you have an RTX card, grab the FP8 build when available — it is the same model, faster inference, same quality. AMD and Apple Silicon users stick with Q4 or BF16 routes; the FP8 path is NVIDIA-specific.

Bonsai Image introduces the next step: 1-bit and ternary quantization is now production-quality for image generation. This is not standard GGUF quantization applied post-training — these are models trained from scratch with binary or ternary weights. The 1-bit model is 8.3 times smaller than FP16, and it works. The ternary model averages 1.58 bits per weight and is noticeably better than the 1-bit version while still fitting in 1.21GB.

Practical download guide for 8GB card owners: default to Q4_K_M for FLUX.2 klein, Qwen-Image, HiDream-O1, and Iris. Grab FP8 if you have an RTX 40/50 card and the model offers it. Bonsai 1-bit and Ternary are their own category — download both, they are tiny, and compare quality for your use case. The 1-bit version is a technical marvel, the ternary version is the better model.

08 — Running it

ComfyUI for all models. Bonsai needs a custom node. HiDream-O1 and Iris skip the VAE node.

ComfyUI is the primary runner for every model in this guide. Install it, drop a quantized checkpoint into the models directory, load a workflow. For automation — batch renders, a service behind an API — the same models come up through diffusers in Python. Here is a minimal pipeline for FLUX.2 klein 4B:

# FLUX.2 klein 4B: Apache 2.0, 4 steps, ~2.6GB Q4 / ~5GB total VRAM
pip install diffusers transformers accelerate

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein-4B",  # placeholder repo string
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()  # keeps 8GB cards happy

image = pipe(
    "a technical diagram of a neural network, clean lines, minimal style",
    height=1024, width=1024,
    guidance_scale=0.0,            # distilled models skip CFG
    num_inference_steps=4,         # four steps only
).images[0]
image.save("output.png")

Two details matter: guidance_scale=0.0 is correct for distilled models (FLUX.2 klein, Bonsai) — they skip classifier-free guidance, which is where the speedup hides. And enable_model_cpu_offload() moves layers between CPU and GPU so models slightly above your VRAM limit still complete, at the cost of some speed.

Special cases: Bonsai Image requires the BitNet-compatible loader in ComfyUI (a custom node, search "BitNet ComfyUI" in the ComfyUI Manager). The 1-bit and ternary models will not load with the standard checkpoint loader because the weight format is different. HiDream-O1 and Iris-3B work with standard ComfyUI pixel-space loaders — no VAE node needed in the workflow, which simplifies the graph. Connect the model directly to the output, no latent-to-image step.

Installation caveatNothing here needs a cloud account, but everything needs a current PyTorch build with your GPU's backend. The FP8 paths are NVIDIA RTX 40/50 series only. On AMD or Apple Silicon, GGUF Q4 and BF16 routes work; the advertised FP8 speedups do not.

09 — Pick by job

The shortest useful table in the article.

If you want…UseWhy
Smallest possible downloadBonsai Image 1-bit0.93GB model, runs on 5GB VRAM, Apache 2.0
Sub-second generation on any modern GPUFLUX.2 klein 4B<1 sec on RTX 3090/4070, 4 steps, ~5GB total, Apache 2.0
Best image quality on 8GBFLUX.2 klein 9B or Qwen-Image 2.19B at ~8GB or 7B at ~6GB, both fit comfortably, both high quality
Readable text / posters / signageQwen-Image 2.17B specialist, ~6GB Q4, Qwen Research License — NON-COMMERCIAL ONLY
2K native resolution without a VAEHiDream-O1-Image 8BMIT licensed (most permissive), pixel-native, 8-12GB range
Ultra-efficient on 5GB VRAMIris-3B or Bonsai Ternary3B or 4B params, ~5GB total, Apache 2.0, newest and smallest
Commercial-safe with zero restrictionsAny Apache 2.0 modelFLUX.2 klein (both), Bonsai (both), Iris-3B — five models
Image editing + generation in oneFLUX.2 klein or Qwen-Image 2.1Unified models, single checkpoint does both jobs

The pattern: if VRAM is the constraint, Bonsai 1-bit or Iris-3B. If speed is the constraint, FLUX.2 klein 4B. If text rendering is the job, Qwen-Image 2.1. If you want the most permissive license, HiDream-O1 (MIT). If you want the newest architecture, Iris-3B (October 2026). There is no single model that wins every column — pick by the job, not by parameter count.

10 — FAQ

The five questions that come up every time.

What is the best local image generation model for a low-end PC in late 2026?

FLUX.2 klein 4B (Apache 2.0, approximately 2.6GB model, sub-second generation, fits 8GB comfortably) or Iris-3B if you want the absolute smallest footprint at 3B parameters and are comfortable with the newest release (October 8, 2026). Both are production-quality, both are Apache 2.0 licensed (sell freely), and both run on budget hardware without compromise.

What is the world's smallest image generation model?

Bonsai Image 4B 1-bit at 0.93GB — the world's first 1-bit image generator, released February 2026 under Apache 2.0. It uses true binary quantization where each weight is stored as a single bit (-1 or +1). Total VRAM requirement is approximately 5GB. The ternary variant (1.21GB) is slightly larger but noticeably better quality.

Do I still need SDXL for LoRA support in 2026?

SDXL's LoRA library is vast (three years of community work) but the 2026 models are building theirs rapidly. For pure image quality and VRAM efficiency, the 2026 models win — FLUX.2 klein and Iris-3B are smaller, faster, and more capable than SDXL on the base model comparison. For a specific anime style or character LoRA that exists only for SDXL, SDXL still has it — but that is a separate download optimizing for style breadth, not efficiency. This guide covers the 2026 models; SDXL is not included because it is not a 2026 architecture.

What does pixel-native mean for HiDream-O1 and Iris-3B?

Standard diffusion models work in a compressed latent space (a lower-dimensional representation) and need a VAE decoder at the end to convert latents back to pixels. The VAE is a separate neural network, takes VRAM, and adds a step to the pipeline. Pixel-native means the transformer works directly in pixel space — no VAE component, no latent-to-image conversion. The model's output is already pixels. This simplifies the ComfyUI workflow (no VAE node), reduces total VRAM (no separate VAE loaded), and makes quantization easier because there is only one component to manage.

Which runner should I use for 2026 image generation models?

ComfyUI for all models. It is a node graph interface where you connect components explicitly — model, text encoder, sampler, output. Every current quantization format and advanced workflow ships for ComfyUI first. Bonsai Image requires the BitNet custom node (available in ComfyUI Manager) because the 1-bit and ternary weight formats are not standard. HiDream-O1 and Iris-3B work with standard loaders but skip the VAE node — connect the model directly to output since they are pixel-native. FLUX.2 klein runs via the standard FLUX ComfyUI workflow, same as the older FLUX.1 models.

11 — Sources

Where each claim came from.

#SourceUsed for
1FLUX.2 klein 4B and 9B model cards (Black Forest Labs, Jan 2026)Release dates (January 15, 2026 for 4B), parameter counts, Apache 2.0 license, sub-second generation claims, VRAM specs, and 4-step distillation
2Bonsai Image 1-bit and Ternary model cards (Feb 2026)0.93GB and 1.21GB sizes, 1-bit and ternary quantization details, BitNet architecture, Apache 2.0 license, 4-step distillation, 5GB VRAM requirement
3HiDream-O1-Image 8B model card (14 May 2026)MIT license, pixel-native unified architecture, 2K native generation, benchmark claims (outscores models 3.4× larger), 8-12GB VRAM range
4Qwen-Image 2.1 model card (20 Sep 2026)7B parameters, Qwen Research License — NON-COMMERCIAL ONLY, text rendering specialization, Q4_K_M 6GB VRAM, comparison to 20B original Qwen-Image
5Iris-3B model card (8 Oct 2026)3B parameters, Apache 2.0 license, pixel-space architecture (no VAE), efficiency claims (matches Qwen-Image despite being 2.3× smaller), 5-8GB VRAM estimate
6BitNet research papers and architecture documentation1-bit and ternary quantization background, binary weights (-1/+1), ternary weights (-1/0/+1), 1.58 bits/weight average for ternary, first application to image generation
7ComfyUI documentation and BitNet custom node repositoryRunner instructions, BitNet loader requirement for Bonsai, pixel-space loader workflow for HiDream-O1 and Iris-3B, standard FLUX workflow for klein models
8GGUF quantization format documentationQ4_K_M as baseline quantization, FP8 for RTX 40/50 series, VRAM reduction math, quality loss comparisons
9This site, GGUF vs EXL2 vs AWQ vs GPTQQuantization vocabulary and hardware-tier guidance referenced in chapter 6
10This site, Text-to-Speech & Speech-to-Text Models 2026Sibling modality guide — same license-first method applied to voice
11Qwen-Image-Bench leaderboard (29-model composite, October 2026)Qwen-Image 2.1 score (60.28, rank 7/29), GPT Image 2.5 Sunburst (67.01), Nano Banana 2.0 (59.82), GPT Image 1.5 (59.65)
12Artificial Analysis image generation leaderboard (October 2026)HiDream-O1-Image 8B rank #8, efficiency claims vs 56B models
13GenEval benchmark — arxiv 2512.16853 (Benchmark drift analysis)17.7% systematic error rate for current models, used in callout warning
14img.ly image generation benchmark (Nano Banana Pro entry)3.13/5.0 overall score, 5.00/5.0 text rendering score
15Iris-3B model card (October 2026) — benchmark sectionGenEval 0.798, DPG-Bench 86.52, OneIG-EN parity with Qwen-Image 7B
16HiDream-O1-Image 8B model card (May 2026) — benchmark sectionOutscores 56B models on GenEval, DPG, HPSv3; parity with 27B Qwen-Image
17img.ly image generation benchmark (full run, October 2026)All img.ly out-of-5.0 scores: GPT Image 2.5 Sunburst (3.27/5.0 overall, 5.0 text, 4.9 prompt, 4.1 composition, $0.036/image, 30.4s); Nano Banana Pro (3.13/5.0, 5.0 text, 3.7 color, 4.6 prompt, 3.6 composition, $0.150/image, 23.3s, 17th of 23); Nano Banana 2.0 (3.45/5.0, 4.96 text, 4.76 prompt, 4.44 composition); Nano Banana 2 Lite (3.58/5.0, 4.78 composition 2nd place, 4.92 text, $0.0336/image, 4.0s latency, 4th of 23); Nano Banana 2.1 (1,050 Elo, $0.0336/image); DALL-E 3 prompt adherence (92% / 9.2 out of 10 on OpenAI Evals)

Assembled 30 October 2026. Licenses change — Apache 2.0, MIT are stable; Qwen Research License is research/non-commercial only and requires separate license for commercial use. Re-read the weights license before shipping, not this page. VRAM figures are practical floors for quantized builds on consumer cards and vary with text encoders, resolution, and runner memory management. Treat them as bands. Bonsai 1-bit size (0.93GB) and sub-second generation for FLUX.2 klein 4B are from model cards; we did not re-benchmark all models on identical hardware. Iris-3B is the newest release (October 8, 2026) and community quantization is ongoing — VRAM estimates are early reports.

Need help with this?

Tell me what you’re working on and I’ll help you work through it — where you got stuck, what you’re trying to build, which model to pick. Your message arrives with this article attached, so I’ll know exactly what you’re reading.

Connect with me on Instagram