Skip to content

FLUX.1 Text-to-Image: dev and schnell Local Deployment ​

FLUX.1 is a text-to-image model from Black Forest Labs—a company founded by former Stable Diffusion team members. The official tutorial introduces it as one of the largest open-source text-to-image models, with 12B parameters and raw files of about 23GB, known for outstanding image quality and flexibility. Architecturally, it combines the strengths of both Transformer and diffusion models.

This page walks you through running the official FLUX workflow from start to finish: first distinguish between the two open-source versions, dev and schnell; then use the "full four-file set" to generate your first image; and finally see how low-VRAM devices can use the fp8 single-file version.

What You'll Be Able to Do After This Lesson ​

  • Distinguish the positioning and licenses of the three FLUX.1 siblings (Pro / dev / schnell), and know which one to choose for local deployment
  • Run the full FLUX.1 dev workflow: four model files each in its place, image generated in 20 steps
  • Switch to schnell with one move: swap only the diffusion model, change the steps to 4, and roll images at high speed
  • Run FLUX on low-VRAM devices with the fp8 single-file checkpoint—only one model file to install
  • Remember FLUX's ironclad parameters: cfg 1, no negative prompt, euler + simple

Your Current Struggles ​

  • You've heard FLUX has top-tier image quality, but the weights start at 20GB, and you don't know if your GPU and disk can handle it
  • You downloaded the official template, but with DualCLIPLoader's two dropdowns you don't know which slot takes clip_l and which takes t5xxl
  • You carry over SD1.5 habits: crank cfg to 7 and write aggressive negative prompts—FLUX completely ignores them

When to Use This Technique ​

When you need:

  • Outstanding image quality and "draw what you write" prompt adherence—even complex prompts are faithfully rendered
  • To run a flagship open-source model locally, without depending on or paying for closed-source APIs
  • Either refined generation (dev, 20 steps) or high-speed image rolling (schnell, 4 steps)

And you don't want to:

  • To be scared off by 23GB weights on a low-VRAM machine—the fp8 single-file version in Step 6 is the solution
  • To fiddle with negative prompts—the official FLUX workflow doesn't use them at all

🎒 Preparation Before Starting ​

  • You've completed your first image generation: you know how to load a workflow, write a prompt, and run it with Ctrl+Enter
  • You're clear on the model directory rules: what goes in diffusion_models, text_encoders, vae, and checkpoints (if you forget, review where models go)
  • Reserve about 32GB of disk space for the full dev four-file set; the fp8 single-file version only needs room for one file
  • If you want the dev version: your Hugging Face account is logged in and you've agreed to the FLUX.1-dev repository license (non-commercial); schnell is Apache 2.0 with no such barrier
  • Your network can reach Hugging Face; if the connection is unstable, use the ModelScope mirror in China (address given in Step 2)
  • ComfyUI is updated to the latest version (a reminder at the start of the official tutorial)
  • A cup of water ☕—the biggest wait in this lesson is downloading the models

Core Idea ​

FLUX.1 uses a "hybrid architecture." Officially, it combines the strengths of Transformer networks and diffusion models: text and image information are effectively integrated within the model, generated images align precisely with prompts, and complex prompts are rendered especially well. The 12B parameters capture more complex patterns and relationships, producing more realistic and diverse images with a wide range of adaptable styles.

How the three siblings split the work (this page runs the latter two):

VersionLicenseCharacteristicsHow to Obtain
FLUX.1 ProClosed-sourceThe best-performing flagshipAPI access only
FLUX.1 devopen source, non-commercialdistilled from Pro, performance close to Prodownload from Hugging Face, requires agreeing to the license
FLUX.1 schnellApache 2.0distilled, accelerated version, 4 steps to generate an image, suitable for low-end hardwaredirect download from Hugging Face

Two deployment routes (this is exactly how the official tutorial divides them):

RouteWhat to installImage qualityVRAMSuitable for
Full version (four-piece set)diffusion model + two text encoders + VAE installed separatelyBestHigher requirementsAmple VRAM, want the best prompt adherence
fp8 single-file checkpointone fp8 quantized fileSlightly below the full versionLower requirementsLimited VRAM, want to get running quickly

Why is cfg fixed 1 with no negative prompt? From the official tutorial's own words: thanks to FLUX's excellent prompt adherence, no negative prompt is needed. So the official template zeroes out the negative conditioning directly with a ConditioningZeroOut node, and cfg is fixed 1 — the sticky note in the schnell template even specifically reminds you: set cfg to 1.0, and the negative prompt will be ignored.

Workflow skeleton (full version; two more loaders than the single-checkpoint workflow):

UNETLoader (diffusion model)──────────────────────────→ KSampler ──→ VAEDecode ──→ SaveImage
DualCLIPLoader (clip_l + t5xxl)──→ CLIPTextEncode (your prompt)──→ KSampler (positive)
                                        └──→ ConditioningZeroOut ──→ KSampler (negative, zeroed out)
VAELoader (VAE) ──────────────────────────────────────────────→ VAEDecode
EmptySD3LatentImage (1024×1024 empty canvas)───────────────────────→ KSampler

Follow along ​

Step 1: Load the official FLUX workflow ​

Why: In the official template library, the FLUX.1 text-to-image template comes with parameters and model links already configured, which is much faster than wiring things up from scratch.

How: Open the template library from Templates in the left sidebar, search for Flux.1; this lesson's main thread uses this one:

Template nameTemplate IDContents
Flux.1 dev-only: text to imageflux_dev_full_text_to_imagedev full version, 20 steps

If you don't want to use the template library, download the JSON directly and open it via the menu Workflows → Open (Ctrl+O): flux_dev_full_text_to_image.json. See Template Library for the full walkthrough of the template library.

You should see: On the canvas there is a subgraph node named Text to Image (Flux.1 Dev), with common parameters like prompt, width/height, seed, and model filename exposed on the node surface, plus a sticky note (MarkdownNote) full of model download links next to it.

  • The dev full-version workflow loaded on the canvas

Step 2: Download the dev full-version four-piece set and put them in place ​

Why: The full version is not packaged as a single checkpoint; the four files are installed separately. Put them in the wrong subdirectory and the files won't show up in the loader's dropdown list.

How: Download the four files from Hugging Face (the template's sticky note includes the official download links):

FileSizeWhich subdirectory to put it inDownload
flux1-dev.safetensors22.17 GBmodels/diffusion_models/Hugging Face
clip_l.safetensors234.7 MBmodels/text_encoders/Hugging Face
t5xxl_fp16.safetensors9.12 GBmodels/text_encoders/Hugging Face
ae.safetensors319.8 MBmodels/vae/Hugging Face

The directory structure looks like this:

ComfyUI/
├── models/
│   ├── diffusion_models/
│   │   └── flux1-dev.safetensors
│   ├── text_encoders/
│   │   ├── clip_l.safetensors
│   │   └── t5xxl_fp16.safetensors
│   └── vae/
│       └── ae.safetensors

💡 Downloading in China and low-VRAM substitutions

  • ModelScope has official mirrors: the diffusion model repository Comfy-Org/flux1-dev and Comfy-Org/Lumina_Image_2.0_Repackaged where the VAE lives; the template's sticky note includes links to both.
  • Less than 32GB of VRAM: the official tutorial suggests switching to the fp8 text encoders to save VRAM; the one listed in the template's sticky note is t5xxl_fp8_e4m3fn_scaled.safetensors (4.8 GB), with the other files unchanged.

⚠️ You must agree to the license before using the dev version

The dev weights on Hugging Face require you to log in and agree to the FLUX.1-dev license (non-commercial) before downloading — the official tutorial specifically reminds you: if the download fails, check these two things first. schnell is Apache 2.0 and has no such barrier.

Once everything is in place, press r on the canvas to refresh, then select the corresponding files in the subgraph's model dropdowns (or inside the subgraph's loader nodes). If you're unsure which file goes in which slot, go back to the comparison table in Where to Put Models.

You should see: all red missing-file warnings are gone, and every loader shows the correct filename.

  • All four files in place, with files selected in every loader

Step 3: Understand the nodes and parameters of the FLUX workflow ​

Why: The prerequisite for tuning parameters is knowing what each node does and why its defaults are what they are.

How: Double-click to enter the subgraph and go through it node by node against this table:

NodeWhat it doesKey parameters in the template
UNETLoader (Load Diffusion Model)Loads the diffusion model itself (12B)flux1-dev.safetensors
DualCLIPLoaderLoads two text encoders at onceFirst slot clip_l.safetensors, second slot t5xxl_fp16.safetensors, type flux
VAELoader (Load VAE)Loads the VAEae.safetensors
CLIPTextEncodeEncodes the prompt into a conditionConnect to KSampler's positive
ConditioningZeroOutZeroes out the negative conditionFLUX cfg=1, no negative prompt needed
EmptySD3LatentImageCreates an empty canvas1024×1024, batch 1
KSamplerDenoising sampler20 steps, cfg 1, euler, simple, denoise 1.0
VAEDecodeDecodes latent space into pixels—
SaveImagePreview and saveFiles land in ComfyUI/output/

The order of the two slots in DualCLIPLoader matters: the recipe stated in the ComfyUI source code is flux type = clip-l, t5—put clip_l in the first slot and t5xxl in the second, and choose flux for type.

You should see: From left to right you can state each node's responsibility, and the KSampler parameters match the table above.

  • I can state which loader loads each of the four components and what KSampler's key parameters are

Step 4: Write a prompt and generate your first dev image ​

Why: FLUX's signature strength is prompt adherence—the more specific your prompt, the more faithfully the image is rendered, and no negative prompt is needed.

How to do it:

  1. Write a prompt in the subgraph's prompt box. The example that comes with the official template:
text
A fairy tale scene of a young girl with silver curly hair wearing a delicate white dress, standing among crystal butterflies and glowing glass roses. The scene is filled with soft magical light, like a dream from a fantasy world.
  1. The default size is 1024×1024; to change the aspect ratio, edit the subgraph's width / height
  2. Click Run, or press Ctrl+Enter

You should see: The progress bar runs through 20 steps and the SaveImage node outputs an image—the picture contains the elements described in the prompt: a silver-haired girl, a white dress, crystal butterflies, glowing glass roses, like a fairy-tale scene.

  • The first image generated by FLUX.1 dev appears in SaveImage

Step 5: Switch to schnell—4-step fast image generation ​

Why: schnell goes further along the distillation path: 4 steps produce a good image, and the license is still the permissive Apache 2.0. The official tutorial notes: compared with the dev version, the schnell workflow differs only in the model file.

How to do it:

  1. Additionally download flux1-schnell.safetensors (22.15 GB) into models/diffusion_models/, repository: Comfy-Org/flux1-schnell (ModelScope mirror). Keep the text encoders and VAE from step 2 (the official template defaults to t5xxl_fp16; the docs also mention that schnell can use the fp8 version of t5xxl to save VRAM, while fp16 gives better quality)
  2. Choose either of the two ways to run it:

Option A: Load the schnell full-version template (recommended) ​

Search Flux.1 in the template library and choose "Flux.1 Schnell Full: Text to Image" (flux_schnell_full_text_to_image). Its prompt node is CLIPTextEncodeFlux: the prompt is split into clip_l and t5xxl fields—you can write different content in each; the official example uses two different descriptions—plus a guidance parameter, which the template defaults to 3.5.

Option B: Keep the dev workflow and change two places ​

Change the UNETLoader to flux1-schnell.safetensors, and KSampler steps 20 → 4. Leave everything else unchanged.

  1. Click Run

You should see: The progress bar finishes in only 4 steps and outputs an image—visibly faster. The official positioning of schnell is a fast version that even low-end hardware can run.

  • The schnell version runs successfully, producing an image in 4 steps

Step 6: Low on VRAM? Use the fp8 single-file checkpoint ​

Why: The fp8 single-file version packages the diffusion model, text encoders, and VAE into one quantized checkpoint—only one file is needed and VRAM requirements are lower, at the cost of slightly reduced image quality versus the full version. The official positioning is a single-file entry option for devices with limited VRAM.

How to do it:

VersionDownloadPut intoLoading nodeSteps
schnell fp8flux1-schnell-fp8.safetensorsmodels/checkpoints/Load Checkpoint4
dev fp8flux1-dev-fp8.safetensorsmodels/checkpoints/Load Checkpoint20 (same as the full version)
  1. For schnell fp8, just use the template: search Flux.1 in the template library and choose "Flux.1 Schnell FP8" (flux_schnell). Its structure is exactly the single-checkpoint version: one CheckpointLoaderSimple node outputs MODEL / CLIP / VAE, the negative prompt box is left empty, and KSampler uses 4 steps with cfg 1
  2. Manually set up the dev fp8 following the official tutorial: download flux1-dev-fp8.safetensors and put it into models/checkpoints/, then load it with a Load Checkpoint node. The easiest setup: copy the schnell fp8 template, swap the checkpoint to flux1-dev-fp8.safetensors, and change the steps back to 20
  3. Click Run

⚠️ Don't be misled by this template name

There is also a "Flux.1 dev-only fp8: text-to-image" template in the template library (flux_dev_checkpoint_example) — the name contains fp8, but the actual template content is a full four-file workflow with the same structure as step 1 (also 20 steps). To run the single-file dev version, manually modify it as described in item 2 above; don't count on this template.

You should see: only a single checkpoint loader remains on the canvas (no longer a row of loaders), and a new file in checkpoints/ is enough to generate an image.

  • The fp8 single-file version runs successfully, and the file is placed in models/checkpoints/

Checkpoints ✅ ​

  • The dev full version runs successfully: load template → four files in place → generate in 20 steps
  • schnell runs successfully: swap the diffusion model + 4 steps, or just use the schnell template
  • I know that cfg 1 and not writing a negative prompt are FLUX's design, not a broken workflow
  • The fp8 single-file version's file is placed in models/checkpoints/, not diffusion_models/
  • I can state the differences between dev (non-commercial, 20 steps) and schnell (Apache 2.0, 4 steps)

Pitfall warnings ​

❌ Cranking cfg up high and writing lots of negative prompts ​

Reason: in the official FLUX workflow, cfg is fixed at 1 and negative conditioning is zeroed out by ConditioningZeroOut; the schnell template note says verbatim — set cfg to 1.0 and the negative prompt is simply ignored. Correct approach: keep cfg at 1 and put all your effort into describing the image in the positive prompt.

❌ dev model download rejected (401 / 403) ​

Reason: FLUX.1 dev is under a non-commercial license, so on Hugging Face you must first log in and agree to the repository terms. Correct approach: log in to your account, go to the repository and agree to the terms before downloading; or use the ModelScope mirror (step 2). schnell (Apache 2.0) has no such restriction.

❌ The fp8 file is put into diffusion_models and can't be found in the node ​

Reason: flux1-dev-fp8.safetensors / flux1-schnell-fp8.safetensors are packaged checkpoints that belong in models/checkpoints/ and are loaded by Load Checkpoint; only the full version's flux1-dev.safetensors belongs in diffusion_models/. Correct approach: put files in place according to the table in step 6; if it still can't be found, troubleshoot via model loading failure.

❌ Not enough VRAM, the full version goes straight to OOM ​

Reason: the full version has to serve both a 22GB-class diffusion model and a 9GB-class t5xxl_fp16. Correct approach: first, per the official recommendation, replace t5xxl with t5xxl_fp8_e4m3fn_scaled.safetensors (4.8 GB); if that's still not enough, switch entirely to the fp8 single-file version; for a systematic solution see insufficient VRAM.

Advanced tips (optional) ​

🔧 Write full, long sentences as prompts: faithfully rendering complex prompts is FLUX's strength — the official examples are all complete, long scene descriptions written in one go covering characters, environment, and lighting, which works better than piling up keyword tags.

🔧 Drag an image in and get the workflow: the example images in the official tutorial all carry workflow metadata, so dragging an image directly into the ComfyUI window (or Workflows → Open) recovers the full workflow and model download info — when you see a great FLUX-generated image by someone else, try dragging it in first.

🔧 The FLUX family has more cards to play: for image editing use FLUX.1 Kontext (character consistency, multi-turn iteration); for inpainting and outpainting use FLUX.1 Fill; for the new generation of multi-reference consistency see FLUX.2 and FLUX.3 Klein.

Lesson summary ​

✅ The FLUX workflow is running: dev full version with four files in place → generate in 20 steps; schnell swaps the diffusion model and changes steps to 4.

✅ You know how to pick a version: dev is non-commercial with performance close to the closed-source flagship Pro; schnell is the 4-step accelerated version under Apache 2.0, friendly to low-end setups.

✅ You've memorized the parameters: cfg 1, no negative prompt, euler + simple; dev 20 steps, schnell 4 steps.

✅ Low VRAM has a fallback: swap t5xxl for the fp8 version to halve the size, or switch entirely to the fp8 single-file checkpoint (placed in checkpoints/).

Key configuration recap:

ConfigurationRecommended valueNotes
Diffusion model (dev)flux1-dev.safetensors (22.17 GB)Put in models/diffusion_models/; the fp8 single-file version uses flux1-dev-fp8.safetensors, placed in checkpoints/
Diffusion model (schnell)flux1-schnell.safetensors (22.15 GB)Same as above; fp8 version flux1-schnell-fp8.safetensors
Text encoderclip_l.safetensors + t5xxl_fp16.safetensors (9.12 GB)Put in models/text_encoders/; for low VRAM swap to t5xxl_fp8_e4m3fn_scaled.safetensors (4.8 GB)
VAEae.safetensors (319.8 MB)Put in models/vae/
DualCLIPLoaderFirst slot clip_l, second slot t5xxl, type fluxSource recipe: flux = clip-l, t5
KSampler (dev)20 steps, cfg 1, euler, simple, denoise 1.0Official template configuration
KSampler (schnell)4 steps, cfg 1, euler, simple, denoise 1.0schnell is a 4-step distilled model
CanvasEmptySD3LatentImage 1024×1024To change the aspect ratio, modify width / height

Next Lesson Preview ​

Text-to-image is only the starting point of FLUX.1. The next lesson's FLUX.1 Kontext turns it into an "iterative image-editing engine": give it a character image and modify it round by round with instructions, while the character's appearance stays consistent. Next lesson: FLUX.1 Kontext.

You will learn:

  • Local deployment of Kontext dev (fp8 weights + text encoder + VAE)
  • Using the "Load Image (from output)" node to feed the previous round's result directly into the next round
  • Instruction-based iterative image editing: character consistency, style reference
  • Limitations of Kontext: prompts only support English
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.