This article presents a practical idea for people who can run FLUX locally or otherwise have full access to img2img, and especially to those who have less than 24gb VRAM and like to experiment. As far as I know, it doesn't work on Civitai because you can't switch from an SDXL model to FLUX using image-to-image variations. At least, I couldn't find a way when I tried - please let me know if I'm wrong about this. I've been making the initial image with txt2img in SDXL and producing the final image with FLUX through img2img. This can also apply to SD1 and Pony in place of SDXL. I thought it might be interesting to show a demonstration for those who haven't tried it.
For reference, I'm using a computer with 16gb VRAM (nvidia 4060), 32 gb RAM, and running FLUX in WebforgeUI.
Why combine SDXL and FLUX?
Advantages of including SDXL: It's significantly faster to generate multiple images to have a selection to pick the best style and composition. Generating through img2img with FLUX can be faster than txt2img at lower denoise values with the same number of steps. It's possible to use SDXL's vast library of style LoRAs in txt2img, then FLUX keeps a similar style in img2img without the LoRA.
Advantages of including FLUX: It can add or fix text. It can fix anatomy and structure problems. It adds extra fidelity, details, and smooths out the linework. It can be satisfying seeing FLUX's transformations on what SDXL was struggling with.
Practical workflow: from SDXL+LoRA to FLUX img2img
Steps: Generate an image with an SDXL checkpoint plus any LoRAs. Switch to a FLUX model. Put the image in img2img and set the denoise value to around 3 to 5 (adjust up or down as needed). To train a Stable Diffusion image LoRA locally in 2026, use Kohya's sd-scripts (the standard trainer): an SDXL LoRA needs about 12 GB of VRAM minimum (16 GB comfortable), while a FLUX.1 LoRA traditionally wanted 24 GB but now runs on 16 GB - and as low as 4-8 GB - thanks to Kohya's fused-backward-pass optimizations added in v0.9.0 (January 2025).
You only need 10-30 captioned images, a sensible learning rate (around 1e-4), and a LoRA rank of roughly 16-32 for FLUX or 32-64 for SDXL. This guide is specifically about image LoRAs - teaching a diffusion model a new character, art style, or product. That is a completely different toolchain from training a text LLM LoRA. The de facto standard is Kohya's sd-scripts (kohya-ss/sd-scripts on GitHub) - a Python toolkit of training scripts for Stable Diffusion and related image models. It ships sdxl_train_network.py for SDXL LoRAs and flux_train_network.py for FLUX.1 LoRAs, plus support for SD 1.5/2.x, SD3/3.5 and other models. The takeaway: pick the interface you like, but the actual math is Kohya's underneath. You can verify the script list and supported models on the official kohya-ss/sd-scripts repository.
Reading articles is good. Building is better. Free account = 20+ free chapters across 25 courses, with a per-chapter AI tutor. No card. SDXL (Stable Diffusion XL) is a 3.5B-parameter U-Net diffusion model. FLUX.1 is a 12-billion-parameter rectified-flow transformer (a DiT - Diffusion Transformer) from Black Forest Labs. It produces noticeably better prompt adherence and anatomy, but it is heavier and - importantly - more sensitive to learning rate than SDXL. Rule of thumb: if you have a 12 GB card, train SDXL. If you have 16 GB, you can do either (FLUX via FluxGym or ComfyUI-FluxTrainer).
What about FLUX.2? Black Forest Labs released the FLUX.2 series on 25 November 2025 (Pro, Flex, Dev, and an Apache-2.0 "Klein" variant). The open-weight FLUX.2 dev model is larger and heavier than FLUX.1 and realistically wants 24 GB+ to train, while the smaller Klein is aimed at consumer cards. It's newer, and the consumer-GPU training tooling is still settling. Here is the honest, by-tier breakdown for LoRA training specifically (full fine-tuning needs far more).
LoRA training: capacity and hardware considerations
- GPU VRAM: 8 GB - Possible, with heavy optimization; 12 GB - Comfortable; 16 GB - Via FluxGym / ComfyUI split_mode; 24 GB+ - easier and faster, especially for larger models.
- SDXL LoRA vs. FLUX.1 LoRA: notes highlight that FLUX.1 can train on smaller GPUs with optimized configs, while SDXL LoRAs historically demand more VRAM.
- Training runs: On an RTX 3090 (24 GB), an SDXL LoRA run is roughly 30-60 minutes for ~1,500 steps at 1024px; a FLUX.1 LoRA is longer (1-3 hours) for a comparable run due to FLUX's 12B size.
- Output: After training, you get a single .safetensors file. Drop it in your models/Lora folder to use locally, and share via CivitAI, the largest community catalog of image models.
The FLUX equivalent uses flux_train_network.py and additionally points at the FLUX text encoders (CLIP-L and T5-XXL) and the FLUX VAE/autoencoder. If you already run image generation in ComfyUI, you do not need to touch a terminal. ComfyUI-FluxTrainer (by kijai) is a set of custom nodes that wrap slightly modified Kohya FLUX training scripts, letting you build a training workflow as a node graph - and use the same base models you already generate with. The appeal is comparison: because settings are nodes, you can branch a graph to test two ranks or learning rates side by side. The tradeoff is that node-based training is fiddlier to reproduce than a saved TOML. New to ComfyUI itself? Our complete ComfyUI guide covers installation and the node basics you'll need before adding the trainer.
Practical LoRA patterns
- Character LoRA: 10-20 images of one subject across varied poses/lighting, a unique trigger token, rank 16-32, ~1,500 steps. Keep backgrounds varied so the LoRA learns the face/body, not a setting.
- Style LoRA: 15-30 images that share an art style but differ in subject. Caption the content of each image and let the style be learned implicitly, or use a style trigger token.
- Product LoRA: 15-25 clean shots of the product on neutral and varied backgrounds, multiple angles.
Approximate, single-machine figures: On an RTX 3090 (24 GB), an SDXL LoRA run is roughly 30-60 minutes for ~1,500 steps at 1024px. A FLUX.1 LoRA is noticeably longer - on the order of 1-3 hours for a comparable run - because of FLUX's 12B size. These numbers depend on hardware, config, batch size, resolution, and whether you’re block-swapping to system RAM. When training finishes you get a single .safetensors file. Drop it in your models/Lora folder to use locally, and to share it, the standard hub is CivitAI-the largest community catalog of image models, hosting the overwhelming majority of public Stable Diffusion and FLUX LoRAs (tens of thousands of LoRA resources and counting).
Workflow notes and tips
- Kohya's sd-scripts is the standard image-LoRA trainer. FLUX is more learning-rate sensitive than SDXL. 10-30 captioned images is enough. Don’t have the base models yet? Prefer a visual workflow over the CLI? Training a text model instead of an image one? Weighing the 24 GB upgrade for faster FLUX runs?
- The practical SDXL sweet spot: fused backward pass optimizations dropped FLUX LoRA training from a hard 24 GB requirement down toward 4-8 GB on optimized configs. Note that "it fits in 8 GB" and "it trains well in 8 GB" are different statements - expect long runs and small batches at the bottom of this table. The dataset is where most LoRAs are won or lost.
- ComfyUI-FluxTrainer provides a node-based workflow, making it easier to compare learning rates and ranks side by side, but may be fiddlier to reproduce than a saved TOML.
Example prompts and settings: before/after visuals
Here are some before and after images described in the draft, illustrating how FLUX can refine SDXL outputs. Cafe Chroma: exterior of a cafe, text "Cafe Chroma"; top text says "Cafe Chroma" and a small sign on the wall says "WELCOME". Flux smooths out and adds small details in areas like potted plants. Steps: 30, Sampler: Euler, Schedule type: Simple, CFG scale: 1, Distilled CFG Scale: 3.5, Seed: 782544532, Size: 896x1152, Model hash: bea01d51bd, Model: flux1-dev-bnb-nf4-v2, Denoising strength: 0.4. Link to full sizes.
The Lute Player: main objective to improve hands. Photograph of an elegant woman with delicate features playing a lute. Steps: 30, Sampler: Euler, Schedule type: Simple, CFG scale: 1, Distilled CFG Scale: 3.5, Seed: 353199320, Size: 896x1152, Model hash: bea01d51bd, Model: flux1-dev-bnb-nf4-v2, Denoising strength: 0.4. Link to full sizes.
Magical Library: FLUX smoothing for a cleaner look and more symmetrical designs, Victorian magical library with gold, lamp light, symmetrical decorations, art nouveau/deco influences. Steps: 30, Sampler: Euler, Schedule type: Simple, CFG scale: 1, Distilled CFG Scale: 3.5, Seed: 3996458741, Size: 896x1152, Model: flux1-dev-bnb-nf4-v2, Denoising: 0.5. Link to full sizes.
Table: rough hardware-to-compatibility overview
| Scenario | SDXL LoRA | FLUX.1 LoRA | Notes |
|---|---|---|---|
| VRAM requirement | 8-12 GB possible with optimization | 16 GB comfortable | Higher complexity for FLUX |
| Training time (1.5k steps, 1024px) | ~30-60 min | 1-3 hours | Depends on batch, rank, LR |
| Quality focus | Style adherence with LoRA | Better prompt adherence and anatomy |
In summary, SDXL LoRAs can be trained and used efficiently on relatively modest GPUs, while FLUX LoRAs benefit from FLUX's transformation capabilities, with trade-offs in training time and VRAM usage. The combined workflow-txt2img with SDXL, followed by img2img with FLUX-offers faster iteration for style and composition, improved text and anatomy, and broader stylistic control via SDXL LoRAs without sacrificing FLUX refinements.
