FLUX.1

Run FLUX.1 image generation from Black Forest Labs on Clore.ai

Faster alternative! FLUX.2 Klein generates images in < 0.5 seconds (vs 10–30s for FLUX.1) with comparable quality. This guide is still relevant for LoRA training and ControlNet workflows.

State-of-the-art image generation model from Black Forest Labs on CLORE.AI GPUs.

All examples can be run on GPU servers rented through CLORE.AI Marketplace.

Why FLUX.1?

• Best quality - Superior to SDXL and Midjourney v5

• Text rendering - Actually readable text in images

• Prompt following - Excellent instruction adherence

• Fast variants - FLUX.1-schnell for quick generation

Model Variants

Model	Speed	Quality	VRAM	License
FLUX.1-schnell	Fast (4 steps)	Great	12GB+	Apache 2.0
FLUX.1-dev	Medium (20 steps)	Excellent	16GB+	Non-commercial
FLUX.1-pro	API only	Best	-	Commercial

Quick Deploy on CLORE.AI

Docker Image:

ghcr.io/huggingface/text-generation-inference:latest

Ports:

22/tcp
7860/http

For easiest deployment, use ComfyUI with FLUX nodes.

Installation Methods

Method 1: ComfyUI (Recommended)

# Install ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt

# Download FLUX models
cd models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors

# Download required components
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/ae.safetensors

# Run ComfyUI
python main.py --listen 0.0.0.0

Method 2: Diffusers

pip install diffusers transformers accelerate torch

python << 'PYEOF'
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    "A cat wearing a space suit on Mars",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF

Method 3: Fooocus

Fooocus has built-in FLUX support:

git clone https://github.com/lllyasviel/Fooocus
cd Fooocus
pip install -r requirements.txt

# Download FLUX model to models/checkpoints/
python launch.py --listen

ComfyUI Workflow

FLUX.1-schnell (Fast)

Nodes needed:

1. Load Diffusion Model → flux1-schnell.safetensors

2. DualCLIPLoader → clip_l.safetensors + t5xxl_fp16.safetensors

3. CLIP Text Encode → your prompt

4. Empty SD3 Latent Image → set dimensions

5. KSampler → steps: 4, cfg: 1.0

6. VAE Decode → ae.safetensors

7. Save Image

FLUX.1-dev (Quality)

Same workflow but:

• Steps: 20-50

• CFG: 3.5

• Use guidance_scale in prompt

Python API

Basic Generation

import torch
from diffusers import FluxPipeline

# Load model
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Generate
image = pipe(
    prompt="A serene Japanese garden with cherry blossoms",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("output.png")

With Memory Optimization

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)

# Enable optimizations
pipe.enable_model_cpu_offload()  # Saves ~10GB VRAM
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "Portrait of a cyberpunk samurai",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]

Batch Generation

prompts = [
    "A sunset over mountains",
    "A futuristic city at night",
    "An underwater coral reef",
]

images = pipe(
    prompts,
    height=1024,
    width=1024,
    num_inference_steps=4,
).images

for i, img in enumerate(images):
    img.save(f"output_{i}.png")

FLUX.1-dev (Higher Quality)

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Hyperrealistic portrait of an elderly fisherman",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]

Prompt Tips

FLUX excels at:

• Text in images: "A neon sign that says 'OPEN 24/7'"

• Complex scenes: "A busy Tokyo street at night with reflections"

• Specific styles: "Oil painting in the style of Monet"

• Detailed descriptions: Long, detailed prompts work well

Example Prompts

# Photorealistic
A professional photograph of a golden retriever puppy playing in autumn leaves, 
shallow depth of field, warm afternoon light, Canon EOS R5

# Artistic
An impressionist painting of a Parisian cafe in the rain, 
oil on canvas, visible brushstrokes, warm colors

# Text rendering
A vintage movie poster with the title "COSMIC VOYAGE" in bold retro letters,
1960s sci-fi aesthetic, astronaut illustration

# Complex scene
A cozy library interior with floor-to-ceiling bookshelves, 
a leather armchair by a fireplace, rain visible through a window,
warm lamp light, photorealistic

Memory Optimization

For 12GB VRAM (RTX 3060)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # Use fp16 instead of bf16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

# Generate at lower resolution
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]

For 8GB VRAM

Use quantized version or ComfyUI with GGUF:

# In ComfyUI, install GGUF nodes
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

# Download quantized model
wget https://huggingface.co/city96/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-Q4_K_S.gguf

Performance Comparison

Model	Steps	Time (4090)	Quality
FLUX.1-schnell	4	~3 sec	Great
FLUX.1-dev	20	~12 sec	Excellent
FLUX.1-dev	50	~30 sec	Best
SDXL	30	~8 sec	Good

GPU Requirements

Setup	Minimum	Recommended
FLUX.1-schnell	12GB	16GB+
FLUX.1-dev	16GB	24GB+
With CPU offload	8GB	12GB+
Quantized (GGUF)	6GB	8GB+

GPU Presets

RTX 3060 12GB (Budget)

# Use quantized model
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Settings:
# - schnell only (dev may OOM)
# - 512x512 to 768x768
# - 4 steps
# - Batch size 1

RTX 3090 24GB (Optimal)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_vae_tiling()

# Settings:
# - schnell: 1024x1024, batch 2
# - dev: 1024x1024, batch 1
# - 20-30 steps for dev
# - Enable VAE tiling for high-res

RTX 4090 24GB (Performance)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Settings:
# - schnell: 1024x1024, batch 4
# - dev: 1024x1024, batch 2
# - 30-50 steps for best quality
# - Can do 1536x1536 with tiling

A100 40GB/80GB (Production)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Settings:
# - schnell: 1024x1024, batch 8+
# - dev: 1024x1024, batch 4
# - 50 steps for maximum quality
# - 2048x2048 possible

Cost Estimate

GPU	Hourly	Images/Hour
RTX 3060 12GB	~$0.03	~200 (schnell)
RTX 3090 24GB	~$0.06	~600 (schnell)
RTX 4090 24GB	~$0.10	~1000 (schnell)
A100 40GB	~$0.17	~1500 (schnell)

Troubleshooting

Out of Memory

# Use CPU offload
pipe.enable_model_cpu_offload()

# Or sequential CPU offload (slower but less VRAM)
pipe.enable_sequential_cpu_offload()

# Reduce resolution
height=768, width=768

Slow Generation

• Use FLUX.1-schnell (4 steps)

• Enable torch.compile: pipe.unet = torch.compile(pipe.unet)

• Use fp16 instead of bf16 on older GPUs

Poor Quality

• Use more steps (FLUX-dev: 30-50)

• Increase guidance_scale (3.0-4.0 for dev)

• Write more detailed prompts

---

FLUX LoRA

LoRA (Low-Rank Adaptation) weights allow you to fine-tune FLUX for specific styles, characters, or concepts without retraining the full model. Hundreds of community LoRAs are available on HuggingFace and CivitAI.

Installation

pip install diffusers transformers accelerate peft

Loading a Single LoRA

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Load LoRA weights from a local file
pipe.load_lora_weights("path/to/lora.safetensors")

image = pipe(
    "A portrait in the style of Van Gogh, swirling brushstrokes",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")

Loading from HuggingFace Hub

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Load LoRA directly from HuggingFace repo
pipe.load_lora_weights(
    "username/my-flux-lora",          # HF repo ID
    weight_name="my_lora.safetensors" # filename in repo
)

image = pipe(
    "trigger_word a beautiful landscape",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")

LoRA Scale (Strength)

# Control LoRA influence with cross_attention_kwargs
image = pipe(
    "A cyberpunk character, neon lights",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0.0 = no effect, 1.0 = full effect
).images[0]

Combining Multiple LoRAs

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Load first LoRA
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Load second LoRA
pipe.load_lora_weights(
    "path/to/character_lora.safetensors",
    adapter_name="character"
)

# Combine with weights
pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.9])

image = pipe(
    "character_trigger wearing elaborate costume, artistic_trigger style",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")

Unloading LoRA

# Remove LoRA weights to restore base model
pipe.unload_lora_weights()

Training Your Own FLUX LoRA

# Use kohya-ss or ai-toolkit for FLUX LoRA training
git clone https://github.com/ostris/ai-toolkit
cd ai-toolkit
pip install -r requirements.txt

# Prepare dataset: 10-30 images with captions
# Edit config YAML, then:
python run.py config/flux_lora_train.yaml

Recommended LoRA Sources

Source	URL	Notes
CivitAI	civitai.com	Large community library
HuggingFace	huggingface.co/models	Filter by FLUX
Replicate	replicate.com	Browse trained models

---

ControlNet for FLUX

ControlNet allows guiding FLUX generation with structural inputs like canny edges, depth maps, and pose skeletons. XLabs-AI has released the first ControlNet models specifically for FLUX.1.

Installation

pip install diffusers transformers accelerate controlnet-aux pillow

FLUX ControlNet Canny (XLabs-AI)

import torch
import numpy as np
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Load the FLUX ControlNet model (Canny variant)
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)

# Load the pipeline with ControlNet
pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Prepare the control image (canny edges)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# Generate with ControlNet guidance
image = pipe(
    prompt="A futuristic cityscape with neon signs, photorealistic, 8K",
    control_image=control_image,
    controlnet_conditioning_scale=0.7,
    num_inference_steps=25,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(0),
).images[0]

image.save("controlnet_flux_output.png")

FLUX ControlNet Depth

import torch
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from transformers import pipeline as hf_pipeline

# Load depth estimator
depth_estimator = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# Prepare depth map
input_image = load_image("portrait.jpg").resize((1024, 1024))
depth_result = depth_estimator(input_image)["depth"]
depth_image = depth_result.convert("RGB")

# Load ControlNet Depth
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="A marble statue of a warrior, dramatic lighting, museum photo",
    control_image=depth_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("depth_controlnet_output.png")

Multi-ControlNet for FLUX

import torch
from diffusers import FluxControlNetPipeline, FluxMultiControlNetModel, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Load multiple ControlNets
controlnet_canny = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)
controlnet_depth = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

# Combine into MultiControlNet
multi_controlnet = FluxMultiControlNetModel([controlnet_canny, controlnet_depth])

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=multi_controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="A knight in armor standing in a forest, dramatic lighting",
    control_image=[canny_image, depth_image],
    controlnet_conditioning_scale=[0.7, 0.5],
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]

Available FLUX ControlNet Models

Model	Repo	Use Case
Canny	XLabs-AI/flux-controlnet-canny-diffusers	Edge-guided generation
Depth	XLabs-AI/flux-controlnet-depth-diffusers	Depth-guided generation
HED/Soft Edge	XLabs-AI/flux-controlnet-hed-diffusers	Soft structural control
Pose	XLabs-AI/flux-controlnet-openpose-diffusers	Pose-guided portraits

ControlNet Tips

• conditioning_scale 0.5–0.8 works best for FLUX (too high loses creativity)

• Use 1024×1024 or multiples for best quality

• Combine with LoRA for style + structure control

• Lower steps (20–25) is usually sufficient with ControlNet

---

FLUX.1-schnell: Fast Generation Mode

FLUX.1-schnell is the distilled, speed-optimized variant of FLUX. It generates high-quality images in just 4 steps (vs 20–50 for FLUX.1-dev), making it ideal for rapid prototyping and high-throughput workflows.

Key Differences vs FLUX.1-dev

Feature	FLUX.1-schnell	FLUX.1-dev
Steps	4	20–50
Speed (4090)	~3 sec	~12–30 sec
License	Apache 2.0 (free commercial)	Non-commercial
guidance_scale	0.0 (no CFG)	3.5
Quality	Great	Excellent
VRAM	12GB+	16GB+

License note: FLUX.1-schnell is Apache 2.0 — you can use it in commercial products freely. FLUX.1-dev requires a separate commercial license from Black Forest Labs.

Quick Start

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="A stunning aerial view of New York City at golden hour, photorealistic",
    height=1024,
    width=1024,
    num_inference_steps=4,   # Only 4 steps needed!
    guidance_scale=0.0,       # CFG disabled for schnell
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("Generated in ~3 seconds on RTX 4090!")

High-Throughput Batch Generation

import torch
from diffusers import FluxPipeline
from pathlib import Path

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")  # Keep on GPU for speed, don't use cpu_offload

output_dir = Path("schnell_outputs")
output_dir.mkdir(exist_ok=True)

prompts = [
    "A serene mountain lake at dawn, misty atmosphere",
    "A bustling Tokyo street market at night, neon reflections",
    "A macro photograph of a dew-covered spider web",
    "An ancient library with floating books and magical light",
    "A futuristic underwater city with bioluminescent sea life",
]

# Batch generation
for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        height=1024,
        width=1024,
        num_inference_steps=4,
        guidance_scale=0.0,
        generator=torch.Generator(device="cuda").manual_seed(i),
    ).images[0]
    image.save(output_dir / f"image_{i:04d}.png")
    print(f"Generated {i+1}/{len(prompts)}: {prompt[:50]}...")

Multiple Aspect Ratios with schnell

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# FLUX supports flexible aspect ratios
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "A majestic wolf in a snowy forest, professional wildlife photography"

for name, (width, height) in resolutions.items():
    image = pipe(
        prompt=prompt,
        height=height,
        width=width,
        num_inference_steps=4,
        guidance_scale=0.0,
    ).images[0]
    image.save(f"schnell_{name}.png")
    print(f"Saved {name}: {width}x{height}")

schnell with Memory Optimizations

import torch
from diffusers import FluxPipeline

# For 12GB VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 saves memory on older GPUs
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="A cozy cabin in autumn forest, warm light through windows",
    height=768,
    width=768,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]
image.save("schnell_low_vram.png")

Performance Benchmarks (schnell)

GPU	VRAM	Time/image (1024px)	Images/hour
RTX 3060 12GB	12GB	~8 sec	~450
RTX 3090 24GB	24GB	~4 sec	~900
RTX 4090 24GB	24GB	~3 sec	~1200
A100 40GB	40GB	~2 sec	~1800

When to Use schnell vs dev

Use FLUX.1-schnell when:

• Rapid prototyping / testing prompts

• High-volume batch generation

• Commercial projects (Apache 2.0)

• Limited GPU budget

• Real-time or near-real-time applications

Use FLUX.1-dev when:

• Maximum image quality is priority

• Fine detail and complex scenes

• Research / artistic work

• Combining with LoRA/ControlNet (dev tends to respond better)

---

Next Steps

• ComfyUI - Best interface for FLUX

• Fooocus - Simple alternative

• ControlNet - Guided generation

• Kohya Training - Train FLUX LoRAs