Flux by Black Forest Labs Builder's image pick

The Black Forest Labs origin story

The Flux story starts in Munich in 2022, inside Stability AI's research team. Robin Rombach, Andreas Blattmann, Patrick Esser, and Dominik Lorenz were the core researchers behind Stable Diffusion — the model that put open-source image generation on the map. In early 2024, the team departed Stability AI and founded Black Forest Labs (BFL) with backing from Andreessen Horowitz. Their pitch was direct: take everything they'd learned building and shipping Stable Diffusion, fix what SD got wrong, and rebuild the model architecture from scratch.

The result — FLUX.1 — landed in August 2024 in three simultaneous variants: [schnell] (fast, open weights, Apache 2.0), [dev] (higher quality, open weights, non-commercial), and [pro] (best quality, API-only, commercial). The release immediately attracted attention not just for its output quality but for the architecture underneath: a hybrid transformer combining multimodal and parallel diffusion transformer blocks, trained at 12 billion parameters. That's roughly double the scale of SDXL. The size paid off in ways you could see immediately — portraits that looked photographic, text in images that was legible, prompt adherence that actually tracked complex multi-object descriptions.

By October 2024, BFL released FLUX1.1 [pro] with a 2x speed increase and measurable quality jump, followed by Ultra and Raw modes — Ultra pushing output to 4 megapixels, Raw tuned for candid, documentary-style photorealism without the "AI polish" sheen. Then in November 2025, FLUX.2 [dev] arrived: a full architectural generation update at 32B parameters, with native image editing, multi-reference support, and NVIDIA-optimized FP8 inference that cut VRAM requirements by roughly 40%. BFL closed a $300M Series B in December 2025, valuing the company at over $6B, and by January 2026 had shipped FLUX.2 [klein] — a distilled, Apache 2.0-licensed variant built for real-time generation.

This is not a hobby project. This is the same team that built Stable Diffusion, with more resources, a clean slate, and a commercial mandate. That context matters when evaluating every output you get from a Flux model.

What Flux actually is

Flux is a text-to-image diffusion model family — you give it a text prompt, it gives back a photographic-quality image. What separates it from every predecessor is a combination of scale (12B–32B parameters), a novel hybrid-transformer architecture, and a training methodology that produces unusually tight correspondence between what you write and what you get.

At the technical level, Flux uses a rectified flow transformer architecture — a departure from the U-Net backbone that defined Stable Diffusion 1.x and SDXL. Rectified flow simplifies the diffusion path between noise and image, which translates to faster inference at equivalent quality and better gradient flow during training. The multimodal transformer blocks attend jointly over image patches and text tokens, meaning the model's "understanding" of your prompt and its internal image representation are tightly coupled throughout the generation process, not just at the conditioning step.

The practical consequence of that architecture: if you write a 200-word prompt describing the exact pose, lighting, color palette, and background of a scene, Flux will honor it with a degree of fidelity that competitors struggle to match. You're not prompt-engineering around the model's limitations — you're describing what you want.

The model family in 2026

The FLUX lineup has two generations. Understanding the split is worth the two minutes it takes.

FLUX.1 — the original generation

Three models, each with a different availability and use-case profile:

• FLUX.1 [schnell] — 12B parameters, Apache 2.0 open weights. The fastest Flux model, designed for 4-step generation. Free to download and run locally via Hugging Face, free to use commercially, free to fine-tune. The entry point for anyone who wants to self-host. Output quality is strong for a 4-step model but noticeably below [dev] and [pro] on detail and fidelity.
• FLUX.1 [dev] — 12B parameters, open weights with a non-commercial license. Better quality than [schnell] at 20–50 steps. Free for personal and research use, fine-tunable (LoRA training is the primary workflow for the open-source community). Commercial use requires a separate agreement with BFL. This is the model powering most of the community LoRAs, style adapters, and fine-tunes you see on Hugging Face and Civitai.
• FLUX.1 [pro] — API-only, commercially licensed, no weights released. Best quality of the three, optimized for production. Available via the BFL API, fal.ai, Replicate, and other inference platforms. $0.04/image on the BFL API as of 2026.

FLUX1.1 [pro] — the first quality jump

Released October 2024, FLUX1.1 [pro] added a 2x speed improvement and a quality uplift verified by third-party benchmarks. Two modes on top of the base model:

• Ultra — generates at up to 4 megapixels (versus FLUX1.1 [pro]'s standard ~1MP), 10 seconds per sample. The tool of choice for anything that needs to be printed or displayed large. $0.06/image on the BFL API.
• Raw — same pricing, different character. Raw mode targets a documentary, candid-photography aesthetic: less studio-polished, more "someone actually photographed this." Useful for anything that would look over-produced with standard settings — street photography styles, journalistic compositions, authentic lifestyle imagery.

FLUX.2 — the 2025–2026 generation

The full-generation update, built on a 32B architecture with native editing capabilities:

• FLUX.2 [dev] — 32B open weights (non-commercial license), available on Hugging Face since November 2025. The most powerful open-weight image model currently available. NVIDIA collaboration reduced VRAM requirements via FP8 optimization; runs on a single high-VRAM consumer GPU with optimized implementations.
• FLUX.2 [pro] — API-only, production-optimized. Enhanced prompt understanding, multi-reference image support (up to 10 reference images simultaneously). $0.03/image.
• FLUX.2 [flex] — Configurable quality-speed trade-off for fine-tuning and style exploration. $0.06/image.
• FLUX.2 [max] — Studio-grade quality tier, native 4MP output. $0.07/image.
• FLUX.2 [klein] — Apache 2.0 open weights, distilled for speed, capable of sub-second generation. Released January 2026. The replacement for [schnell] in the open/free tier.

flux · flux-render.png

First impressions using Flux

The fastest way to see what Flux can do without spending anything: fal.ai's playground, which lets you run FLUX.1 [schnell] for free on their infrastructure. You type a prompt, hit generate, and an image comes back in about 3–5 seconds. No account required for casual testing.

The first thing that stands out is how literally Flux interprets your prompt. Type "a barista with red hair and silver earrings pouring latte art in a sunlit cafe" and you get exactly that — red hair, earrings visible, latte art that actually looks like latte art, window light from the direction you'd expect. This isn't remarkable to describe, but it's remarkable in practice. Earlier models — including Stable Diffusion XL — would catch some elements and drop others. Flux catches everything in a 30-word prompt without you needing to reorder it, weight elements with brackets, or add negative prompts to suppress artifacts.

The second thing that hits you is resolution. Even the schnell model generates at 1024×1024 with a level of crispness and edge definition that older SD variants needed ControlNet extensions to approach. Hair strands are individually defined. Fabric textures are coherent. Hands — historically AI's most reliably broken output — are correct more often than not.

Move to FLUX1.1 [pro] Ultra and the gap to professional photography becomes difficult to articulate. The level of detail at 4MP is not "this looks like a photo"; it's "I would need metadata to confirm this isn't a photo."

Photorealism: where Flux dethroned Stable Diffusion

Stable Diffusion's photorealism ceiling was always a negotiation between the base model, checkpoint merges, LoRA stacking, and samplers. Power users built elaborate workflows to approach photographic quality. Beginners got muddy, over-saturated outputs that screamed "AI."

Flux changed this in two ways. First, the base model is dramatically better at physical coherence — lighting behaves like light, materials behave like materials, depth of field follows optics. You don't need a "photorealism" LoRA to get photographic output; you need a clear prompt. Second, the scale (12B–32B parameters) brings a richness of world knowledge that smaller models simply can't access. Flux has seen enough photographs during training to understand what skin looks like under different lighting, what a worn leather jacket looks like versus a new one, what the bokeh of a 50mm f/1.4 looks like versus a phone camera.

In third-party benchmarks run through early 2026, FLUX.2 [pro] and [max] rank first among accessible image models for photographic realism — ahead of Midjourney V8 on technical metrics (LPIPS perceptual similarity, FID for natural photography) even while Midjourney retains its lead on subjective "beautiful output" scores.

Text rendering: the feature that surprised everyone

Generating legible, correctly spelled text inside an image was the AI image generation community's longest-standing joke. Stable Diffusion would produce signs with letter soup. Midjourney would give you glyphs that looked vaguely like English from a distance and fell apart on inspection. Every model had this problem.

Flux addressed it through architectural changes and scale — the transformer's joint attention over text and image tokens makes character rendering a first-class part of the generation process rather than an afterthought. FLUX.2 [flex] and [pro] claim roughly 60% accuracy on first-attempt legible typography, which is dramatically better than predecessors even if it's not Ideogram-level reliability.

In practice, this means: short words on clean backgrounds (product labels, poster headlines, simple signs) work consistently. Longer sentences, stylized fonts at small sizes, or text on complex backgrounds still require multiple attempts. The gap to Ideogram — which was purpose-built for text-in-image work and remains the category leader at ~95% accuracy — is real. But Flux is now usable for most everyday text-in-image tasks, which is a category shift from "impossible" to "usually works."

flux · flux-ui.png

Prompt adherence: the real competitive moat

Prompt adherence is the metric that matters most for professional use, and it's where Flux has the clearest technical lead over everything except DALL-E 3 in the conversational pipeline. The architecture's joint attention mechanism means the model processes your text description and the image it's building simultaneously, checking correspondence throughout generation rather than only at the conditioning step.

The practical test: describe a scene with four distinct visual elements — a specific person type, an action, a setting, and a lighting condition. Run the same prompt on Flux, Midjourney, and SD 3.5. Flux will hit all four. Midjourney will frequently reinterpret the aesthetic and drop the least "beautiful" element. SD 3.5 will sometimes confuse spatial relationships. This isn't cherry-picking — it's consistent across thousands of documented community comparisons.

For marketing teams, product photographers, and UI designers, this difference is the difference between "AI tool that saves me 30 minutes" and "AI tool that actually does the job." When your brief says "CEO in a navy suit standing at the window of a modern office, late afternoon backlight, shallow depth of field" — you need all of that in the output, not a reinterpretation of the vibes.

Three real workflows, end-to-end

Open weights vs API: the choice that matters

Flux is unusual in the AI image space because you have a genuine choice: run the model yourself, or pay per image through an API. Neither option is objectively correct — the right answer depends on your volume, technical appetite, and use case.

Running Flux locally

FLUX.1 [schnell], FLUX.1 [dev], FLUX.2 [dev], and FLUX.2 [klein] are all available on Hugging Face with open weights. Local inference works well on a GPU with 16–24GB VRAM for FLUX.1 models, and on high-VRAM consumer cards (24GB+) for FLUX.2 [dev] with FP8 optimization. ComfyUI is the dominant workflow tool — a node-based interface where you chain together sampling, LoRA loading, conditioning, and upscaling into a visual pipeline. The community has built thousands of public ComfyUI workflows for every conceivable Flux use case.

The licensing rules for local use: [schnell] and [klein] are Apache 2.0 — no restrictions, including commercial. [dev] models carry a non-commercial license by default; commercial use requires a separate agreement with BFL (tiered by volume). FLUX.2 [dev] weights on Hugging Face are gated — you agree to the license before downloading, and BFL can verify you have the right agreement in place before using commercially.

Using the API

For developers who don't want to manage GPU infrastructure, the API is straightforward: send a prompt (and optionally reference images), receive a URL to a generated image, pay per image. Three main platforms:

• BFL API (api.bfl.ai) — direct from Black Forest Labs. Full model lineup. Pay-as-you-go, no subscriptions. FLUX.1 [pro] at $0.04/image; FLUX1.1 [pro] Ultra at $0.06/image; FLUX.2 [pro] at $0.03/image; FLUX.2 [max] at $0.07/image.
• fal.ai — fast cold starts, generous free tier for testing, strong uptime. FLUX.1 [schnell] at $0.003/megapixel; FLUX.1 Kontext [pro] at $0.04/image. Popular for developer integrations due to clean SDK and webhook support.
• Replicate — broader model catalog alongside Flux, pay-per-second pricing that can be slightly cheaper for fast models, higher latency variance than fal.ai.

Pricing and licensing in full

Flux has no subscription tier and no free managed service — it's either open weights (free to run, license restrictions apply) or pay-per-image API. Here's the full picture as of mid-2026:

Open weights (self-hosted)

• FLUX.1 [schnell] — free, Apache 2.0, commercial. Best for: fast previews, high-volume local pipelines, distillation research.
• FLUX.1 [dev] — free for non-commercial, personal, and research use. Commercial license: tiered, contact BFL. Best for: LoRA training, community experiments, personal creative work.
• FLUX.2 [dev] — same commercial terms as [dev]. 32B parameters; requires high-VRAM GPU (24GB+). Best for: highest-quality open-weight generation, research, custom fine-tuning.
• FLUX.2 [klein] — free, Apache 2.0, commercial. Distilled for speed. Best for: real-time generation, mobile pipelines, zero-budget prototyping.

BFL API (pay-as-you-go)

• FLUX.1 [pro] — $0.04/image
• FLUX1.1 [pro] — $0.04/image
• FLUX1.1 [pro] Ultra / Raw — $0.06/image
• FLUX.2 [pro] — $0.03/image
• FLUX.2 [flex] — $0.06/image
• FLUX.2 [max] — $0.07/image

For comparison: Midjourney Basic ($10/mo) gives approximately 200 images per month — roughly $0.05/image. At FLUX.2 [pro] pricing ($0.03), you break even around 330 images/month. Above that volume, Flux is cheaper, API-accessible, and less restricted in output style.

flux · flux-text.png

Flux vs Midjourney

Where Flux gets it wrong

No tool review is honest without this section. Flux has real limitations that matter.

Text rendering is better, not great

The 60% first-attempt accuracy on text sounds promising until you're on deadline and need a hero image with a specific tagline. On complex typography — multiple lines, stylized fonts, text on curved surfaces — you'll spend more time iterating than Ideogram would require. Flux is not the specialist here. Use Ideogram when text precision is the whole job.

No native interface — you bring your own

Midjourney gives you a beautiful web gallery, variation controls, and a community feed. Flux gives you an API or a model weight. Everything else — the interface, the gallery, the workflow — you build or borrow. fal.ai and BFL's playground fill some of this gap, but the experience is spartan versus Midjourney's polished product. This is a feature for developers and a real limitation for non-technical creatives.

Artistic styles require LoRAs — base model is photorealism-default

Ask Flux for an oil painting, a watercolor study, or a specific illustration aesthetic and the base model gives you something workable but generic. Midjourney's aesthetic engine produces gallery-quality stylized output from short prompts. With Flux, stylized work requires either a fine-tuned LoRA (takes setup and training budget) or a FLUX.2 [flex] workflow with careful prompting and steps configuration. The payoff is better control and consistency once you have the LoRA — but the entry cost is real.

VRAM requirements for local FLUX.2

FLUX.2 [dev] at 32B parameters is not a casual local inference model. You need 24GB+ VRAM with FP8 optimization, or you're running it very slowly or quantized. FLUX.1 models run acceptably on 16GB cards. FLUX.2 [klein] is the practical answer for budget hardware, but it's a meaningful capability trade-off from [dev]. The community is actively building quantization and optimization tooling — this constraint will loosen over the coming year.

Consistency across generations without LoRA

Generate the same person, character, or branded element twice with Flux and you'll get two different faces without a LoRA or reference image. FLUX.2 [pro]'s multi-reference support helps significantly — feeding a reference image constrains the output. But pure text-to-image consistency for characters is a known limitation across all current diffusion models, Flux included.

What's next for Flux

flux · flux-api.png

Who is Flux for

After spending time across the model family, the user profile becomes clear.

Flux is the right tool if you are a developer integrating image generation into a product, a marketing team generating product photography and campaign assets at scale, a designer who needs precise prompt control and consistent output for a brand, a researcher or artist who wants to fine-tune a model on their own visual style, or anyone who generates enough images per month that per-image pricing beats a subscription.

Flux is probably not your first stop if you are a creative who wants to explore AI art aesthetics with short prompts and zero setup, someone who wants to browse community inspiration and do image variations in a social feed, or a non-technical user who finds API keys and ComfyUI workflows intimidating. That person should start with Midjourney or DALL-E.

• Developer building an image generation feature in a SaaS product
• Marketing team that needs 100+ product lifestyle shots a month
• Designer who needs consistent brand character assets via LoRA
• Researcher exploring open-weight model fine-tuning and training
• Anyone who generates 300+ images/month and wants API access

• Non-technical creatives who want a polished web gallery experience
• Users who primarily want stylized, painterly, or "AI aesthetic" art
• Anyone who needs near-perfect typographic text in images (use Ideogram)
• Teams that need zero-infrastructure setup and a single monthly bill

Alternatives at a glance

FAQ

The verdict