FLUX · ONE-ADAPTER PROOF

Make one FLUX LoRA work before you stack another

A card in Forge proves discovery—not compatibility. Match the exact FLUX base, inspect the inserted tag, choose the application mode deliberately, then prove the expected effect with a fixed-seed A/B run.

BASEExact FLUX variantloads and generates alone
+
LORAExact artifact + recipekeys · trigger · weight
PROOFsame seed · one changeconsole + image + timing
Inspected original Forge · commit dfdcbab · code dated 26 Jun 2025Reviewed 01 Sep 2026
01 · Symptom router

Start at the first layer that fails

Choose what you can observe now. The result gives one next action and one acceptance proof, so discovery, compatibility, precision and memory do not get mixed together.

What happens with one FLUX LoRA?
FIRST ACTIONRepair discovery before compatibility

At the inspected commit, Forge scans the active LoRA directory recursively for .pt, .ckpt and .safetensors files. A missing card means you have not yet proved the active path or inventory refresh.

Do next
Confirm the default models/Lora path or your --lora-dir override, use Refresh in the LoRA extra-networks view, then check the filename is one of the scanned extensions.
Accept when
The card appears and clicking it inserts a LoRA tag into the selected prompt.
Open this check

VERIFIED The router follows the inspected loader order: discover the file, resolve its target keys, apply patches, then run the model. Inspect networks.py ↗

02 · Compatibility contract

“FLUX LoRA” is four facts, not one filename label

Write this record before moving the file. It is the shortest route to separating the wrong base from an unsupported export.

01

Base identity

The publisher explicitly names the FLUX variant or fine-tune used for training.

“FLUX” in a filename is not enough. Do not substitute SD 1.5, SDXL, SD3.5 or an unrelated FLUX variant.

02

Artifact identity

Save the model page, direct download URL, exact filename, byte size and hash.

A renamed file loses the evidence needed to distinguish versions and trainer exports.

03

Activation recipe

Record trigger/activation text, recommended starting weight and any required prompt pattern.

Trigger words and LoRA weight are separate controls; neither repairs incompatible keys.

04

Forge identity

Record original repository and commit dfdcbab.

Forks and old snapshots may expose different loaders, mappings and defaults.

03 · Install and activate

Take one adapter from file to controlled run

This is the FLUX-specific route. It keeps the generic folder step brief and spends the evidence budget on base identity, application mode and console proof.

  1. 01

    Prove FLUX without the LoRA

    Complete one base-only image with the intended checkpoint, VAE and text encoders. A broken base is not a LoRA problem.

  2. 02

    Verify the publisher contract

    Confirm the adapter was trained for the exact FLUX base you selected. Save its page, direct file link, hash, activation text and recommended weight.

  3. 03

    Place only the adapter file

    Use models/Lora/ by default. If Forge was launched with --lora-dir, that override is the active inventory instead.

  4. 04

    Refresh the LoRA inventory

    Open the extra-networks browser, choose LoRA and use Refresh. Restart only if the active installation still does not rescan as expected.

  5. 05

    Insert the card, then inspect the prompt

    A click normally inserts <lora:alias:weight>. Confirm the alias and weight; add the publisher’s activation text if it was not stored in Forge user metadata.

  6. 06

    Choose one application mode

    Start with the base file’s normal matched mode. For a low-bit precision, patching or unsupported-quantization problem, test the corresponding “(fp16 LoRA)” option as one named experiment.

  7. 07

    Run a fixed-seed A/B pair

    Save the base image and infotext, enable one LoRA, keep every other setting fixed, and compare the expected effect plus console output.

FORGE TAG<lora:alias:weight>Example structure only—use the alias inserted by your card.
PROMPT TEXTpublisher activation textOnly when the adapter recipe requires it.
HIRES / IMG2IMGdenoising strengthA separate control, not LoRA strength.

VERIFIED Current cards insert the alias and preferred/default multiplier; activation text is appended only when saved in Forge user metadata. Inspect the card code ↗

04 · Strength

A weight is a multiplier, not a percentage of style

Start from the publisher recipe. If no weight is documented, record your first value as an ASSUMPTION and compare several values without changing the rest of the job.

CONTROL RULE

Change the number after the final colon

<lora:alias:weight>

A single value becomes the default text-encoder multiplier; the model multiplier defaults to the same value in the inspected parser. Advanced separate targets exist, but they are not a compatibility repair.

START

Publisher baseline

Use the value documented for the exact artifact and base.

COMPARE

Same seed and prompt

Change only weight; preserve the full infotext for each image.

STOP

Do not overpower a mismatch

If keys do not load, a larger multiplier still applies nothing.

REMEMBER

A changed weight can repatch

Weight belongs to Forge’s current patch identity.

ASSUMPTION BOUNDARY

There is no source-supported universal sequence such as “0.5, 0.8, 1.0” for all FLUX LoRAs. Training alpha, rank, target modules, captions and base behavior change the useful range.

05 · Low-bit modes

Normal and “fp16 LoRA” move cost to different phases

Use the paired option that preserves the base storage choice: Automatic ↔ Automatic (fp16 LoRA), bnb-nf4 ↔ bnb-nf4 (fp16 LoRA), and so on.

NORMAL LOW-BIT MODE

Patch once up front

base weights← merge →LoRA
Watch: patch time and requantization
PAIRED (FP16 LORA) MODE

Evaluate on each step

base forward+online LoRA
Watch: warm step time and adapter count
Behavior documented in the dated official guide and rechecked against commit dfdcbab
QuestionNormal low-bit modePaired “(fp16 LoRA)” mode
Where the adapter work happensMerged/precomputed into affected base weights.Kept as an online patch and evaluated during forward passes.
Precision relationshipThe dated guide says the adapter is baked to the low-bit diffusion model’s precision.The dated guide describes the adapter as staying at higher precision.
First-run behaviorMay show a long Patching LoRAs phase.Avoids that same up-front merge route.
Warm generation behaviorThe guide says patching itself should not keep slowing diffusion after the merge.Adds work on every diffusion step; multiple adapters can add substantially more.
When the LoRA weight changesThe inspected cache identity changes, so Forge must refresh the patch set.The online patch set also changes and must be refreshed.
Full-precision base nuanceNormal patching is used.Current code turns online mode off when model storage is float32, float16 or bfloat16.
CONSOLE PROOF
Using online LoRAs in FP16: True[LORA] Loaded … with on_the_fly = True

These lines prove the setting reached the inspected original-Forge loader. They do not by themselves prove the adapter produced the intended visual effect.

06 · Format boundary

Forge matches state-dict keys—not marketplace labels

The statements below describe source code at one commit. They are not a promise that every file from a named trainer or every future export works.

DISCOVERY.pt · .ckpt · .safetensors

The inventory scans these extensions recursively.

FLUX TARGET MAPtransformer · lora_transformer · lycoris

The code builds several FLUX prefix mappings.

PATCH PAIRSup/down · A/B · linear-layer

The loader recognizes several tensor naming pairs.

VERIFIED

Commit-bound capabilities

Exact extensions, mappings, mismatch thresholds, patch routes and console messages are visible in original Forge source.

UNKNOWN

Your exact adapter

A container can mix unsupported keys, unexpected targets or a different architecture. Only its load record and controlled effect close the question.

REPORT CONTRACT

Artifact page + direct URL

The official FLUX LoRA note requests both. Add the hash, base, Forge commit and console to make the report reproducible.

VERIFIED When more than 12 keys remain unmatched after model and clip attempts, the inspected loader prints “LoRA version mismatch for KModel” and returns without that adapter. Inspect the threshold ↗

07 · Failure decoder

Let the first console line choose the next move

Preserve the first error before secondary OOM, browser disconnect or process-exit messages bury it.

01Card absent after download

Confirm the active --lora-dir, scanned extension and completed download. The default is models/Lora; subfolders are scanned recursively. Then use the LoRA view’s Refresh.

02Clicking the card adds a tag but no trigger words

This is not proof of failure. Forge appends activation text only when it exists in the item’s user metadata. Copy the exact publisher activation text yourself when required.

03“LoRA version mismatch for KModel”

The commit-bound loader found more than 12 unmatched keys after attempting model and text-encoder matching, then returned without applying the adapter. Verify base and export format; weight changes cannot fix this.

04“Loading … with unmatched keys”

Some keys were not consumed, but the threshold for the full version-mismatch return was not crossed. Treat the adapter as only partially understood until the expected effect and Loaded counts are verified.

05“Mismatch …-UNet with … keys mismatched”

Too many mapped patches were skipped for the model target. Preserve the complete line, exact file and base identity; do not claim success from a generated image alone.

06“Low bit LoRA for this data type is not implemented yet”

Use the corresponding “(fp16 LoRA)” mode and confirm the console says Using online LoRAs in FP16: True. If it does and the same error remains, capture the original-Forge commit and full traceback.

07“Patching LoRA weights out of memory”

The current patcher retries after offloading models. If the process still fails, compare the paired on-the-fly mode and record GPU Weights, Swap Method, Swap Location, VRAM and system RAM.

08Patching repeats on every identical generation

The dated guide and inspected cache logic say unchanged filename, weights and mode should reuse the loaded target. Check dynamic prompt weights or mode changes, then report a minimal reproduction if the identity truly stays fixed.

09Base works; one LoRA crashes the machine

Keep the base fixed, remove every other adapter and extension, lower workload pressure, and compare normal versus paired fp16-LoRA behavior. A community crash report is not a hardware rule.

08 · Controlled proof

Build a report another user can reproduce

One successful image can hide wrong triggers, partial key loading or a lucky prompt. This receipt binds the artifact, environment, job and observed effect.

FLUX LoRA validation receipt
FIELDS RECORDED0 / 8

Record all eight fields before calling the adapter supported or broken.

A · BASE

LoRA tag absent

Generate the saved job and keep its image, infotext, time and console.

B · ADAPTER

One tag + exact trigger

Reuse every setting, including seed. Save Loaded/mismatch lines and timing.

C · REPEAT

More than one seed

Confirm the expected effect is reproducible, not one-image coincidence.

09 · Evidence register

Product claims stay attached to original Forge

Community guides supplied vocabulary and failure questions. Current code and original maintainer material decide what this page states as Forge behavior.

VERIFIED

Original source and maintainer notes

Used for paths, parsing, patch modes, cache identity and console behavior.

COMMUNITY-REPORTED

Issues and discussions

Used to identify symptoms; individual hardware outcomes are not universal rules.

STALE SNAPSHOT

Dated tutorials and video

Used for user journeys only. Their settings, models and performance claims were not copied as requirements.

UNKNOWN

Untested artifact and machine

Compatibility, useful strength, speed, memory and output until the receipt passes.

O16 · Official FLUX LoRA noteVERIFIEDReporting fields, normal versus fp16-LoRA behavior and unchanged-weight cache expectation.O15 · Official low-bit guideVERIFIEDDated FLUX low-bit vocabulary and warning against mismatched forced precision.Current LoRA inventoryVERIFIEDExtensions, recursive scan, cache identity, unmatched-key thresholds and console lines.Current activation parserVERIFIEDPrompt multipliers and separation of model/text-encoder strengths.Current LoRA cardsVERIFIEDRefresh, inserted tag, alias, preferred weight and optional activation text.Current metadata readerVERIFIEDFLUX metadata detection and filename/metadata alias behavior.Current low-bit UIVERIFIEDExact paired choices and online_lora state.Current patcherVERIFIEDMerged versus online patches, OOM retry and cache behavior.Current key mappingsVERIFIEDCommit-bound FLUX prefixes and tensor naming pairs.Current GGUF quantizerVERIFIEDExact unsupported-low-bit-LoRA exception text.BFL FLUX repositoryVERIFIEDUpstream variant and official LoRA context; not Forge compatibility proof.Patching Q&A #1353COMMUNITY-REPORTEDReal patching freeze intent; hardware outcome not generalized.Multiple-LoRA Q&A #2061COMMUNITY-REPORTEDPer-step slowdown question; individual timings not generalized.GGUF issue #2625COMMUNITY-REPORTEDExact error and console-proof intent; closed issue is not a universal fix.A10 · Forge FLUX setupSTALE SNAPSHOTDated user path and low-bit terminology only.A11 · GGUF and LoRA walkthroughSTALE SNAPSHOTFolder, prompt and application questions; recipe values not generalized.A15 · ForgeUI tutorialSTALE SNAPSHOTDiscovery, family labels and strength confusion; claims rechecked against code.V07 · Full transcript reviewedSTALE SNAPSHOTWrong-base, refresh and trigger-word user journey; settings and hardware claims excluded.
BASE NOT PROVEN?

Run FLUX cleanly first

Choose the variant and package, then complete the base acceptance run.

Open the FLUX guide →
BASE FORMAT UNCLEAR?

Compare GGUF and NF4

Keep the LoRA plan visible while choosing the base runtime path.

Open GGUF vs NF4 →

GENERIC LORA TASK For SD 1.5, SDXL, folders, prompt tags, weights and family matching without FLUX low-bit behavior, open the universal LoRA guide →

10 · Direct answers

FLUX LoRA questions, answered at the failure boundary

These answers intentionally separate what the code proves, what dated maintainers documented, what the community reports and what your own run still needs to establish.

How do I use a FLUX LoRA in Stable Diffusion WebUI Forge?

Prove the exact FLUX base first, place the adapter in the active LoRA directory, refresh the LoRA cards, insert one adapter, add its documented activation text and starting weight, then compare a fixed-seed base run with a base-plus-LoRA run.

Where do FLUX LoRA files go in Forge?

The default inspected path is models/Lora/. A launch-time --lora-dir value overrides that inventory, so diagnose the active command rather than copying the file into several folders.

Why is my FLUX LoRA not showing in Forge?

The active folder may differ, the inventory may need Refresh, the download may be incomplete, or the extension may not be scanned. At the inspected commit the LoRA scanner accepts .pt, .ckpt and .safetensors recursively.

Can I refresh LoRAs in Forge without restarting?

Yes. The inspected LoRA extra-networks page has a Refresh action that rebuilds the available network list. If that does not expose the file, verify the active path and extension before restarting.

What is the FLUX LoRA prompt syntax in Forge?

The normal card inserts <lora:alias:weight>. The alias may come from file metadata or the filename according to Forge settings, so using the card is safer than guessing it manually.

Does a FLUX LoRA need a trigger word?

Only when its publisher or training recipe says so. A trigger word steers activation in the prompt; it does not load the file and cannot repair an architecture or key-layout mismatch.

What strength should I use for a FLUX LoRA?

Start with the exact publisher recommendation for that adapter and base, then test lower or higher values one at a time with a fixed seed. There is no universal best FLUX LoRA strength.

Does LoRA weight 1 mean 100 percent style?

It means a multiplier of 1.0 in Forge’s adapter call. It is not a calibrated promise of “100 percent style,” because training scale, alpha, rank, targets, trigger text and the base all affect the result.

Is LoRA strength the same as denoising strength?

No. The number in <lora:name:weight> scales the adapter patch. Denoising strength controls how much an img2img or Hires-fix process can move away from its input.

Can an SDXL or SD 1.5 LoRA work with FLUX?

Do not assume it can. The model architectures and target keys differ. Use an adapter explicitly published for the exact FLUX family and verify its console mapping.

Can I use a FLUX.1-dev LoRA with FLUX.1-schnell?

Only when the adapter publisher documents that combination and your controlled test confirms it. The shared FLUX name is not enough to declare cross-variant compatibility.

Does .safetensors mean the LoRA is compatible with FLUX?

No. .safetensors is a container. Compatibility depends on the base architecture, target keys, naming layout and loader support in the inspected Forge build.

Which LoRA file formats does Forge scan?

At inspected commit dfdcbab, the default LoRA inventory scans .pt, .ckpt and .safetensors. Discovery is broader than compatibility: a listed file can still have unmatched or unsupported keys.

Which FLUX LoRA key layouts does Forge support?

The inspected code contains FLUX mappings for transformer-style, lora_transformer-style and lycoris-style prefixes and recognizes several up/down tensor naming pairs. That is code capability, not a guarantee for every trainer export; test the exact file.

What does “LoRA version mismatch for KModel” mean?

At the inspected commit, more than 12 state-dict keys remained unmatched after Forge tried the model and text-encoder maps, so the loader prints the message and returns without applying that adapter.

What is the difference between Automatic and Automatic (fp16 LoRA)?

For a low-bit base, the dated official guide describes Automatic as precomputing the adapter into the base precision, while Automatic (fp16 LoRA) keeps it higher precision and computes it on every diffusion step.

What Diffusion in Low Bits setting should I use for a GGUF FLUX LoRA?

Keep the GGUF base on its normal detected route first. If the adapter patch is unsupported, too slow or loses the expected effect, test Automatic (fp16 LoRA) and verify on_the_fly = True in the console.

What Diffusion in Low Bits setting should I use for an NF4 FLUX LoRA?

Start with Automatic for a checkpoint already packaged as NF4. Test Automatic (fp16 LoRA) as a separate adapter-precision experiment; do not force an unrelated base storage type.

Why does Patching LoRAs take so long in Forge?

Normal low-bit application can merge the adapter into many affected base weights and requantize them. Measure this as an up-front phase; the paired fp16-LoRA option trades that phase for per-step work.

Why does Forge patch my LoRA again after I change its strength?

The inspected patch identity includes the filename, model strength, text-encoder strength and online mode. Changing the multiplier changes that identity, so the patch set must refresh.

Should Forge patch the same LoRA on every generation?

Not when its file, strengths and mode stay unchanged. The dated maintainer note says it should load once, and the inspected code returns early when the compiled target hash is unchanged.

Why is generation slower with Automatic (fp16 LoRA)?

That mode evaluates the adapter during each diffusion iteration for a low-bit model. The dated guide says one adapter may add a little time and several may add much more; measure your exact workload.

Can I stack multiple FLUX LoRAs in Forge?

You can test a stack only after every adapter passes alone. Record each exact weight and watch memory and warm speed, especially in an fp16-LoRA mode where every active adapter adds per-step work.

Why does my FLUX LoRA have no visible effect?

Check the exact base, prompt tag, activation text and publisher weight, then read the console for Loaded, unmatched-key or version-mismatch lines. Compare fixed seeds and more than one prompt before calling a subtle adapter inactive.

Why does my FLUX LoRA look blurry or distorted?

First lower only the adapter weight from the publisher baseline and compare the same seed. Then test the paired low-bit application mode separately. Community reports suggest both can matter, but neither diagnosis is universal.

What information should I include when reporting a broken FLUX LoRA?

Include the adapter page and direct download URL as the maintainer requested, plus file hash, exact FLUX base, original-Forge commit, full prompt/tag, low-bit mode, console Loaded/mismatch lines, traceback and a fixed-seed A/B result.

Can I use Automatic (fp16 LoRA) with a full-precision FLUX base?

The option exists, but the inspected loader disables online mode when model storage is float32, float16 or bfloat16. Verify the console rather than assuming the label forces on-the-fly behavior.