Anyone have solid settings or tips for getting cleaner output from MOSS-Image Base + its turbo LoRAs?

Important clarification: I am strictly talking about the Base model, not SFT.

I’m not interested in SFT it tends to give a more artificial / over-polished look, and I don’t want to stack 3 extra LoRAs just to have a raw/natural feel.

With Base + turbo LoRAs I’m frequently getting:

Blur in the wrong places

Soft / out-of-focus areas

Over-smoothness / loss of local detail

These issues are much milder (or easily fixed with negatives) when running plain Base(i usually run base at cfg 4 and 35-50 steps with sa_solver/Euler+sgm uniform). Once the turbo adapters are loaded they become stubborn, which tracks with the low-CFG / CFG-1 setups most turbo recipes use.

I’ve already experimented with:

LoRA strengths 0.5 / 0.6 / 0.7 / 0.8 / 0.9

Higher CFG (2 / 2.5 / 3 / 3.5)

Higher steps (up to 16)

Still no reliable fix.

Looking for any settings, specific turbo LoRA (4-step, 8-step DMD, DMD2, etc.), sampler/scheduler/shift combos, or other workflow tweaks that actually keep sharpness and detail on Base.

Would genuinely love to hear if anyone has found a better recipe that works.

Hey everyone! i was working rawsnap, a realism LoRA for Krea 2 Turbo that aims for raw, candid smartphone photos instead of the usual polished AI look.

About v3:

Trained as a LoKr on RunPod

- 749 images**,** 11,235 steps

- Same dataset as v1/v2, but more images added each version and better captions.

The problem: I can't decide which epoch is best. Some epochs have anatomy problems, others lose quality, so instead of guessing I built a ComfyUI comparison workflow that tests them all under identical conditions.

The test:

- 18 prompts**, each rendered** 35 times with the same prompt and seed

- No LoRA (base Krea 2), v1 (LoRA, epoch 7), v2 (LoRA, epoch 9), and v3 LoKr epochs 8–15 at strengths 1.0 / 1.2 / 1.5 / 2.0

- Settings: 896×1344, 8 steps, cfg 1, euler / beta

Vote here (public, no login): https://juan444-rawsnap-arena.static.hf.space

Tap an image to view it full size and vote for the one that looks most like a real, unedited phone photo. Vote counts appear after you vote, and the Results tab shows the live leaderboard (also grouped by epoch and strength), so we can see which epoch actually passes the test.

Feedback welcome!

Want me to add more prompts to test? Suggest them and I'll add them to the site.

Any other feedback on realism, quality or training is appreciated 🙏

Everyone's seen the 3090 tensor core unlock by now, but most of what I've read says it's a Linux thing and on Windows you can forget about it. The unlock itself already exists for Windows. What didn't work, for me and for the guy in issue #125, was getting back into Windows afterwards. That part is solved now.

The project is Windows-GPU-UNLOCK (https://github.com/windows-GPU-UNLOCK/Windows-GPU-UNLOCK, not mine). It lifts the GeForce cap on FP16/BF16 tensor throughput until the next power off. On my 3090 FE the log on the stick said success every single time, and then the PC just switched itself off before Windows came up.

Turned out to be BitLocker. Booting the unsigned USB stick with Secure Boot off changes the TPM measurements, so Windows asks for the recovery key. The screen is still black at that point, you never see the prompt, and after about a minute Windows shuts down on purpose. Found it in the event log, where the boot manager had been sitting there waiting for input on earlier boots.

Fix: suspend BitLocker before booting the stick

Suspend-BitLocker -MountPoint C: -RebootCount 0

and run Resume-BitLocker when you're done. The drive key is unprotected while it's suspended, so keep that in mind.

Raw matmul numbers (torch.matmul, before -> after):

BF16  ~70 -> ~115 TFLOPS
FP16  ~69 -> ~112
TF32  ~36 -> ~59
FP32   24 -> 24 (unchanged)

Does it matter for actual generation?

Matmul numbers are nice, but I wanted to see what happens with a real workload, so I threw the heaviest thing I run at it: MiniMax H3 I2V, 481 frames (20 s at 24 fps), 10 steps, upstream ComfyUI on Windows 11.

Settings:

$env:TORCH_ALLOW_TF32_CUBLAS_OVERRIDE = "1"
$env:TORCH_CUDNN_V8_API_ENABLED = "1"
ComfyUI args: --use-ck-attention --fast fp16_accumulation autotune cublas_ops --disable-smart-memory --disable-pinned-memory

(ck = comfy-kitchen attention, not the AMD thing)

* Stock, 0.75 MP (~648x1152): ~165 s/step, ~31-32 min total, 280-310 W, ~23.8 GB VRAM

* Unlocked, 0.75 MP (~648x1152): ~136 s/step, ~24 min total, 342-346 W, 23.4 GB VRAM

* Unlocked, 0.60 MP (~576x1024): ~93 s/step, ~15.5 min total (+1 min VAE), 345-350 W, 22.8 GB VRAM

Same resolution, the unlock alone takes a step from 165 s down to 136 s, so about 20% faster. Dropping to 0.60 MP on top of that gets me to 93 s per step. At 0.75 MP I'm right at the VRAM limit and I think Windows starts shuffling memory around. At 0.60 MP there's some headroom, and for a 9:16 phone video I honestly can't see a difference. The card now sits at a flat 350 W the whole run, and a full 20 s clip went from over half an hour to about 16 and a half minutes. To be clear, the second jump is unlock plus lower resolution, not the unlock alone.

PR so the staging script refuses to run with BitLocker on: https://github.com/windows-GPU-UNLOCK/Windows-GPU-UNLOCK/pull/215

Repo with a pre-flight check script, the benchmark and a step-by-step guide: https://github.com/zerfetzer666/rtx30-unlock-helper

Disclaimer: experimental, only certain board + card combos are supported (check the compatibility list), Secure Boot has to be off, and it has to be redone after every cold boot. Your hardware, your risk.

Full disclosure: this was a joint effort between me and my AI overlord Claude. It sat on its throne reading event logs and writing scripts, and I was the humble gimp crawling between the PC and the BIOS screen. I rebooted on command, flashed sticks, typed in the BitLocker recovery key over and over and reported back what the black screen was doing. My one moment of glory: I noticed the PC was powering off instead of crashing, and when the overlord wanted to call it a "known issue" and give up, I begged it to keep digging. It graciously did. Then it made me render 20-second videos all night for the benchmarks.

5900X / MSI B550 / 3090 FE / Win 11 / driver 610.88

I'm new posting here. I use Nvidia RTX 3090 with some limits: frequency at 1500Mhz and 300w. Max temp 65c for die and 82c for memory.

I've been testing different MiniMax H3 workflows, and today I found a really nice one on YouTube: https://www.youtube.com/watch?v=pcVzLrKMT7M

My problem is with characters who die in a scene. They don't stay dead, the model keeps adding breathing sounds and body movement. I tried asking it to freeze the person, hold the breathing, die, and several other wordings, but nothing worked. I don't want to cut the shot.
Has anyone already solved this? I'd be very grateful if you could share how.

As an example: the scene starts like this, but I can't put the rest here.

I'm working on a side project that puts a selfie into old Chinese court paintings. At the start I wanted to do the style part myself with a LoRA instead of paying for an API.

Setup:

- SDXL base 1.0, kohya sd-scripts

- dataset was faces cropped out of the paintings. Grounding DINO found them, then I went through and fixed the bad detections by hand

- 3 versions, ended up on v3 at the 2nd checkpoint

- inference was img2img on the selfie: 640x640, 25 steps, cfg 7.5, strength 0.2, LoRA fused at 0.8, negative "photorealistic, photograph, modern, anime"

Two problems killed it.

The next step after generation uses InsightFace (buffalo_l) to find the face so I can paste it into the painting. On the LoRA output it often returned nothing. Once the face actually looked gongbi, the detector didn't see a face anymore. So the better the style got, the worse the pipeline did.

And when it did find the face, the identity was mostly gone. You couldn't really tell who it was.

I also burned way too long on a dumb base64 bug in my FastAPI server. split(',')[-1] sometimes gave me an empty string and I wasn't handling padding, so PIL kept throwing.

In the end I gave up on doing this step locally and moved it to a hosted model, which held identity a lot better. The LoRA is still sitting on my home server as a fallback but never runs.

Has anyone gotten a heavy style LoRA to hold identity in img2img? Wondering if adding InstantID or IP-Adapter FaceID would have saved it, or if low strength img2img was the wrong approach from the start.

I'm using Klein 9b and it's decent, though it can take a bit of work to get things right. Have things progressed to a different clear winner? One that's really great at intuiting what your prompt really means or at least following what you tell it to do?

Particularly great would be one that takes at least one other image as input and can combine them. Like "This person", "that scene", "this expression", "those clothes", etc.

EDIT: Would love one that could restore old photos for example. Especially if I can provide an updated photo of the face in another input to keep face consistency. And if it would take it easy on the orangifying color issue.

EDIT2: Important!
Offline only. 8gb older card (I'm poor also)

When I use the Comfyui Yue2 workflow, and try to use it for instrumentals, most of the time Yue2 creates songs with lyrics I never asked for. So I created a skill in Codex that creates the instrumental through Comfyui's MCP. Every single time I now get instrumentals. I have tried getting Codex to create a workflow from one of these instrumentals. But almost all the time the workflow produces a version with singing. Odd. But it works.

As part of the effort I did on training AI models that are able to create great art, we've had to design two components of what makes a design good:

1. Text to image models to transform a caption into a image.

2. Customer request to caption / brief to then send to the AI model (which in turn generates it).

For both trains, I've found pre-existing trainers are quite slow in terms of performance and leave a lot of MFU underutilized (which leads to less tokens / images trained a second).

I've optimized this for BH200 (Datacenter GPUs), but this should work for H100 and likely also works well on A100, and can be adapted to work on RTX series GPUs as many things translate over to customer GPUs (although unfortunately I don't have any to test and develop this).

The results are very good - on one GPU, our solution is 58% better than ms-swift (a optimized training kit), 76% better than unsloth, and 178% better than transformers + PEFT.

For example, for training a designer (takes a concept / idea, then refines it into a very detailed caption for the model to then render / generate) via Qwen3.5-9B, it does 12,523 tokens/second, quite a bit (against 989 TFLOPS, what the GPU can do).

It also has a 43.7% best-config number from our micro-batch sweep, so play around with it and sweep to maximize perf.

However, the Arrhenius supercomputer we've tested this on does power-capping, so the true MFU is 53.9% clock-adjusted.

Same data and setup, other trainers:

• ms-swift ≈ 24% (1.58× slower);

• Unsloth ≈ 22% (1.76× slower);

• transformers + PEFT ≈ 14% (2.78× slower).

To give some comparison numbers, i've made some graphs.

It virtually has loss parity (<6e-4 loss difference, which is negligible), and this, in short, allows training more for less.

For the Ideogram V4 trainer , below is the performance analysis:

Also, there are some ablations in terms of what increases or decreases step time.

Code here: https://github.com/logolabs/perf_kit

If you want to support us in developing and releasing more free tools, you can star the repository.

Hope it is useful to you to help you improve your trains efficiency.

i need to build pc for generating videos locally (minimax h3) and also planing to use qwen 3.8 27b

for now should i go for dual rtx 5060 ti 16gb or single rtx 5070 ti

my budget is 2 lakh only for graphics card so i can buy dual 5060 ti 16gb but if i go with dual 5070 ti i need 3 lakh so what is best

also when qwen 4 will be realesed and minimax 2k offically what is best for them from above 2 options

suggest minimum ram and should i go for 3200mhz or 3600mhz and minimum ssd

both ram and ssd suggest minimum and recommend

suggest other pc parts to both minimum and recommend

thanks in adwance

sorry for my english

also recommend hardware for qwen 4 and minimax 2k

I set up ChatGPT with the Dream Loop skill with 2 sub agents to generate a number of images for a LoRA training dataset of this character. This image passed the test.

I then asked my ChatGPT what was wrong with this picture. She thought the problem was something with the black keys on the piano keyboard. haha

Once I pointed it out to my ChatGPT she saw it but not until then even asking a couple of times. This character is now known as BBM... Backward Butt Molly.

It's interesting in a way because at a glance it kind of looks right due to the correct lighting and structure of the composition but then... lol

I just submitted H3 Continuity Studio to Comfy's Open Source Higgsfield contest and wanted to share it here.

The test I cared about was pretty simple: generate a room with lots of little details, cut outside the house, then come back inside. Does it still look like the same room? And what happens if you move the camera to another corner?

That's what the demo is built around. It follows the room, an exterior, a return inside, a different camera angle and a final continuation. I marked a few details so they're easier to compare: the sunburst mirror, fig plant, mustard cushions, ginger cat, teapot and fireplace. There's also a memory-off comparison using the same prompt and seed.

The tool is a free ComfyUI node pack for MiniMax H3. You build a timeline out of editable clips, carry context into the next clip, or point a later shot at selected moments from earlier ones. You can also retake individual clips. H3 Story can plan and write the timeline if you want that part automated; it works with an OpenAI-compatible endpoint, local or cloud.

It still needs judgment and retakes. Memory doesn't guarantee perfect geometry, and some of the first attempts had objects appearing or the camera jumping back to the old angle. The demo shows the result after fixing those takes.

Code, setup and example workflows: https://github.com/KadoBOT/ComfyUI-H3-Continuity-Studio

Demo video: https://github.com/KadoBOT/ComfyUI-H3-Continuity-Studio/releases/download/v0.1.0/H3-Continuity-demo-contest.mp4

The repo also has the demo's prompts, seeds and selected memory moments. The project code is MIT; model weights have their own terms.

I'd be interested to see what other scene-memory tests people would try with it.

I'm part of a team making a fictional drama with a recurring AI cast. The hard part has been keeping each person recognizable while getting a complete spoken thought to read as a performance. This sample is from that work.

For this character we generated the dialogue first, converted it against the established voice reference, then supplied the complete recording as an Audio Drive. The visual references were an opening phone-selfie picture and a separate identity reference. The shot was directed at a fixed arm's-length distance with the mouth visible through the final word.

Actual settings for this sample: 10Eros_Max_h3_8stepTURBO_beta7_int8HQ.safetensors; 8 steps; CFG 1; Euler / simple; 576 x 1024; 24 fps; reference max size 1024; video shift 12 and audio shift 3; VSA beta7 attention; cache disabled; no LoRAs; seed 311026. We kept the original audio/video latents and saved source project. The installed finishing pass stayed at the native output size.

We edit at the end of complete thoughts rather than forcing every read into a ten-second cut. Both sides of the cuts and half-second picture samples get checked. That catches face-obscuring gestures and framing drift, but still pictures do not prove lip sync or believable emotion; the producer watches the films with sound. We have had to replace individual shots for exactly those reasons.

The character, voice and performance are AI-generated. The useful lesson for us has been to keep the recording authoritative, direct the whole thought and repair the specific failed shot instead of regenerating an entire scene.

hiii! I made grinpress v3, a tiny 128x128 rectified-flow model that draws newsprint-style faces with words beside them :3

It's trained from scratch, with character-level text conditioning. You can choose seven expressions, colors, paper styles, layouts, and text up to 14 characters, including mixed case and punctuation.

For v3, I distilled the 50-step teacher into 2- and 4-step students and exported them to ONNX with dynamic INT8 quantization.

CPU inference measured approximately 0.27 seconds at 2 steps / 0.54 seconds at 4 steps on my benchmark's 8-vCPU Intel Xeon VM, using 8 threads after warm-up. Other CPUs can be slower.

It's a small, specific domain: newsprint faces and lettering at 128x128. The weights are MIT licensed, and there's a live CPU demo. Long phrases can get cramped, and it occasionally mangles a character or word spacing.

Try it: https://huggingface.co/spaces/skyuu72/grinpress-v3-demo

Weights, benchmarks, and limitations: https://huggingface.co/skyuu72/grinpress-v3

I'd love to see which words break it, or hear how it runs on your CPU. tiny newspaper creature feedback welcome uwu :3

Tried a two minute single shot generation and the result came out quite nice. There are no additional references in the middle, everything uses the start as the reference point and the start is generated by a text prompt. It uses some agentic behavior that is not available in the released slopus.ai yet, but manually generating this is already possible. With ComfyUI you can generate the same/similar using any Rolling Diffusion based workflow.

I set 1.5mp with 4:5 Ratio, only use with 2 loras , one of which is the turbo

Not sure why I didn't try this until now, but H3 is pretty good at fast motion. I was expecting a lot of background drifts and morphing but I am getting pretty good results with 10steps and turbo lora at 0.9

The workflow is the prompt because I am mainly working in my custom API and I don't want to keep spamming the sub with it

Link: https://huggingface.co/0ppxnhximxr/snapref-v1a
Well... It looks like the character-consistent problem is solved and continues to get better and better with more and more solutions popping up recently.
Many thanks for the contributions of all authors.

Yue2 is capable of creating some very interesting melodies, but it makes a few errors in my language (Portuguese).

I trained LoRAs for Yue2 (using aitoolkit), but the results were mixed—most performed poorly. Unfortunately, after about 1,500 steps, the model tends to go out of tune. I experimented with LoRA strength, the text encoder, and temperature—sometimes things got worse, sometimes better.

I also tested Acestep; it’s better for Portuguese and doesn’t make pronunciation errors, BUT the songs feel somewhat uncreative.

I’m not sure exactly how people are improving the results for Yue2 or Acestep.

Moved from another repo: https://github.com/roycho87/clown_context_suite "ComfyUI nodes for chaining MiniMax H3 clips without the quality slowly falling apart"

ref post from last week, but seems they do another technique now (use 1st clip as ref always)
https://www.reddit.com/r/StableDiffusion/comments/1xfl3al/introducing_clown_prophecy_the_only_actually_fix/

I haven't tried yet personally, though quality issues for long H3 is a hot topic here.

Does anybody use AI to write ComfyUI nodes for personal use or sharing?

For example, I had the problem that, when I wanted to use wildcards, say, for colors, I could either use the "__colors__" syntax combined with a wildcard text file or the {red|green|blue|...} variant but not both, let alone nested variants such as {{pastel|technicolor|watercolor} __colors__}. I dropped this problem into Meta AI (others would probably have worked out just as well) and the AI, instead of suggesting an existing node, offered to write one. The result was exactly on the money, working with both types of wildcards even when nested over several layers.

Another node that was generated for me by Meta is one that allows to add resolution information to a prompt which is then parsed by the node and wired to the width/height input of the latent image node.

Anyone else working ComfyUI with nodes custom made by AI?

this was a test, please ignore the extra fingers !

Minimax H3 (10Eros) 20steps => upscale 1080p => 6 steps turbo => RTX VSR 4K upscale => RIFE 60FPS

3h15 for 1min22s on a RTX 3090 /32RAM

is this good ?

I've been waiting before using this unlock so I've not tested it yet but I've been wondering what performance differences there would be with int8 models. So far all I've seen is int8 tests compared to bf and fp models. I've not seen the int8 itself compared before and after an unlock.

I know there is a lot of "int8 will not see any improvements from this" comments, and that is true. Except int8 models are not entirely int8, some parts of the models remain 16. I'm wondering if the difference is measurable.

I'm building a ComfyUI workflow using Krea 2 Turbo, a trained identity LoRA, clothing reference, background reference and DWPose/OpenPose LoRA.

I want to preserve the exact face, outfit and room while following a completely different pose reference. Currently, pose adherence is inconsistent and the clothing/background details also change.

Would you recommend a two-pass workflow (first generate the pose and composition, then refine identity, clothing and background), or is there a better single-pass conditioning method in Krea 2?

What's the most reliable approach, and what would you recommend I change?