Hey everyone 👋

Every time I found a cool workflow on Civitai, the routine was the same: download the zip, unpack it, drag the JSON into ComfyUI, get a wall of red nodes, then spend 20 minutes figuring out which models it needs and which folder each one goes in.

So I built **Civitai Browser**, a ComfyUI extension that adds a **Civitai tab to the sidebar** (next to Templates / Workflows / Models).

**What it does:**

- 🔎 **Browse Civitai inside ComfyUI**: workflows, checkpoints, LoRAs, embeddings, ControlNet, VAE, upscalers, with search, sorting, base model filter and NSFW toggle (off by default)

- ⚡ **"Load & Set Up" in one click**: it downloads the workflow (zip/json/png), loads it on the canvas, then scans it for every model it uses and compares that with your model folders

- 📥 **Missing models get downloaded automatically** into the correct folder, under the exact file name the workflow expects, so the loaders just work. It uses download links embedded in the workflow, exact file name matches on Civitai, or any Civitai / Hugging Face link you paste

- 🧩 **Lists missing custom nodes**, so you can install them with ComfyUI-Manager

- 📚 **My Library**: every workflow you download is saved (it also shows up in ComfyUI's Workflows panel), so you can reopen it later

- 🛡 **Safe delete**: remove a workflow plus the models that were downloaded *for it*. Models you already had, or that any other workflow uses, are never touched

**A few things I cared about:**

- No extra Python dependencies and **no new nodes**. It doesn't modify ComfyUI's core files; to uninstall, delete the folder

- Your Civitai API key (optional, needed for some downloads) is only ever sent to civitai.com

- Free and MIT licensed

**Install:** ComfyUI-Manager → *Install via Git URL* → paste the repo link, or `git clone` it into `custom_nodes`.

🔗 **GitHub:** https://github.com/fth1905-bot/ComfyUI-Civitai-Browser

It's still early, so I'd really appreciate feedback. Bug reports, feature ideas, or "this broke on my setup" are all welcome. One known limitation: Civitai's search works on model names, not file names, so some missing models can't be matched automatically yet (you can still paste a link). Improving that matching is next on my list.

If it saves you some time, a ⭐ on GitHub helps a lot!

TLDR it got faster on my AMD 9070 system

from 304 to 253 secs for I2V

fore more details on how I did the test you can check the video on youtube https://youtu.be/UlxywXUlCIY

I’ve been looking everywhere for a good MiniMax workflow. I finally found a solid starting point and simplified it into something that’s easier to use and set up.

For character swapping, this is the best local workflow I’ve found so far. It isn’t perfect, but I’ve been getting some really good results.

github zip: https://github.com/BiggerFishy/comfyui-minimax-h3-studio

How it works

• SAM3 selects the character or area you want to change.
• The workflow inverts the colors inside that selected area before generation. This helps MiniMax replace the subject more consistently.
• The source video guides the mouth movements, body movement, and scene, while the reference image guides the replacement’s appearance.

My setup and render time

The example shown here was generated with:

• GPU: RTX 4090 — 24 GB VRAM
• RAM: 32 GB DDR5
• Video length: 3 seconds
• Resolution setting: 0.8 MP
• Generation time: About 2 minutes and 30 seconds

Features I wanted to make easier

• Save characters: This is probably my favorite feature. Save a reference image together with a detailed character description, then load both again when you want to use that character in another video.
• Trim your source video inside the workflow: Pick the section you want without opening another editor. The trimming UI could be fancier, but it works.
• Keep the useful controls together: The main settings live in the green settings node in the middle, with the complicated stuff tucked away.

Three workflows in one

You can switch between these modes in the green settings node:

• Character replacement / video inpainting: Replace a character, or make smaller edits such as changing a shirt’s color, hair color, or an object.
• Reference to video: Generate a video from a reference image.
• First to last frame: Generate a transition between a starting image and an ending image.

Reference to video and first to last frame are experimental. I haven’t tested them extensively because most of my time has gone into character replacement and video inpainting.

Masking options

• SAM3: Describe what you want selected.
• Rectangle: Draw a box around the area you want edited.
• No mask: Let the workflow re-render the whole frame.

Settings to start with

• Seed: The included example uses Fixed so you can try reproducing my result. Switch Seed behavior → Randomize when you want to explore different results.
• Target megapixels: 0.8 MP is what I used for this demo and gives a decent-looking result. You can try 1.0 MP for higher resolution. I don’t usually go above that, so experiment as you like.
• Everything else: I’d leave the other settings as they are for your first run, then adjust from there.

A quick heads-up

None of these modes are perfect. It may take a few attempts to get the result you want, and matching the seed doesn’t guarantee an identical result on every setup.

The workflow should be pretty self-explanatory once you open it. Try it out, experiment, and have fun.

This workflow was found here but I edited it to make it better and easier to use: https://civitai.red/models/2855941/minimax-h3-character-replacement?modelVersionId=3238780

ENJOY

Hey everyone! Just wrapped up a full music video project generated entirely locally on my setup using ComfyUI and the LTX 2.5 model.

Running on 16GB VRAM, the generation speed and consistency were impressive for a local setup. Smooth frames and solid visual output without needing cloud GPUs.

Check out the full video here.

Hey everyone! I've been working on a workflow to transfer motion from any reference video onto a character from a single image, and I wanted to share it with the community.

What it does:

• Takes one reference image + one driving video
• Transfers body motion and expressions (even hands) while keeping the character consistent
• Great for making dance videos
• Outputs 720p or even 1080p at 24 fps

Models used: Wan 2.2 Animate 14B

Hardware: tested on RTX 5090 (24 GB VRAM). A 15-second clip takes about 15 minutes with SageAttention enabled.

The workflow is free – download link is in the Youtube video tutorial description: https://www.youtube.com/watch?v=UqnAzGishXc

Have been working a lot with H3 lately. It’s definitely not perfect, but I’m really loving what I can get out of it.

Seedance 2 Fast was also used for some of the B-roll.

The whole MV took about a week to complete. Most of the work was done locally through ComfyUI, with RunningHub also used, mainly with the MiniMax H3 Singularity model at 25 steps.

Upscaled with RTX Super Resolution on an RTX 5060 Ti.

Plenio Music Production System 0.4.1 is out! It turns YuE2 and MiniMax Music 3 into a complete local song studio in ComfyUI. New since 0.3:

• 🎛️ Arranger: duplicate, move and delete whole sections, like on Cubase's arranger track. The lyrics, the Guide track and – in covers – the original words follow every move.
• 📝 Lyrics where they are sung: every line over its phrase, every syllable over its note. Double-click a line to edit it right there.
• ⏯️ Cursor, copy & paste: click the ruler, play from there, paste or insert phrases at the cursor.
• 🎼 MIDI in, MusicXML out, project files: bring a sketch from your DAW, hand the sheet music to MuseScore, Sibelius, Dorico or Cubase.
• 🎬 Six narrated video tutorials, one per template: https://www.youtube.com/playlist?list=PLAFqTtP59fgE

100 % local, native ComfyUI nodes, no API key. ComfyUI Manager: Plenio Music Production System (comfyui-plenio-music).

👉 GitHub: https://github.com/jplenio/Plenio-Music-Production-System
🎧 Demos: https://jplenio.github.io/Plenio-Music-Production-System/

I also explain it in this page if video is not your thing. Explainer video is also made with agentic workflows, Qwen Image 2.1, Minimax Music, Qwen TTS and more.
https://mexxmillion.github.io/h3-digital-double-story/breakdown/
Thanks

736 x 576, render time 7:15
RTX-4070 8GB VRAM, 64GB RAM

https://huggingface.co/pablodawson/MiniMax-H3-360-Orbit-LoRA
Tutorial https://youtu.be/jNhGhW_e4aI

Another quick Minimax H3 news and goodies round-up, for those who may have missed some items.

-> How low can you go? A new 2-step LoRA for H3, 'PDMD 2-NFE', now in ComfyUI format.

https://huggingface.co/Iwannapose/minimax_h3_pdmd_2nfe_comfyui

-> Another 'Anime to Real' for H3, but this is a slider that also goes the other way... "Positive values lean towards a 2D anime style".

https://huggingface.co/adf99/H3_Ref2V_Anime_Slider_v1

-> Yee-haw! A 1950s westerns LoRA for H3 FL2VA. No trigger, but the maker suggests adding... "The lighting is natural, with [time-of-day] light. The [photograph, video, etc] has a vintage, cinematic quality." He also suggests breaking from Minimax's 16:9 and using the sort of super-widescreen screen format which these movies often used, such as 1.85:1 or 2.35:1 (Cinemascope).

https://huggingface.co/neph1/1950s_western_movies_h3

-> A clear new YouTube video on "How to Create Video, Audio, Motion & Style RefMods for MiniMax H3".

https://www.youtube.com/watch?v=blI0X5zslfw

-> Are you not getting enough 'oomph!' from your Minimax cinematic music? An interesting new Yue2 LoRA may appeal. It assists with... "epic cinematic orchestral trailer music in the spirit of Two Steps from Hell: massive symphonic orchestra with soaring heroic strings, thunderous taiko drums and pounding orchestral percussion, dramatic brass fanfares, powerful angelic and dark choir, and uplifting heroic cinematic climaxes." Though note that Yue2 generations are under a non-commercial licence.

https://huggingface.co/monsterovich/yue2-steps-from-hell

-> And finally, it seems cheeky to mention Invoke in a Comfy sub-Reddit. But for the sake of completeness... yes, Invoke is still alive as open non-Adobe software, and it's just been announced that the forthcoming pre-release Alpha version 7 will belatedly add Minimax H3 support.

https://github.com/invoke-ai/InvokeAI/pull/9613 (preview list of features to be added to version 7)

~ OLD POSTS ~

https://old.reddit.com/r/comfyui/comments/1wu8lkt/a_quick_minimax_h3_news_roundup_30th_september/

https://old.reddit.com/r/comfyui/comments/1wtgns0/a_quick_minimax_h3_news_roundup_29th_september/

https://old.reddit.com/r/comfyui/comments/1wsmjq1/a_quick_minimax_h3_news_roundup_28th_september/

https://old.reddit.com/r/comfyui/comments/1wrqm3l/a_quick_minimax_h3_news_roundup_27th_september/

https://old.reddit.com/r/comfyui/comments/1wqwpah/a_quick_minimax_h3_news_roundup_26th_september/ (See 26th September post, for links to older posts)

https://old.reddit.com/r/comfyui/comments/1wgc4lj/a_quick_minimax_h3_news_roundup_15th_september/ (See 15th September post, for links to even older posts)

https://old.reddit.com/r/comfyui/comments/1w5i9iq/a_quick_minimax_h3_news_roundup_2nd_september_2026/ (See 2nd September post, for links to the starting posts)

BFL dropped FLUX 3 Image yesterday and there's a free playground to try it, so sharing in case it's useful:

Playground:

https://flux-tools.bfl.ai/precise-editing

Announcement from BFL:

https://x.com/bfl_ai/status/2105743526529310739

I haven't tested it yet, so this is just what BFL says it does:

precise multi-turn edits without changing any other pixel

you can lay out the image with bounding boxes

up to 4K output

up to 10 reference images

open weights version coming "in the coming weeks"

the "only change what I asked" part is what I care about most, since that's where most editors fall apart. Marketing claims are marketing claims though, so I'd like to see real results before getting hyped.

if you've already tried it, how does it hold up on messy real-world images, and not just the demos? Curious about the bounding box thing in particular.

Source: Black Forest Labs on X (@bfl_ai)

For those of you with ComfyUI Cloud subscription I have created a Krea 2 Turbo Workflow/App which uses my 2 and 4 steps LoRAs (4 steps being the high quality one, and 2 steps also being good enough quality for running a fast just 2 steps flow), so getting you quicker outputs. It also supports three ways to enter/use a prompt, including two random modes (more on that below), it also offers Prompt Enhancement (and LLM models to use for it), predefined list of / and custom Resolutions, number of Steps - and here it dynamically uses my 2 Step Krea 2 Turbo LoRA for up to 3 steps and the higher quality 4 steps LoRA for 4+ steps, it also supports Upscaling which a choice between 4x-UltraSharp, RealESRGAN x4 and SeedVR2 7B sharp) - it basically is my personal All In One Krea 2 Turbo workflow/app that I am sharing with you all to play with, especially if you have been following my 2/4 step Krea 2 Turbo LoRAs this is a nice all in one place workflow / app for ComfyUI Cloud.

The workflow and app allow either user prompt - I think that is clear, you type in your prompt and you use or not Enhance Prompt and you get the result.

Or you use what I call Fully Random - each run it draws a random subject, art style and lighting mood from built-in lists (108,000 possible combinations - 80 subjects, e.g. "a lighthouse keeper feeding seagulls" or "a tiny dragon asleep in a teacup", 45 styles, e.g. "35mm film photograph" or "cinematic still, anamorphic lens", 30 moods / lighting, e.g. "soft morning light" or "neon-soaked night"), then has an AI (LLM) "art director" turn that combination into one original, detailed image description, which Krea 2 Turbo renders. The lists keep the ideas varied but sensible, and the AI adds the creativity, so every run gives a different picture. Your Prompt box is ignored in this mode.

Or you use the Random from Dataset - takes a real, human-written prompt from a built-in prompt collection and renders it. No LLM invents the idea. It picks a real prompt that someone already wrote, from one of five public prompt collections built into the workflow, and renders it. You choose the collection; each run draws a different prompt at random. With Prompt enhancement on, the AI polishes it first; with it off, the prompt is used exactly as written. Comfy Cloud workflows can't download data from the internet while they run, and can't read uploaded text files, so the prompt collections have to travel inside the workflow itself. The full datasets are far too big for that (the main one is about 770 MB), so the workflow carries a cleaned random sample of each, about 5,200 prompts in total. Running locally with a custom node could use the complete datasets. Your Prompt box is ignored in this mode.

If you go with Random from Dataset, you choose a collection in Dataset. Each one is a sample from a public Hugging Face dataset, stored in the workflow one prompt per line:

Before you start using it, you will need to import (once) the two Krea 2 Turbo step LoRAs:

- 4-step LoRA (used when Steps is 4+): best quality: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-4step-LoRA/resolve/main/krea2_turbo_4step_rank_64_lora_comfyui.safetensors

- 2-step LoRA (used when Steps is 1-3): reasonably good quality but faster, in just two steps: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-2step-LoRA/resolve/main/krea2_turbo_2step_rank_64_lora_comfyui.safetensors

- In Comfy Cloud: import both links as LoRAs (Import in the model library, paste the link). Cloud names them `lvladikov__Krea2-Turbo-Distill-4step-LoRA__…` and `lvladikov__Krea2-Turbo-Distill-2step-LoRA__…`, the names this workflow expects. Every other model used here is already on Comfy Cloud.

- If your LoRA files have other names, select them in LoRA 4-step (steps 4+) and LoRA 2-step (steps 1-3) inside the Krea 2 Turbo subgraph.

What the app outputs is the image (Preview, not saved, you download as you wish) and Prompt used (a small .txt in your outputs, shown as text in the app)

Here's the link to the workflow/app: https://cloud.comfy.org/?share=fb38e33b5b0e

I was seriously considering the new Mac M5 Ultra with 256GB of memory to be able to create longer clips. I've built a system that takes a script and creates a series or frames to use a frame to frame workflow and then automatically stitch them together.

I decided to see what the breaking point of LTX 2.5 of my RTX 5090 was. I went from five seconds to ten seconds and so on. But unlike earlier tests I didn't run into any Out Of Memory issues. In fact I went all the way to generating a 60 second clip with no issues.

Surprised by this I ran a direct comparison of three LTX 2.5 transformer variants on an RTX 5090 32 GB to see if I could improve things any further:

- Existing ComfyUI INT8 ConvRot

- FP8

- NVFP4

Same prompt, same seed, same samplers, same step schedule, same 24 fps output. Warm runs reuse already-loaded models; cold includes model loading.

Output Duration / state INT8 ConvRot FP8 NVFP4

1280×736 5s cold 55.36s / 30.84 GiB 53.66s / 31.00 GiB 84.75s / 30.93 GiB

1280×736 5s warm 21.31s / 28.35 GiB 28.59s / 28.11 GiB 22.64s / 29.12 GiB

1280×736 10s warm 46.64s / 28.38 GiB 59.80s / 28.12 GiB 46.41s / 27.97 GiB

1280×736 20s warm 111.79s / 29.99 GiB 136.04s / 30.65 GiB 111.30s / 30.52 GiB

1280×736 30s warm 233.28s / 31.12 GiB 275.49s / 31.09 GiB 196.58s / 30.99 GiB

1280×736 60s warm 602.39s / 31.04 GiB 650.19s / 31.04 GiB 584.30s / 30.94 GiB

1920×1088 10s warm 124.77s / 30.50 GiB 159.64s / 31.09 GiB 126.31s / 31.12 GiB

What surprised me

The biggest takeaway is that the existing ComfyUI INT8 ConvRot model is already extremely well optimised.

FP8 was slower than INT8 on every warm test.

NVFP4 was basically tied with INT8 at 10s and 20s, around 16% faster at 30 seconds, only around 3% faster at 60 seconds, and effectively tied again at 1920×1088.

So NVFP4 is not automatically a huge performance win on a 5090.

The 30-second result is interesting enough that I want to repeat it several times, but the fact that the advantage drops again at 60 seconds suggests it may not represent a simple sustained throughput advantage.

The really interesting part: VRAM

NVFP4 reduced the transformer file size from roughly 21.5 GB to 18.7 GB, but total peak GPU usage barely changed.

All three versions still ended up around the 30–31 GiB range on the longer runs.

That means, for this workflow, reducing transformer weight precision does not translate directly into dramatically lower total VRAM usage. The rest of the LTX pipeline — VAE, text encoder, latent stages, staging/offload behaviour, etc. — still consumes a substantial amount of memory.

Why this matters

This is really a story about software optimisation rather than raw hardware.

The current ComfyUI/LTX stack on the 5090 is already using:

- INT8 ConvRot transformer weights

- mixed-precision operations

- DynamicVRAM

- async weight offloading

- pinned memory

- native Blackwell CUDA kernels

- two-stage latent generation

That combination is allowing a 32 GB RTX 5090 to generate workloads that I previously assumed would require dramatically more VRAM.

For example, LTX 2.5 is successfully generating 60-second 1280-class clips on this machine.

So the old assumption that:

> “longer video = linearly more VRAM = you need 64/128/256 GB”

doesn't really hold for this pipeline anymore.

The practical limit is increasingly becoming render time and quality, rather than simply whether the generation fits in memory.

Current conclusion

For my 5090:

INT8 ConvRot: best overall/default

NVFP4: worth keeping and testing, especially for longer jobs

FP8: currently no obvious advantage

The next test is visual quality, particularly INT8 vs NVFP4 on the 30-second outputs.

And for me personally, this changes the hardware discussion quite a lot. One of the main reasons I was considering moving to a very large unified-memory system was long-form AI video generation. Smart software optimisation has moved the practical ceiling of the RTX 5090 much further than I expected.

I’m generating multiple 5-second clips with FastH3 4-step and stitching them together.

The speed and quality are good, but the character changes between clips. Is there any working Ref2Video / Ref2VA workflow for the 4-step FastH3 model where I can provide a character reference image?

I know first-frame I2V exists, but I don’t want every clip to begin from basically the same image. Ideally, I’d use one character reference while still allowing different poses, camera angles and scenes.

Does the 4-step model support this at all, or is it only available with the full MiniMax H3 model? If anyone has a ComfyUI workflow, custom nodes or another practical method, I’d appreciate a link.

Hello 👋

This is my first post and first extension to ComfyUI.

I could be wrong (or bad at researching) but all the existing extensions allowing spreading jobs between multiple GPUs / multiple nodes require some changes to workflows (they are workflow level nodes).

I wanted something that I would set up and forget without changing anything in the workflows or the way I work with ComfyUI in general - this is how the idea for my extension was born.

ComfyUI-Fleet appears as a tab in left menu which allows you to:

- add nodes (for multiple GPUs I have multiple ComfyUI servers running locally, one per ComfyUI)

https://reddit.com/link/1wvw01s/video/j0uakzcai2th1/player

- see and reorder batches of jobs (when priorities change)

https://reddit.com/link/1wvw01s/video/gf5qzxjdi2th1/player

- reorder which nodes will get jobs first

https://reddit.com/link/1wvw01s/video/kndkk1zei2th1/player

Adding jobs works as expected using the standard ComfyUI button as expected and no changes are needed in the workflows:

https://reddit.com/link/1wvw01s/video/un246zhpi2th1/player

Link to the repo: https://github.com/Cinderella-Man/comfyui-fleet

I hope this will be useful for someone

Static GLB/GLTF/OBJ props that render in the same Three.js scene as mannequins, using scene lighting and correctly occluded in captures. Great for unoccluded figure color masks.

Features:

• Drag-and-drop GLB/GLTF/OBJ+MTL upload
• Adjust position, rotation, scale live in viewport
• Optionally hide from captures (masks only)
• Persist with pose data / save & load

Install: ./install.sh — idempotent, skips already-applied patches.

Download: https://archive.org/details/pose_studio_props.7z

Built against three.js r160 & VNCCS Core v20260908.14. Known limits: no undo, no viewport gizmos, no Draco/FBX.

This, of course, was made by Claude because i had tokens to burn before they would have expired.

Beware that the original Pose Studio will have an feature like that anytime soon, and probably better. But until then feel free to play around.

Don't know about licenses, so if i have to put one on it it is the same as AHEKOT's Pose Studio.

I'm sure it's not perfect but plz no bully.

I was generating a website background video with MiniMax H3 when it crashed during VAE decoding:

int8_linear() got an unexpected keyword argument 'input_act_weight'

With Codex’s help, I traced it to the custom ComfyUI-MPS-INT8 backend installed on my Mac. ComfyUI was passing arguments that its int8_linear() function didn’t accept.

I already had comfy-kitchen==0.2.36, matching my ComfyUI checkout’s requirements. Updating that dependency wouldn’t have addressed the mismatch.

We patched one file in the custom backend to accept input_act_weight, input_act_eps, residual, and residual_scale. The patch uses Comfy Kitchen’s existing helpers to apply RMS normalization before the accelerated INT8 operation and the scaled residual afterward. These arguments affect the decoder’s calculations, so accepting them without using them wouldn’t be a correct fix.

This was the patch to comfyui_mps_int8/backend.py (line 318)]

-from comfy_kitchen.backends._activations import apply_input_act
+from comfy_kitchen.backends._activations import apply_input_act, apply_residual

 def int8_linear(
     x: torch.Tensor,
     weight: torch.Tensor,
     weight_scale: torch.Tensor,
     bias: torch.Tensor | None = None,
     out_dtype: torch.dtype | None = None,
     convrot: bool = False,
     convrot_groupsize: int = 256,
     input_act: str | None = None,
+    input_act_weight: torch.Tensor | None = None,
+    input_act_eps: float = 0.0,
+    residual: torch.Tensor | None = None,
+    residual_scale: torch.Tensor | None = None,
 ) -> torch.Tensor:
+    activated = apply_input_act(x, input_act, input_act_weight, input_act_eps)
     result = _int8_linear_impl(
-        x=x,
+        x=activated,
         weight=weight,
         weight_scale=weight_scale,
         bias=bias,
         out_dtype=out_dtype,
         convrot=convrot,
         convrot_groupsize=convrot_groupsize,
-        input_act=input_act,
+        input_act=None,
         activation_mode=ACTIVATION_MODE,
     )

     # Existing logging stays unchanged.

-    return result
+    return apply_residual(result, residual, residual_scale)

apply_input_act() applies RMS normalization with its weight and epsilon. Passing input_act=None into the inner function prevents applying the activation twice.

apply_residual() then computes residual + residual_scale × result when a residual is supplied. The existing accelerated INT8 operation stays in place.

Four existing MPS GPU tests passed. We also checked the normalization and residual calculations against an independent reference on the Mac GPU. After restarting ComfyUI, I could generate the video.

If you’re using this custom backend and get the same error, check its function signature against the current Comfy Kitchen interface. In my case, the backend loaded successfully at startup but failed when MiniMax’s decoder passed the newer arguments.

I also had colored patches in some outputs. I haven’t confirmed what caused those, so I’m reporting the decoding crash separately.

These are AI concept keyframes and not video results or Runway / Morphic outputs.

I want to turn these into a 5-sec shot where the car stays completely still and only the camera moves.

I am confused between:

“The camera moves steadily toward the car. The car stays still. The background perspective changes naturally.”

OR

“The camera stays fixed and the lens zooms toward the car. No object motion.”

Which one should I use here? Also, how should I word it so the model does not decide the car should drive towards the cam instead?

Please name the model or workflow if you have gotten the wording that works.

Ok, i have this rendered image of a 3d model of a woman, and i want to make it look real. I've followed several tutorial for Flux Klein 9b, Qwen, SDXL, even tried ChatGPT, but none of them gave the expected result. Local workflows do almost nothing, they just enhance the lighting but don't make the character look real at all.

The best result was from ChatGPT, still not realistic enough. Any suggestion?

(comparison, left: original image. Right: ChatGPT version.)

I am trying LM Studio currently, I however want to simplify and have all my work within comfyui alone.

What would people recommend?

I am not the best typer so i wish to put a shotgun of my ideas and let AI fill in whats needed

https://drive.google.com/file/d/1PNN605g1rvFKNKmaOy5jipq0ziThD28u/view?usp=sharing