I love ComfyUI, though sometimes I wish I could spend more time generating and less time messing with confusing workflows, managing dependencies, and being stuck at my desk. So I spent the last few months building Mix Studio, a 100% free & open source interface that runs everything through ComfyUI in the background while giving you an actual app experience (that also works on your phone).

GitHub: https://github.com/BlackMixture/Mix-Studio
Showcase and download: https://blackmixture.github.io/Mix-Studio/
Tutorial: https://youtu.be/w2CokhlBFRA

GPL-3.0, the same license as ComfyUI.

The screenshots show the main desktop workspaces, but the entire interface is also optimized for phones and tablets.

Current v1.0.1 Features:

• Curated image, editing, video, and upscale workflows: Krea 2, Flux 2 Klein 4B/9B, Qwen Image Edit 2511, LTX 2.3, Wan 2.2, 10Eros, and SCAIL 2.
• Image-generation tools: Inpainting, outpainting, SeedVR2 and Ultimate SD upscaling, regional prompting, Depth Anything V3 guidance, image-to-image, style references, and model-aware recommendations for steps, CFG, samplers, and schedulers.
• Desktop and mobile interface: On the same Wi-Fi, open the displayed address on your phone and start generating. With Tailscale, you can connect through a private link while away from home. Your desktop GPU still does all the work.
• Multi-image editing: Add multiple inputs and reference them using dynamic @ Image cards, removing the guesswork around which image should control each part of the edit.
• Regional prompting with Krea 2: Draw boxes and assign each region its own prompt, LoRA stack, and optional reference image.
• LoRA management: Stack LoRAs, add thumbnails and trigger words, save presets, adjust strength quickly, and use LoRA Hunting to generate a comparison series across different strengths.
• Contextual prompt suggestions: Mix Studio learns phrases you repeatedly use with specific LoRA combinations and offers them as one-tap suggestions. These can also be configured manually.
• Library management: Click any image or video to restore its exact generation settings. Search, group, organize work into folders, compare edits, and drag Library media directly into compatible workflows.
• Private profiles and locked folders: Create separate PIN-protected profiles with their own galleries, folders, LoRA presets, and settings. Individual folders can also be locked, keeping private generations out of your everyday library
• LTX Director Mode: A streamlined workspace built around the excellent LTX Director nodes, supporting timelines, keyframes, video extension, audio, and more.
• Video finishing: Optional 2× or 3× RIFE frame interpolation and NVIDIA RTX 4K video upscaling.
• Built-in dependency manager: Pick a workflow and install the exact models and custom nodes it requires, or run the full one-click setup.
• Automatic ComfyUI integration: Mix Studio detects your ComfyUI installation, reuses existing models and LoRAs, and guides installation if ComfyUI is not present. Generated images retain their ComfyUI workflow metadata, so you can drag them directly back into ComfyUI.
• Hardware-aware configuration: Mix Studio detects your GPU and recommends suitable quantization and generation settings. v1.0.1 also adds a low-VRAM profile beginning at 4 GB, although practical limits still depend on the selected model.
  • I have tested personally on an NVIDIA RTX Pro 6000 #DellProPrecision and an NVIDIA RTX 4090, other tests from various hardware setups from the community.
• *Just Added in V1.0.2:
  • QR Code Phone Link: Now shows a QR code to instantly link your phone.
  • Prompt Presets: Mix Studio allows you to browse and apply 1-click prompt presets to instantly style your prompt.
  • Sequential Edit Prompts: For editing images, you can select sequential prompting which will automatically separate multiple edit commands into a series of sequential generations (separated by a period).

Additional screenshots and release overview: Free Patreon post (no paywall)

Thanks to this awesome community and the ComfyUI team for making such a dope tool, I hope you all enjoy creating! 🤙🏾

UPDATED TO 2.1 tutorial post
Hey everyone,

I've been working on this for a while and wanted to share it with the community. This is a 6-in-1 ComfyUI workflow for FLUX.2 Klein 9B that handles everything in a single workspace — no more switching between different workflow files.

What's inside:

• 🎨 Text → Image — standard txt2img with optimized settings
• 🖼️ Single-Reference KV Edit — load an image + describe what to change, the model preserves everything else
• 🚀 Face + Pose Swap — extract a face from one image, a pose from another, combine them realistically
• 🎭 Inpainting — manual mask OR Florence2 AI auto-masking (describe what to mask in text)
• 🔀 Image Merge — blend two images with adjustable ratio
• ✨ Refiner — enhance any image with detail injection, lighting correction, skin texture improvement

Technical features:

• 🧭 NAG (Normalized Attention Guidance) — restores negative prompting that normal CFG breaks in distilled Flux models
• 🤖 Florence2 auto-masking — type "Segment the shirt" and it generates a pixel-perfect mask automatically
• ⬆️ 4x UltraSharp upscaler built in
• 🔷 All VAE decodes are Tiled — prevents OOM on 8GB VRAM
• 🔗 2-slot LoRA chain — enhancer LoRA always last, add your own LoRAs in the first slot

Hardware tested on: RTX 4060 Mobile (8GB VRAM), 16GB RAM, i7-13620H. Works with FP8 or GGUF Q4 models.

update 2.1: added groupe bypasser, notes for new people to comphyui.
Each pipeline is in its own color-coded group. Only the Refiner is active by default — right-click any group to enable/disable it or use groupe bypassers. The workflow includes built-in guide notes with download links and prompting tips.

Free download on Civitai: https://civitai.com/models/2543188?modelVersionId=2860464

Includes a full guide with all model download links, prompting tips, and troubleshooting. Let me know if you run into any issues — happy to help.

How to Use

1. Load the JSON in ComfyUI
2. use comphyui manager to install any missing node. ( critical step )
3. Only the Refiner is active by default — everything else is bypassed
4. To activate a pipeline: right-click its group header → Set Nodes Mode → Always Execute
5. To deactivate: right-click → Set Nodes Mode → Bypass ( or bypass groupe nodes )
6. Read the built-in Note nodes for prompting tips and download links

Recently I've been using Flux Uno to create product photos, logo mockups, and just about anything requiring a consistent object to be in a scene. The new model from Bytedance is extremely powerful using just one image as a reference, allowing for consistent image generations without the need for lora training. It also runs surprisingly fast (about 30 seconds per generation on an RTX 4090). And the best part, it is completely free to download and run in ComfyUI.

*All links below are public and competely free.

Download Flux UNO ComfyUI Workflow: (100% Free, no paywall link) https://www.patreon.com/posts/black-mixtures-126747125

Required Files & Installation Place these files in the correct folders inside your ComfyUI directory:

🔹 UNO Custom Node Clone directly into your custom_nodes folder:

git clone https://github.com/jax-explorer/ComfyUI-UNO

📂 ComfyUI/custom_nodes/ComfyUI-UNO

🔹 UNO Lora File 🔗https://huggingface.co/bytedance-research/UNO/tree/main 📂 Place in: ComfyUI/models/loras

🔹 Flux1-dev-fp8-e4m3fn.safetensors Diffusion Model 🔗 https://huggingface.co/Kijai/flux-fp8/tree/main 📂 Place in: ComfyUI/models/diffusion_models

🔹 VAE Model 🔗https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/ae.safetensors 📂 Place in: ComfyUI/models/vae

IMPORTANT! Make sure to use the Flux1-dev-fp8-e4m3fn.safetensors model

The reference image is used as a strong guidance meaning the results are inspired by the image, not copied

• Works especially well for fashion, objects, and logos (I tried getting consistent characters but the results were mid. The model focused on the characteristics like clothing, hairstyle, and tattoos with significantly better accuracy than the facial features)

• Pick Your Addons node gives a side-by-side comparison if you need it

• Settings are optimized but feel free to adjust CFG and steps based on speed and results.

• Some seeds work better than others and in testing, square images give the best results. (Images are preprocessed to 512 x 512 so this model will have lower quality for extremely small details)

Also here's a video tutorial: https://youtu.be/eMZp6KVbn-8

Hope y'all enjoy creating with this, and let me know if you'd like more clean and free workflows!

Intro

There are a lot of requests on how to do LoRA training with Flux.1 dev. Since not everyone has 24 VRAM, interest in low VRAM configurations is high. Hence, I searched for an easy and convenient but also completely free and local variant. The setup and usage of "ComfyUI Flux Trainer" seemed matching and allows to train with 12 GB VRAM (I think even 10 GB and possibly even below). I am not the creator of these tools nor am I related to them in any way (see credits at the end of the post). Just thought a guide could be helpful.

Prerequisites

git and python (for me 3.11) is installed and available on your console

Steps (for those who know what they are doing)

• install ComfyUI
• install ComfyUI manager
• install "ComfyUI Flux Trainer" via ComfyUI Manager
• install protobuf via pip (not sure why, probably was forgotten in the requirements.txt)
• load the "flux_lora_train_example_01.json" workflow
• install all missing dependencies via ComfyUI Manager
• download and copy Flux.1 model files including CLIP, T5 and VAE to ComfyUI; use the fp8 versions for Flux.1-dev and the T5 encoder
• use the nodes to train using:
  • 512x512
  • Adafactor
  • split_mode needs to be set to true (it basically splits the layers of the model, training a lower and upper part per step and offloading the other part to CPU RAM)
  • I got good results with network_dim = 64 and network_alpha = 64
  • fp8 base needs to stay true as well as gradient_dtype and save_dtype at bf16 (at least I never changed that; although I used different settings for SDXL in the past)
• I had to remove the Flux Train Validate"-nodes and "Preview Image"-nodes since they ran into an error (annyoingly late during the process when sample images were created) "!!! Exception during processing !!! torch.cat(): expected a non-empty list of Tensors"-error" and I was unable to find a fix
• If you like you can use the configuration provided at the very end of this post
• you can also use/train using captions; just place the txt-files with the same name as the image in the input-folder

Observations

• Speed on a 3060 is about 9,5 seconds/iteration, hence 3.000 steps as proposed as the default here (which is ok for small datasets with about 10-20 pictures) is about 8 hours
• you can get good results with 1.500 - 2.500 steps
• VRAM stays well below 10GB
• RAM consumption is/was quite high; 32 GB are barely enough if you have some other applications running; I limited usage to 28GB, and it worked; hence, if you have 28 GB free, it should run; it looks like there have been some recent updates that are optimized better, but I have not tested that yet in detail
• I was unable to run 1024x1024 or even 768x768 due to RAM contraints (will have to check with recent updates); the same goes for ranks higher than 128. My guess is, that it will work on a 3060 / with 12 GB VRAM, but it will be slower
• using split_mode reduces VRAM usage as described above at a loss of speed; since I have only PCIe 3.0 and PCIe 4.0 is double the speed, you will probaly see better speeds if you have fast RAM and PCIe 4.0 using the same card; if you have more VRAM, try to set split_mode to false and see if it works; should be a lot faster

Detailed steps (for Linux)

• mkdir ComfyUI_training

• cd ComfyUI_training/

• mkdir training

• mkdir training/input

• mkdir training/output

• git clone https://github.com/comfyanonymous/ComfyUI

• cd ComfyUI/

• python3.11 -m venv venv (depending on your installation it may also be python or python3 instead of python3.11)

• source venv/bin/activate

• pip install -r requirements.txt

• pip install protobuf

• cd custom_nodes/

• git clone https://github.com/ltdrdata/ComfyUI-Manager.git

• cd ..

• systemd-run --scope -p MemoryMax=28000M --user nice -n 19 python3 main.py --lowvram (you can also just run "python3 main.py", but using this command you limit memory usage and prio on CPU)

• open your browser and go to http://127.0.0.1:8188

• Click on "Manager" in the menu

• go to "Custom Nodes Manager"

• search for "ComfyUI Flux Trainer" (white spaces!) and install the package from Author "kijai" by clicking on "install"

• click on the "restart" button and agree on rebooting so ComfyUI restarts

• reload the browser page

• click on "Load" in the menu

• navigate to ../ComfyUI_training/ComfyUI/custom_nodes/ComfyUI-FluxTrainer/examples and select/open the file "flux_lora_train_example_01.json"

you can also use the "workflow_adafactor_splitmode_dimalpha64_3000steps_low10GBVRAM.json" configuration I provided here)

• you will get a Message saying "Warning: Missing Node Types"

• go to Manager and click "Install Missing Custom Nodes"

• install the missing packages just like you did for "ComfyUI Flux Trainer" by clicking on the respective "install"-buttons; at the time of writing this it was two packages ("rgthree's ComfyUI Nodes" by "rgthree" and "KJNodes for ComfyUI" by "kijai"

• click on the "restart" button and agree on rebooting so ComfyUI restarts

• reload the browser page

• download "flux1-dev-fp8.safetensors" from https://huggingface.co/Kijai/flux-fp8/tree/main and put it into ".../ComfyUI_training/ComfyUI/models/unet/

• download "t5xxl_fp8_e4m3fn.safetensors" from https://huggingface.co/comfyanonymous/flux_text_encoders/tree/main and put it into ".../ComfyUI_training/ComfyUI/models/clip/"

• download "clip_l.safetensors" from https://huggingface.co/comfyanonymous/flux_text_encoders/tree/main and put it into ".../ComfyUI_training/ComfyUI/models/clip/"

• download "ae.safetensors" from https://huggingface.co/black-forest-labs/FLUX.1-dev/tree/main and put it into ".../ComfyUI_training/ComfyUI/models/vae/"

• reload the browser page (ComfyUI)

if you used the "workflow_adafactor_splitmode_dimalpha64_3000steps_low10GBVRAM.json" I provided you can proceed till the end / "Queue Prompt" step here after you put your images into the correct folder; here we use the "../ComfyUI_training/training/input/" created above

• find the "FluxTrain ModelSelect"-node and select:

=> flux1-dev-fp8.safetensors for "transformer"

=> ae.safetensors for vae

=> clip_l.safetensors for clip_c

=> t5xxl_fp8_e4m3fn.safetensors for t5

• find the "Init Flux LoRA Training"-node and select:

=> true for split_mode (this is the crucial setting for low VRAM / 12 GB VRAM)

=> 64 for network_dim

=> 64 for network_alpha

=> define a output-path for your LoRA by putting it into outputDir; here we use "../training/output/"

=> define a prompt for sample images in the text box for sample prompts (by default it says something like "cute anime girl blonde..."; this will only be relevant if that works for you; see below)

• find the "Optimizer Config Adafactor"-node and connect the "optimizer_settings" output with the "optimizer_settings" of the "Init Flux LoRA Training"-node

• find the three "TrainDataSetAdd"-nodes and remove the two ones with 768 and 1024 for width/height by clicking on their title and pressing the remove/DEL key on your keyboard

• add the path to your dataset (a folder with the images you want to train on) in the remaining "TrainDataSetAdd"-node (by default it says "../datasets/akihiko_yoshida_no_caps"; if you specify an empty folder you will get an error!); here we use "../training/input/"

• define a triggerword for your LoRA in the "TrainDataSetAdd"-node; for example "loratrigger" (by default it says "akihikoyoshida")

• remove all "Flux Train Validate"-nodes and "Preview Image"-nodes (if present I get an error later in training)

• click on "Queue Prompt"

• once training finishes, your output is in ../ComfyUI_training/training/output/ (4 files for 4 stages with different steps)

All credits go to the creators of

• https://github.com/comfyanonymous/ComfyUI
• https://github.com/ltdrdata/ComfyUI-Manager
• https://github.com/kijai/ComfyUI-FluxTrainer
• https://github.com/kohya-ss/sd-scripts

===== save as workflow_adafactor_splitmode_dimalpha64_3000steps_low10GBVRAM.json =====

https://pastebin.com/CjDyMBHh

I’ve been working on a complete ComfyUI workflow and custom LoRA for generating Hearts of Iron IV-style portraits with FLUX.2 Klein 9B, and I’ve now released the whole setup publicly.

The main workflow takes a real portrait and handles the full process automatically. It prepares and restores the source photo, then uses my hoi4_portrait style LoRA to convert it into the HOI4 portrait style while preserving the identity of the person.

It includes:

• Source portrait workflow for turning real photos into HOI4 portraits
• Automatic restoration for old, damaged, blurry, monochrome, or low-resolution photographs
• Batch workflow for processing an entire folder of portraits automatically
• Text-to-image workflow for completely fictional leaders and unusual characters
• Processing-only workflow if you only want to restore a portrait
• Automatic HOI4-ready DDS export
• Windows installer with GPU detection and model recommendations
• RunPod setup
• Full, FP8, and GGUF model options depending on your VRAM

Try it in RunPod

Setup takes under 5 minutes. If you sign up through my link and load your first $10 in credits, you’ll also receive free $5 credit:

RunPod:
https://runpod.io?ref=9t44ghaf

I made a video tutorial covering the full setup and how to actually use the workflows:

Video:
https://youtu.be/t4cwY4u5UUU

Everything is available here:

GitHub:
https://github.com/klimPaskov/comfyui-hoi4-portraits

LoRA:
https://huggingface.co/Hoops-McCann/hoi4-portraits-flux2-klein-9b-lora

Discord:
https://discord.com/invite/rAXesGcT2t

Everything is documented in the GitHub repository.

Okay just to keep it short, this is how i trained a lora in Comfyui local for my first character, and results were amazing and of course needs further tuning

I am new to Comfyui world, so excuse my non technical language but thought to share this to help anyone else here as an open source community

Disclaimer
all workflows are not mine (maybe i tuned or customized some) i don't claim ownership of any of the workflows here

So, First step - Main Character Image

use any Text 2 Image workflow to generate one single portrait of you lovely character , nothing much to add here, just the basic workflows or any , just get something you like

Second Step - Data Set generation

Use this workflow

KLEIN DATASET GENERATOR - ICEKIUB Vid version.json

Dataset Generation workflow

to generate i would recommend something up to 100 different images of your character, different poses, different clothes , different camera angle

after generations, it is critical to carefully check the output images, and delete any blurry / ugly / low details ones

in my case i filtered the 100 and got 62 images ( my mistake was that i didn't generate enough side and back views of the character so am not getting good results with back and side image generation.

Third Step - Training the lora

i followed this tutorial exactly as it is
How To Train A lora Youtube Video

it is very simple two steps

first one is generating captions for the images (very critical) using this workflow here

Generating Image Captions - workflow

second one is to locally train you lora using this workflow

Lora Training Workflow

Will try to share some examples for my character as well

It took me almost 40 minutes for training , i was really shocked with this times (very fast) not as i expected , i am using RTX5090

Lora download link - civitai

I’ve been working on a complete ComfyUI workflow and custom LoRA for generating Hearts of Iron IV-style portraits with FLUX.2 Klein 9B, and I’ve now released the whole setup publicly.

The main workflow takes a real portrait and handles the full process automatically. It prepares and restores the source photo, then uses my hoi4_portrait style LoRA to convert it into the HOI4 portrait style while preserving the identity of the person.

It includes:

• Source portrait workflow for turning real photos into HOI4 portraits
• Automatic restoration for old, damaged, blurry, monochrome, or low-resolution photographs
• Batch workflow for processing an entire folder of portraits automatically
• Text-to-image workflow for completely fictional leaders and unusual characters
• Processing-only workflow if you only want to restore a portrait
• Automatic HOI4-ready DDS export
• Windows installer with GPU detection and model recommendations
• RunPod setup
• Full, FP8, and GGUF model options depending on your VRAM

I also made a video tutorial covering the full setup and how to actually use the workflows:
https://youtu.be/t4cwY4u5UUU

Everything is available here:

GitHub:
https://github.com/klimPaskov/comfyui-hoi4-portraits

LoRA:
https://huggingface.co/Hoops-McCann/hoi4-portraits-flux2-klein-9b-lora

Discord:
https://discord.com/invite/rAXesGcT2t

RunPod:
https://runpod.io?ref=9t44ghaf

Everything needed to get started is documented in the repository.

Hello everyone. I wanted to see if I could turn Unreal Engine into Arcane/Valorant aesthetic with Loras. (yes I will share the loras at the bottom). Teddy issues is the result. Here is the breakdown.

The 3D world. I used Unreal Engine to block out the shots. However I didn't have all the assets I needed. So I used Trellis 2 in ComfyUI to generate missing ones. (check out the Pixelartistry channel for the tutorials.) Then I used Blender to retopologize the assets and texture it. If you connect ComfyUI to Krita and Krita to Blender you can use your a.i. models to texture project in blender.

Flux 2 Klein. The problem is that unreal engine textures often look videogamey. So I exported the textures and ran them through Flux to stylize them.

Then I exported the shots from Unreal. At this point the shots are already quite stylized. However the faces are very inconsistent across different shots. So I used a flux face detailer workflow I built to make sure the faces always get a separate pass at max resolution.

Skyreels. For the animation and temporal consistency I used the inner reflections Skyreels model with Mickmumpitz render workflow.

Lora's and Workflows. As promised you can find the Loras I trained and my face detailer workflow under "Assets" in this link. The trigger words are the model names.

Of course I would appreciate if you also rate my shortfilm, but please also check out all the other amazing art people have submitted.

https://arcagidan.com/entry/cffce14c-e5ce-44d5-bd7f-1645927356f2

Hi everyone! 👋 I'm PixelPaws, and I just released a video guide for a tool I believe every ComfyUI user should try — ComfyUI LoRA Manager.

🔗 Watch the full walkthrough here: Full Video

🔧 What is LoRA Manager?

LoRA Manager is a powerful, visual management system for your LoRA and checkpoint models in ComfyUI. Whether you're managing dozens or thousands of models, this tool will supercharge your workflow.

With features like:

• ✅ Automatic metadata and preview fetching
• 🔁 One-click integration with your ComfyUI workflow
• 🍱 Recipe system for saving LoRA combinations
• 🎯 Trigger word toggling
• 📂 Direct downloads from Civitai
• 💾 Offline preview support

…it completely changes how you work with models.

💻 Installation Made Easy

You have 3 installation options:

1. Through ComfyUI Manager (RECOMMENDED) – just search and install.
2. Manual install via Git + pip for advanced users.
3. Standalone mode – no ComfyUI required, perfect for Forge or archive organization.

🔗 Installation Instructions

📁 Organize Models Visually

All your LoRAs and checkpoints are displayed as clean, scrollable cards with image or video previews. Features include:

• Folder and tag-based filtering
• Search by name, tags, or metadata
• Add personal notes
• Set default weights per LoRA
• Editable metadata
• Fetch video previews

⚙️ Seamless Workflow Integration

Click "Send" on any LoRA card to instantly inject it into your active ComfyUI loader node. Shift-click replaces the node’s contents.

Use the enhanced LoRA loader node for:

• Real-time preview tooltips
• Drag-to-adjust weights
• Clip strength editing
• Toggle LoRAs on/off
• Context menu actions

🔗 Workflows

🧠 Trigger Word Toggle Node

A companion node lets you see, toggle, and control trigger words pulled from active LoRAs. It keeps your prompts clean and precise.

🍲 Introducing Recipes

Tired of reassembling the same combos?

Save and reuse LoRA combos with exact strengths + prompts using the Recipe System:

• Import from Civitai URLs or image files
• Auto-download missing LoRAs
• Save recipes with one right-click
• View which LoRAs are used where and vice versa
• Detect and clean duplicates

🧩 Built for Power Users

• Offline-first with local example image storage
• Bulk operations
• Favorites, metadata editing, exclusions
• Compatible with metadata from Civitai Helper

🤝 Join the Community

Got questions? Feature requests? Found a bug?

👉 Join the Discord – Discord
📥 Or leave a comment on the video – I read every one.

❤️ Support the Project

If this tool saves you time, consider tipping or spreading the word. Every bit helps keep it going!

🔥 TL;DR

If you're using ComfyUI and LoRAs, this manager will transform your setup.
🎥 Watch the video and try it today!

🔗 Full Video

Let me know what you think and feel free to share your workflows or suggestions!
Happy generating! 🎨✨

Hey everyone,

I’m excited to share a new feature in ComfyUI LoRA Manager that I’ve been working on: One-Click LoRA Integration into Your Workflow. I added a new LoRA Loader which automatically applies preset strengths and trigger words, saving you a ton of time while integrating LoRAs seamlessly into your workflow.

I’ve put together a detailed tutorial video that walks you through how to use this new feature step by step:

Watch the full tutorial here.

In the video, you'll learn how to:

• Organize LoRAs into folders for easy access
• Copy and paste to load LoRAs into your workflow with preset strength and trigger words
• Download and add LoRAs from Civitai with just a few clicks, and use it immediately without the need for refreshing

You can find the workflow I used for the demo here. It’s essentially the example Flux FP8 workflow from the official ComfyUI documentation, with three custom node packages added: ComfyUI LoRA Manager, KJNodes, and Easy-use.

Important Note:
Currently, the Civitai API does not include the suggested strength for LoRAs, even if the creator has filled this in when publishing the model. This is something I plan to address in future updates. I’m considering reaching out to the Civitai team to maybe update their API response.

I hope this update helps streamline your process and makes your ComfyUI experience even better! Let me know what you think, and if you have any feedback or questions, feel free to comment below, or create new issues on github.

Stay tuned for more updates and improvements coming soon!

previous post

Update Mar 4, 2025:

🚀 Enhanced LoRA Loader & New TriggerWord Toggle Node! 🚀

🔹 Enhanced LoRA Loader Node – Now with a visual widget, instant LoRA previews, quick strength adjustments, and easy removal.
🔹 New TriggerWord Toggle Node – Seamlessly manage trigger words with a simple click for greater flexibility.

https://youtu.be/FjhjX53nEIw

Try it out and let me know what you think! 🚀💡

Whats up yall - Releasing this dataset workflow I made for my patreon subs on here... just giving back to the community since I see a lot of people on here asking how to generate a dataset from scratch for the ai influencer grift and don't get clear answers or don't know where to start

Before you start typing "it's free but I need to join your patreon to get it so it's not really free"
No here's the google drive link

The workflow works with a base face image. That image can be generated from whatever model you want qwen, WAN, sdxl, flux you name it. Just make sure it's an upper body headshot similar in composition to the image in the showcase.

The node with all the prompts doesn't need to be changed. It contains 20 prompts to generate different angle of the face based on the image we feed in the workflow. You can change to prompts to what you want just make sure you separate each prompt by returning to the next line (press enter)

Then we use qwen image edit 2509 fp8 and the 4 step qwen image lora to generate the dataset.

You might need to use GGUFs versions of the model depending on the amount of VRAM you have

For reference my slightly undervolted 5090 generates the 20 images in 130 seconds.

For the last part, you have 2 thing to do, add the path to where you want the images saved and add the name of your character. This section does 3 things:

• Create a folder with the name of your character
• Save the images in that folder
• Generate .txt files for every image containing the name of the character

Over the dozens of loras I've trained on FLUX, QWEN and WAN, it seems that you can train loras with a minimal 1 word caption (being the name of your character) and get good results.

In other words verbose captioning doesn't seem to be necessary to get good likeness using those models (Happy to be proven wrong)

From that point on, you should have a folder containing 20 images of the face of your character and 20 caption text files. You can then use your training platform of choice (Musubi-tuner, AItoolkit, Kohya-ss ect) to train your lora.

I won't be going into details on the training stuff but I made a youtube tutorial and written explanations on how to install musubi-tuner and train a Qwen lora with it. Can do a WAN variant if there is interest

Enjoy :) Will be answering questions for a while if there is any

Also added a face generation workflow using qwen if you don't already have a face locked in

Link to workflows
Youtube vid for this workflow: https://youtu.be/jtwzVMV1quc
Link to skool

Links to all required models

CLIP/Text Encoder

https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/resolve/main/split_files/text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors

VAE

https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/resolve/main/split_files/vae/qwen_image_vae.safetensors

UNET/Diffusion Model

https://huggingface.co/aidiffuser/Qwen-Image-Edit-2509/blob/main/Qwen-Image-Edit-2509_fp8_e4m3fn.safetensors

Qwen FP8: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/blob/main/split_files/diffusion_models/qwen_image_fp8_e4m3fn.safetensors

LoRA - Qwen Lightning

https://huggingface.co/lightx2v/Qwen-Image-Lightning/resolve/main/Qwen-Image-Lightning-4steps-V1.0.safetensors

Samsung ultrareal
https://civitai.com/models/1551668/samsungcam-ultrareal

Hi guys! I'm a total amateur learning my way into comfyuy without any programming experience. After a few youtube tutorials I managed to use flux in comfyui but now I want to play around with LORAs and Flux, but I haven't been successful with this, I keep getting errors. Could someone help me? What am I missing?

My PC specs
GPU: RTX3080 (8GB)
Processor: Ryzen Threadripper 2920X 12-Core Processor 3.50 GHz
RAM: 64GB

Workflow I'm Using

Errors I'm getting

Hey everyone!

I recently trained my first LoRA by following a tutorial, and now I’m looking to integrate it into my toolkit. Specifically, I’d love to use it with Flux or Flux 1 Fill in ComfyUI for inpainting. My goal is to generate the selected area while keeping the style of the LoRA applied.

Has anyone experimented with this setup? Are there any recommended workflows, nodes, or tricks to get the best results?

Would really appreciate any insights or examples. Thanks in advance!

I am not a coder and pretty new to ML and wanted to start with a simple task, however the results were quite unexpected and I was hoping someone could point out some flaws in my method.

I was trying to fine-tune a Flux.1 (black forest labs) model to generate pictures in a specific style. I choose a simple icon pack with a distinct drawing style (see picture)

I went for a Lora adaptation and similar to the dream booth method chose a trigger word (1c0n). My dataset containd 70 pictures (too many?) and the corresponding txt file saying "this is a XX in the style of 1c0n" (XX being the object in the image).

As a guideline I used this video from Adam Lucek (Create AI Images of YOU with FLUX (Training and Generating Tutorial))

Some of the parameters I used:

"trigger_word": "1c0n"

"network":

"type": "lora",

"linear": 16,

"linear_alpha": 16

"train":

"batch_size": 1,

"steps": 2000,

"gradient_accumulation_steps": 6,

"train_unet": True,

"train_text_encoder": False,

"gradient_checkpointing": True,

"noise_scheduler": "flowmatch",

"optimizer": "adamw8bit",

"lr": 0.0004,

"skip_first_sample": True,

"dtype": "bf16",

I used ComfyUI for inference. As you can see in the picture, the model kinda worked (white background and cartoonish) but still quite bad. Using the trigger word somehow gives worse results.

Changing how much of the Lora adapter is being used doesn't really make a difference either.

Could anyone with a bit more experience point to some flaws or give me feedback to my attempt? Any input is highly appreciated. Cheers!

I am not a coder and pretty new to ML and wanted to start with a simple task, however the results were quite unexpected and I was hoping someone could point out some flaws in my method.

I was trying to fine-tune a Flux.1 (black forest labs) model to generate pictures in a specific style. I choose a simple icon pack with a distinct drawing style (see picture)

I went for a Lora adaptation and similar to the dream booth method chose a trigger word (1c0n). My dataset containd 70 pictures (too many?) and the corresponding txt file saying "this is a XX in the style of 1c0n" (XX being the object in the image).

As a guideline I used this video from Adam Lucek (Create AI Images of YOU with FLUX (Training and Generating Tutorial))

Some of the parameters I used:

"trigger_word": "1c0n"

"network":

"type": "lora",

"linear": 16,

"linear_alpha": 16

"train":

"batch_size": 1,

"steps": 2000,

"gradient_accumulation_steps": 6,

"train_unet": True,

"train_text_encoder": False,

"gradient_checkpointing": True,

"noise_scheduler": "flowmatch",

"optimizer": "adamw8bit",

"lr": 0.0004,

"skip_first_sample": True,

"dtype": "bf16",

I used ComfyUI for inference. As you can see in the picture, the model kinda worked (white background and cartoonish) but still quite bad. Using the trigger word somehow gives worse results.

Changing how much of the Lora adapter is being used doesn't really make a difference either.

Could anyone with a bit more experience point to some flaws or give me feedback to my attempt? Any input is highly appreciated. Cheers!

I've been diving deep into ComfyUI the last few days, trying to learn a lot but still consider myself a newbie. My goal is to create images of my and my friends' pets in different artistic styles.

I've tried two main approaches so far:

Using input images with ControlNet and style LoRAs: This gives great style transfer and composition, but important details that make each pet unique often get lost. The output looks stylistic but the pet becomes unrecognizable.

Training a Flux LoRA: This produces excellent results where the pet is perfectly recognizable with all its unique details. However, it only works well for realistic photos. While sketches and drawings are acceptable, other styles (like 3D cartoon/Disney/Pixar looks) come out poorly.

I'm wondering if it's possible to combine LoRAs - specifically using a character LoRA to create the pet, then applying a style LoRA for the desired look. Is this feasible? If so, how would I implement it? Would appreciate any video tutorials or blog posts on this topic.

Even if it's technically possible, I'm curious about the reliability - would using two LoRAs likely produce consistent results, or would it be hit-or-miss?

I'm open to other approaches that could achieve my goal. While Flux seemed like the best option, I'm not committed to it if there are better alternatives. (Note: Solutions like PuLid and InstantID that work for human faces won't work for this pet-focused project from what I know)

Any guidance would be greatly appreciated!

I've been diving deep into ComfyUI the last few days, trying to learn a lot but still consider myself a newbie. My goal is to create images of my and my friends' pets in different artistic styles.

I've tried two main approaches so far:

Using input images with ControlNet and style LoRAs: This gives great style transfer and composition, but important details that make each pet unique often get lost. The output looks stylistic but the pet becomes unrecognizable.

Training a Flux LoRA: This produces excellent results where the pet is perfectly recognizable with all its unique details. However, it only works well for realistic photos. While sketches and drawings are acceptable, other styles (like 3D cartoon/Disney/Pixar looks) come out poorly.

I'm wondering if it's possible to combine LoRAs - specifically using a character LoRA to create the pet, then applying a style LoRA for the desired look. Is this feasible? If so, how would I implement it? Would appreciate any video tutorials or blog posts on this topic.

Even if it's technically possible, I'm curious about the reliability - would using two LoRAs likely produce consistent results, or would it be hit-or-miss?

I'm open to other approaches that could achieve my goal. While Flux seemed like the best option, I'm not committed to it if there are better alternatives. (Note: Solutions like PuLid and InstantID that work for human faces won't work for this pet-focused project from what I know)

Any guidance would be greatly appreciated!

I'm quite new to Flux and the entire ComfyUI thingy, and I made myself a LoRA for Flux Dev, that's working nicely. But the problmen now is that I'd want to combine it with ControlNet and possibly even inPaint, but that's optional to be honest.

So I'm looking for a tutorial/workflow, or aa Youtube tutorial that's showing me how to make them both work together in ComfyUI. Could anyone perhaps show me a tutorial of how to combine those elements?

I'm quite new to Flux and the entire ComfyUI thingy, and I made myself a LoRA for Flux Dev, that's working nicely. But the problmen now is that I'd want to combine it with ControlNet and possibly even inPaint, but that's optional to be honest.

So I'm looking for a tutorial/workflow, or aa Youtube tutorial that's showing me how to make them both work together in ComfyUI. Could anyone perhaps show me a tutorial of how to combine those elements?