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.
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.
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.
| Model | Params | Released | Licence (commercial?) | Min VRAM (quant) | Best at |
|---|---|---|---|---|---|
| FLUX.2 [klein] 4B | 4B | 15 Jan 2026 | Apache 2.0 ✓ | ~5 GB | Sub-second generation, speed |
| FLUX.2 [klein] 9B | 9B | Jan 2026 | Apache 2.0 ✓ | ~8 GB | Higher quality than 4B, still 8GB |
| Bonsai Image 4B 1-bit | 4B | Feb 2026 | Apache 2.0 ✓ | ~5 GB | Smallest download: 0.93GB model |
| Bonsai Image 4B Ternary | 4B | Feb 2026 | Apache 2.0 ✓ | ~5 GB | Better quality than 1-bit, 1.21GB |
| HiDream-O1-Image 8B | 8B | 14 May 2026 | MIT License ✓ | 8–12 GB | Pixel-native 2K, no VAE |
| Qwen-Image 2.1 | 7B | 20 Sep 2026 | Qwen Research License — NON-COMMERCIAL ONLY | ~6 GB (Q4) | Readable text rendering |
| Iris-3B | 3B | 8 Oct 2026 | Apache 2.0 ✓ | ~5–8 GB | Ultra-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
| Metric | Scale | Plain-English meaning | Example |
|---|---|---|---|
| Text Accuracy | / 5.0 | Are 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.0 | Does 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.0 | How many of your instructions are actually followed? | 4.9/5.0 = 98% of what you asked for appears in the image |
| Composition | / 5.0 | Are objects placed where you asked — layout, spatial relationships, framing? | 4.78/5.0 = objects placed exactly as requested ~96% of the time |
| Overall | / 5.0 | Weighted average across all five img.ly dimensions | 3.58/5.0 = strong overall; no single dimension dragging quality down |
| Elo | points | Human preference ranking — higher = people chose this model more often in A/B tests | 1,050 Elo beats 990 Elo by a clear margin humans can see |
| Qwen-Image-Bench | composite | 29-model aggregate: a score of 60 beats all models below 60 on a panel of judge tasks | 60.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:
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.
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
| 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
| Model | Type | Cost per image | 100 images | 1,000 images | 10,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.
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.
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.
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.
09 — Pick by job
The shortest useful table in the article.
| If you want… | Use | Why |
|---|---|---|
| Smallest possible download | Bonsai Image 1-bit | 0.93GB model, runs on 5GB VRAM, Apache 2.0 |
| Sub-second generation on any modern GPU | FLUX.2 klein 4B | <1 sec on RTX 3090/4070, 4 steps, ~5GB total, Apache 2.0 |
| Best image quality on 8GB | FLUX.2 klein 9B or Qwen-Image 2.1 | 9B at ~8GB or 7B at ~6GB, both fit comfortably, both high quality |
| Readable text / posters / signage | Qwen-Image 2.1 | 7B specialist, ~6GB Q4, Qwen Research License — NON-COMMERCIAL ONLY |
| 2K native resolution without a VAE | HiDream-O1-Image 8B | MIT licensed (most permissive), pixel-native, 8-12GB range |
| Ultra-efficient on 5GB VRAM | Iris-3B or Bonsai Ternary | 3B or 4B params, ~5GB total, Apache 2.0, newest and smallest |
| Commercial-safe with zero restrictions | Any Apache 2.0 model | FLUX.2 klein (both), Bonsai (both), Iris-3B — five models |
| Image editing + generation in one | FLUX.2 klein or Qwen-Image 2.1 | Unified 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.
| # | Source | Used for |
|---|---|---|
| 1 | FLUX.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 |
| 2 | Bonsai 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 |
| 3 | HiDream-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 |
| 4 | Qwen-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 |
| 5 | Iris-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 |
| 6 | BitNet research papers and architecture documentation | 1-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 |
| 7 | ComfyUI documentation and BitNet custom node repository | Runner instructions, BitNet loader requirement for Bonsai, pixel-space loader workflow for HiDream-O1 and Iris-3B, standard FLUX workflow for klein models |
| 8 | GGUF quantization format documentation | Q4_K_M as baseline quantization, FP8 for RTX 40/50 series, VRAM reduction math, quality loss comparisons |
| 9 | This site, GGUF vs EXL2 vs AWQ vs GPTQ | Quantization vocabulary and hardware-tier guidance referenced in chapter 6 |
| 10 | This site, Text-to-Speech & Speech-to-Text Models 2026 | Sibling modality guide — same license-first method applied to voice |
| 11 | Qwen-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) |
| 12 | Artificial Analysis image generation leaderboard (October 2026) | HiDream-O1-Image 8B rank #8, efficiency claims vs 56B models |
| 13 | GenEval benchmark — arxiv 2512.16853 (Benchmark drift analysis) | 17.7% systematic error rate for current models, used in callout warning |
| 14 | img.ly image generation benchmark (Nano Banana Pro entry) | 3.13/5.0 overall score, 5.00/5.0 text rendering score |
| 15 | Iris-3B model card (October 2026) — benchmark section | GenEval 0.798, DPG-Bench 86.52, OneIG-EN parity with Qwen-Image 7B |
| 16 | HiDream-O1-Image 8B model card (May 2026) — benchmark section | Outscores 56B models on GenEval, DPG, HPSv3; parity with 27B Qwen-Image |
| 17 | img.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.