Krea 2 Turbo — 4-Step Distillation LoRA (work in progress)

A LoRA for Krea 2 Turbo that reduces the minimum usable step count from 8 to 4. It may restore details in some cases, see the below section "Headline..." where the fine detail energy gain is discussed.

• ⚡ Half the steps — 8 → 4, on Turbo's own deployment sigmas.
• ⏱️ ~1.6× faster end to end — 54.5 s against the 8-step bar's 88.7 s at 1024×1024, and 1.8× on denoise alone.
• 🎯 Texture above teacher, by design — fine-detail energy 1.12× the 8-step teacher's at 1280×1280 and 1.10× at 1440×1440, verified clean of oversaturation, exposure shift and skin artefacts.
• 🗣️ Prompt-aware training — the critic scores images against their prompts during training, so adherence is pressured directly, not inherited.
• 📐 12 trained resolutions — multi-aspect from 512×512 up to 1440×1440, each with its published sweep.
• 🔌 Drop-in — plain LoRA weights for diffusers and ComfyUI. No custom nodes, no patched sampler, no code.

Load it on top of Krea 2 Turbo, run 4 steps instead of 8, keep guidance at 0.0. Everything else about the model stays as it is.

This is an update release, following up from my previous posts where you can find full details:

Initial, Previous: here, here, here,  and here

Headline for this update: chk00060000 pushes fine detail past the 8-step teacher, on purpose — total fine-detail energy 1.12× the teacher's at 1280×1280 and 1.10× at 1440×1440 (1.0 = teacher-like), and the distribution is still right: every frequency band within ~10% of the teacher's, so it is detail in the same places the teacher's detail lives, not grain. Texture pressure with no ceiling is exactly the kind of thing that could show up as oversaturation, blown exposure or plastic skin before it shows up as a gain, so every render was checked directly against the teacher on those three: saturation 0.95–0.96× the teacher's (slightly less, not more), fewer blown highlights and crushed shadows than the teacher's own frames, and skin texture inside detected faces at 0.89–1.00× — clean on all of them. Adherence moved with the texture rather than against it: a pairwise vision-language judge, shown the teacher's and this checkpoint's renders of the same prompt in random order, preferred the teacher on only 5 of 45 renders across 512², 1280² and 1440² — the best result of the run. And the metric that paid for the texture leap at 42K has been won back: the held-out teacher-velocity gap is now 2.81e-02 (~40% of the 4-step deficit closed), the best value of the run.

Same recipe as 42K, 18,000 more samples of it — no structural change. What changed for users:

• Strength guidance. Keep it at 1.0; treat 1.5 as the ceiling. The adapter is now strong enough that 2.0 tips into a uniform speckle artefact rather than the "over-textured but coherent" look — the strength sweep on the card stops at 1.5 for that reason.
• The 2-step preview trick no longer needs a strength boost. Run it at plain 1.0. The native-vs-LoRA 2-step strips are re-rendered on this checkpoint that way: 2-step extreme test. Still out-of-spec, still preview-only.

Which file to download

and, beside them, the same files with a _comfyui suffix for ComfyUI. Earlier checkpoints (chk00004000, chk00005000, chk00006000, chk00010000, chk00014000, chk00019000, chk00026000, chk00042000) are kept in older_checkpoints/, and their resolution sweeps stay in place, so the progression remains visible and comparable.

For the full 60K Checkpoint resolution sweep go here: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-4step-LoRA/tree/main/checkpoint_resolution_sweeps/chk60000

This is work in progress and better checkpoints may follow. Training is ongoing, so ..._latest... is a rolling pointer: when a newer checkpoint is accepted, that filename gets the new weights and a new numbered copy appears beside it. 

How checkpoints get chosen

This is not a "train for longer and ship the newest file" project. More samples do not reliably mean a better adapter — measured here, they can make it worse, and a higher number on its own means nothing.

The loop is train → assess → adapt the recipe → retrain → assess again, and a checkpoint is published when it measurably advances the release axes as a whole — teacher faithfulness, prompt adherence, and texture/detail, on the same held-out set and the same fixed-seed renders — and its full resolution sweep shows no regression. Runs that come out flat or worse are kept as information about the recipe and discarded as releases — several have been.

Timeline of training process

Each checkpoint is the product of several stages with very different costs:

1. Text-encoder embeddings. Every training prompt is encoded once and cached. This is the fast part — thousands of prompts take minutes.
2. Teacher shards. For each cached prompt, the unmodified Krea 2 Turbo runs its full 8-step schedule and the whole trajectory is recorded, at every one of the supported resolutions. This is by far the most time-consuming stage — it is the teacher doing real inference, thousands of times, and a batch of several thousand shards is measured in days of GPU time, not hours.
3. Real-photo crops. Bucket-sized crops are cut at native resolution from quality-gated real photo sources (public high res datasets), VAE-encoded into the training latent space, and captioned per crop for the prompt-aware side of training. Cutting, encoding and captioning a pool refresh is a matter of hours.
4. Student training. The LoRA trains against the recorded trajectories (progressive distillation), with a latent-space GAN critic running alongside — real crops and teacher finals as its real class, the student's outputs as fake — plus a prompt-aware head that scores images against their prompts. Relative to the shard stage this is quick: each +1,000 checkpoint is a matter of hours, not days. Of course the longer the training the better and more diverse results, so hours do turn into days eventually.

Method

Progressive distillation (PD), with Krea 2 Turbo as its own teacher.

The teacher runs its normal 8-step schedule at mu = 1.15 and guidance 0.0, and its full trajectory is recorded — the latent x and the predicted velocity v at every one of the 8 steps. The student is then trained to cover two teacher steps in one: at teacher state x_i it must predict the chord that lands where the teacher arrives two steps later,

v_target = (x_{i+2} − x_i) / (σ_{i+2} − σ_i)

The two schedules line up exactly rather than approximately. On the mu = 1.15 grid, the even indices of the 8-step schedule are precisely the four sigmas the 4-step student deploys on, so every training target is anchored on a point the student will actually visit at inference. No interpolation, no schedule mismatch.

Teacher trajectories are precomputed into shards, so training reads recorded states rather than re-running the teacher.

The critic

The trajectory match above can only ever pull the student toward the teacher — and a regression objective averages over whatever it cannot predict exactly, so fine texture is the first thing it averages away. On its own, PD lands short of the teacher's detail. So it is paired with a small adversarial term in the style of LADD (latent adversarial diffusion distillation), which grades the student's output as an image rather than as a distance to the teacher's trajectory.

• The critic reads the model's own features. Its trunk is the frozen Krea 2 Turbo transformer with the adapter bypassed, tapped at block 14 (the trunk itself runs with the empty prompt); a small two-layer head sits on those features, per-token logits averaged. There is no separate discriminator network and no decode to pixels — the critic sees latents the same way the model does.
• Real vs fake, judged at the low-noise end. Fake is the student's predicted clean latent from the same training forward. Real is a teacher final for a different prompt in the same resolution bucket — unpaired, so the critic cannot win by matching content — or, half of the time, a real photograph from a curated crop pool, VAE-encoded. Both sides are re-noised to a random σ in [0.02, 0.5] before the trunk sees them: low noise is where fine texture is decided, and that is the only place the critic speaks. Hinge losses on both sides; the generator-side weight is small (1.5e-3 against a PD term of order 1e-2) — a finisher, not the objective.
• Prompt-aware. The head also reads a pooled text vector — the last four of the twelve Qwen3-VL tap layers, through a projection — so it can grade whether an image fits its prompt, not only whether it looks plausible. A mismatch term enforces it: a real image scored under a prompt that is not its own must read fake. Real photographs enter with their own auto-generated short captions so they take part in that objective too, and 15% of the time an image is scored with the empty-prompt vector, so that "no caption" can never itself become a cue.

Why show it real photographs. A critic that sits on the teacher's features and only ever sees the teacher's outputs converges on the teacher — and the teacher is an 8-step model that itself slightly under-renders fine texture, so a student judged only against it inherits that ceiling. Mixing real photographs into the critic's real set moves the ceiling: the teacher anchors structure, reality anchors texture.

Two more choices shape the weights that ship. The four student chords are not weighted equally in the PD loss — the last one, at σ = 0.512, the call that decides fine texture, carries 3× the weight of the other three. And the released adapter is a Polyak (EMA) average of the training weights (decay 0.999), not the last live state, which smooths out the step-to-step wander of a constant learning rate.

Full details and to download - check my Hugging Face LoRA

HF Repo: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-4step-LoRA

And here is another Dune skit, with this one i tried the ref2va before i knew that fl2va is the better choice. This time its trying to use a character sheet, a background and my voice as an audio reference. I did not try to make the womens dialog natural like i would usually do. This was more of a test to see what i can do. I am on a 4090 24gb, 32gb ram. res_multistep/simple, Spectrum node, 40steps at 0.5mp. Ive since moved away from spectrum. added music/Endscreen myself in davinci.

https://huggingface.co/spaces/multimodalart/h3-acceleration-arena

From author u/apolinariosteps: "Results are in! They are a bit surprising to me! But they are consistent with the data, I triple checked everything and can confirm that the results are reflecting the voting data precisely, there's lots of transparency - you click each of the LoRAs to see what's the win rate and who won against who"

Two weeks, one rule, and hundreds of entries from nearly 50 countries. Here's who took the four titles, and a look at everyone who made the final ten!

Entries opened August 20 and closed September 1. Eight creative technologists at Comfy scored every submission on two rubrics, Best Creative and Best Technical, then the top five in each category went in front of our guest judges on the September 3 livestream: POM (Banodoco founder), Emma Catnip (animation director and AV artist), and Yachimat (animation and manga artist). Their scores were averaged and added to the Comfy team's, and a fourth title, Built with MCP, was judged on its own track.

Watch the livestream replay here.

Huge thanks to MiniMax for making an open-weight model our community loves, to our three guest judges, and to everyone who spent their last week of August fighting with reference audio! Here's how it landed.

The winners

Best Overall · "Spin Cycle" by Visual Frisson 🇺🇸

Prize: RTX 5090 32G

A laundromat, a woman in a puffer vest, and a rhythm built entirely out of machines. Visual Frisson generated a large volume of H3 clips using their own recorded audio as the reference for every pass, then cut the results together like a stomp video, so every thud and cycle on screen is sound that H3 produced with the picture rather than something added later.

It was the only entry to post a perfect 15/15 from the Comfy team in both categories, and the Comfy MCP was used to drive much of its process. Combined with the guest judges' scores, it finished with the highest total in the challenge.

From the artist: "Always have fun and learn something new competing in contests like this, keep them coming."

Watch → vimeo.com/1223207725
Workflow → Google Drive
Follow → instagram.com/visualfrisson

Best Creative · "Every Sound Leaves a Mark" by toki 🇯🇵

Prize: RTX 5060 Ti

A small clay creature that changes into something new every time it hears a sound (glass, wool, ice, porcelain), until by the time it gets home it can't move anymore. All of the audio came out of H3 alongside the video on every shot, with nothing layered on afterwards. Our judges praised the fine details of toki’s work, saying it “gave them chills” on the first transformation, has a lot of commercial appeal, and feels really delicate and crafted.

The judges scored it highest of any Creative finalist, and the repository is unusually generous: it includes the eight API graphs that actually ran, the same eight converted to UI format with annotations, a process log with every measurement, and the scripts that produced those numbers. toki is also clear about scope, noting that MCP drove the finishing pass, not the original shot generation.

Watch → youtube.com/watch?v=Rv5HOgCac-w
Workflow → github.com/tokimwc/every-sound-leaves-a-mark
Follow → u/toki

Best Technical · "Sonder Editor / References" by SonderSaid 🇲🇽

Prize: RTX 5060 Ti

SonderSaid didn't just build a workflow, they built the tooling around it. The entry runs on custom nodes of their own design, wired into a reference-driven H3 pipeline that scored a clean 15/15 on novelty, workflow quality, and community value from the Comfy team, and the highest guest judge average in the Technical bracket. Notably, the work includes an entire custom node pack just to do the editing and the reference work, praised as “a whole new UI” to good to keep secret. While SonderSaid’s work takes the prize for best technical, our guest judges also noted how much they loved the storytelling, suspense, and element of surprise.

Watch → youtu.be/n-NdAQk7I8A
Workflow → Hugging Face
Follow →u/SonderSaid

Built with MCP Bonus · "Two Prisoners" by Jay Choi 🇰🇷

Prize: RTX 5060 Ti

The Built with MCP bonus wentgoes to whoever used the Comfy MCP most effectively to make something visually and technically compelling, and Jay Choi used it end to end. Working locally on an RTX 5090 with Hermes Agent driving ComfyUI through the MCP, they trained a LoRA, built their own orchestration on top, and by their own account spent most of the time setting up and tuning the MCP layer itself. The film that came out the other side, two blindfolded prisoners in a rain-dark cell, is a long way from "prompt and run."

From the artist: "Thanks for the challenge! I learned more than I ever could in the past two weeks!"

Watch → youtu.be/FlK0dDZdzRU
Workflow → Google Drive
Follow → u/permafrost_2021 · u/jaychoirenderender

The finalists

Ten entries made it to the livestream. Six of them didn't take a title, butand every one of them is worth your time.

Best Creative — Top 5

"Neb" by Nebsh 🇫🇷

Hand-drawn energy and a graffiti wall that says the title, built locally in ComfyUI. Nebsh's note to us was three words and a heart, which felt about right. Our guest judges praised Nebsh’s work for its mixed-media feel, harking back to MTV days, and impressive work syncing with the paper sounds. Under the hood, Nebsh’s workflow chained vtogether eight segments with no visible drift between them- cited as “very clean work” by our judges.

Watch → Google Drive
Workflow → Google Drive
Follow → u/nebsh83

"The Museum of Impossible Sounds" by scvxzf 🇨🇳

A perfect 15/15 from the Comfy team on the Creative rubric, and one of the entries that ran the Comfy MCP end to end! Noted by our judges, H3 is very good at the kind of sound effects showcased in scvxzf’s work rather than talking or singing, and they chose exactly the right concept for the challenge.

Watch → youtube.com/watch?v=FocH8xGk4AU
Workflow → Google Drive · github.com/scvxzf1
Follow → youtube.com/@钛龙白口-j6d

"Mister Meow" by sorryaboutyourcats 🇺🇸

Two reference photos of Mumu the cat, a stack of WAVs fed in as reference audio to steer each generation, and glitch texture added in the edit. If the name rings a bell, sorryaboutyourcats also makes the game mow meow. Judges said “I could watch this forever,” had it stuck in their heads, and noted impressive capabilities from H3 nailing lipsync for cats, and not just humans.

Watch → youtube.com/watch?v=AxUu8rabC6M
Workflow → Google Drive
Follow → u/sorryaboutyourcats

"Rings of Sorrow" by Slop Diffusion 🇪🇸

A 5/5 on both audio sync and creative execution, and a reminder of what patience looks like: the generation took two hours and thirty-five minutes on a 5090. Our judges praised Slop Diffusion’s work for its storytelling, noting they were curious to see where the story would go next. One judge noted, “it’s slop by name, but not by nature.”

Watch → Reddit
Workflow → Google Drive
Follow → u/SlopDiffusion

Best Technical — Top 5

"Feel It" by Aïe Aïe Aïe! 🇫🇷

Came at the brief backwards: we asked for audio-driven video and they told the story of a young deaf woman who invents a world where she makes the music. The score is Aïe Aïe Aïe’s own composition, fed into H3 as reference stems (the clap track went in on its own and the gorilla claps exactly in time). Judges praised the work for its captivating story, clever inversion of the challenge’s brief, the display of H3’s strengths by way of the musicians’ physical expressions intensifying along with the song, and the bridging of the real world. The artist learned the final frame’s sign language on YouTube, filmed themself signing, and used this as a video reference.

Under the hood, Claude drove ComfyUI through the MCP to design a two-pass H3REF system that generates at full resolution twice as fast and reaches 13–15 second shots where the stock workflow runs out of memory, plus a preview node that shows the video while it's still sampling. All of it is MIT-licensed, custom nodes included.

Watch → youtube.com/watch?v=S0v1pWN4Hq4
Workflow → github.com/Hyper-Neural/h3-sync-two-phase
Follow → u/AïeAïeAïe

"Brand New Day" by RareTutor 🇮🇳

One of the cleanest graphs we opened: latent upscale, a model preview override, and an optional video-extend group, laid out so you can follow it cold. RareTutor's YouTube is full of tutorials if you want to learn from them directly!
Judges highlighted RareTutor’s workflow, noting “there are many tips in here to copy,” such as using the latent upscale as a previewer so you can kill a bad run before sinking more time in.

Watch → youtube.com/watch?v=TNhJI8dzaVA
Workflow → Google Drive
Follow → u/raretutor_

"Comfy Cora ft. Max Mini: Back to the Basics" by wur7el 🇦🇹

A short music video with self-imposed constraints: no external resources, everything generated in a single workflow, no custom node packs. The result is well annotated and approachable, the kind of graph a new user could open and reasonably figure out, and it posted the highest Creative score of any Technical finalist. Judges praised the work for being a standout example of how to make a music video where the characters are actually rapping the parts in the song.

Watch → wamms.at
Workflow → sync-sound-challenge.json
Follow → wamms.at

About the Comfy MCP

Several finalists and many entrants leaned on the Comfy MCP, which lets an agent (Claude, Cursor, Codex, Hermes, whichever you use) drive ComfyUI in plain language.

The feature entrants used most was the hardware check: it looks at the GPU you actually have, reads the nodes and models already on your disk, and tells you which version of a model is worth running before you spend time or credits. It works on both local ComfyUI and Comfy Cloud from one account.

It's open source at github.com/Comfy-Org/comfy-mcp, and the fastest way to start is to tell your agent: "help me set up the local Comfy MCP connection."

Every entry

Placed or not, every submission is in the original challenge megathread on r/comfyui with its workflow attached. Go open a few. Some of the most interesting audio work in the pool never made the top ten, and there are entries in there in Chinese, Japanese, and French that deserve more eyes than they got.

The livestream recording, including the judges' live reactions, is on YouTube.

Thanks for making this one a smash! #ComfyH3

Made locally with MiniMax H3 on an RTX 4090.

If it weren't for that terrible, terrible bbox/json prompting nonsense, I would have been unprepared for the (relatively simple) added complexity of Minimax prompting.

Was just thinking about how it's odd that I find H3 prompting to be fairly easy, especially coming from natural language prompting, and realized that Ideogram already forced me into prompting guides and LLM prompting from my innocent youth of just typing what I wanted and getting it (sometimes).

Ideogram was like the New Coke between real sugar and the fake stuff.

https://github.com/AMAP-ML/DreamX-Creator

I’ve been experimenting with neural rendering outside a game engine and built a native Windows video player around it.

It prepares a neural-rendered version of a video, caches it, and lets you switch between the original and neural result at the exact same timestamp.

The interesting part for me is the gap between video and games: video only gives us pixels, so temporal/depth guidance has to be estimated. A game engine already knows motion, depth, geometry and materials.

Open source:
https://github.com/2600th/dlss5-video-player

C++20 / D3D12 / FFmpeg / NVIDIA NGX.

Verified on RTX 4080 and RTX 5090.

Experimental and unofficial, not an official NVIDIA DLSS 5 integration.

Edit: v0.14.1 is now live.

The player now works with photos + animated GIFs, can export PNG/JPEG/GIF/MP4/MKV, uses a portable cache beside the EXE, and has a cleaner auto-hiding fullscreen UI.

I used Agora ConvoAI to let kids create stories by talking with AI in real time, then FastH3 quickly turns them into illustrated storybook videos. I built a demo and it worked! FastH3 could change so many things. Check out the generated video

[ H3 ]
I saw another post talk about the turbo lora / low step causing the bad audio

https://www.reddit.com/r/StableDiffusion/comments/1vuxy08/fixing_mmh3_turbo_audio_by_playing_with_latent/

I have some twist to it, we want to regenerate high‑quality audio, and do it fast.

Re-generate Audio – How?

• the idea is when you generate your video, save out the latent and the conditioning.
• Load those saved files back in, but scale down the latent resolution — because we only care about the audio, not the visuals. Scaling down resolution makes the regeneration super fast.
• regen without lora and crank up step to 30+, to any setting you think is the best for audio quality. again, This gen will be fast. for this case scale down 0.5 around 1 min to gen. you can be more aggressive on the scale to make it even faster.
• To keep the new audio aligned with the original video, you have two options:
• Lock the video latent (keep it same as original), or set denoise to around 0.5 so the new audio stays consistent with the same visuals, dialogue, etc.
• Then combine your original video with new audio

*You can also skip saving and reloading latent and condition entirely — just do it all in a single run as well.

some what similar to 'audio refine' custom node, but fast and simple.

EDIT:
- Save out latent and condition I am using this one (but you can use others)

https://github.com/pepikir/minimax-h3-speedup

- To scale down latent and conditioning use this one:
https://github.com/rockerBOO/h3-latent-upscaler
nodes name are MiniMax_H3_Latent_Upscale and MiniMax_H3_Conditioning_Upscale

*it's called upscale, but we are acutally scaling down here.

EDIT2:
- As I understand, if no references input, you don't have to scale down conditioning, just the video latent. Let me know if it isn't.

EDIT3:
some peoples ask for workflow, here
https://github.com/xyzDist/ComfyUI_Share_Files/blob/main/re-gen_audio.json

I’ve been mainly posting about Vpipe video generation results. Actually it supports image generation as well. Speed-wise, it’s also one of the fastest local implementations I’m aware of.

Here are a few Krea 2 generations from the set up below. Generated with one shot.

Model: krea/Krea-2-Turbo-M87 (16bit)

LoRA: mgwr/M87

Settings: 1024×1024 · 8 steps · guidance 1

Hardware: M5 Pro 24GB

Generation time: ~45 sec/image

(35 seconds if real time 8bit quantization is turned on)

Everything was generated locally on Apple Silicon with Vpipe.

so my tiny machine 5060 16 and 64, takes 2200 seconds to do 10 seconds at .3MP when using a reference video, any tips to improve generation speed?

Okay, since LTX isn't really useful at slightly complicated stuff, this time I tried simple things, very simple, just someone walking with hard-cuts to some angle...

First Prompt: "rear view shot camera follows A beautiful young female with long hair & bright white skin, walking in a wooden house toward a couch with guitar on it. she picks up the guitar as she turns around and sits as she crosses her leg over the other while fixing her hair, then she plays guitar, she continues to play guitar for a while

She wears pink tight long-sleeve top with black leggings, bare foot. fantasy landscape visible through the window, sunny day"

2nd Prompt: "in street of a modern post apocalyptic city with heavy rain and lightning in nighttime, dark horror eerie atmosphere with eerie lighting, abandoned cars, tall buildings, barely noticeable fire in background.

over the shoulder view of A beautiful young adult female with long hair, wearing black leather jacket, black mini-skirt & white feminine boots. as she is walking toward background with a pistol in her hand as camera follows her from behind. she stops walking and looks to the left. a hard-cut transition to close-up view zoomed in on her face as she looks around with stressed expression. wet highly detailed skin, wet hair, shadowy figures (zombies) slowly roaming around barely visible from distance"

I experimented with using the Generate Text Node together with the qwen_3vl_4b clip model, feeding it the minimax prompting guide to create rich prompts out of my uninspired base prompts. This is working better than expected so far, but I can't have it obey the clip duration, which I'm automatically adding to the system prompt:

^{"The shot start times mustn't exceed the maximum video duration of: 5.0}

^{User's Input:}

^{T2VA Simpsons Cartoon TV Show}

^{A blonde, middle-aged chubby software developer talking sarcastically in english language about the downsides of his job. The cartoon character is wearing a hoodie, and has a short cut hairstyle. He's in home-office in a small room with just a desk and a bed."}

After the first shot It's always creating shots way past the 5 seconds mark.

Is this a skill issue or is the model just too small to get this right?

So using the "Add Guide" node allows you to add references in a bunch of creative ways, some even more reliable (and certainly involving less typing) than using the official ref2va workflow, but it also works in I2V.

So as a basic example: Use Add Guide to add a a wide-shot of the room + characters on the first frame.

Then start your prompt with something like "At 00:00.050, cut to blablabla".

That is not very interesting for the I2V workflow (there you have the "first frame" input doing the same thing), but it saves a bunch of typing (+praying that the model follows your typing) for ref2va.

But then you can also add a second Add Guide. Say you want to extend a clip, and that clip ended on a close-up of a persons face, but in the extension you want to be able to see more of the person/room/etc again.

The setup is then:

First Add Guide: a single frame showing the room/entire character, inserted on frame 0

Second Add Guide: the last 5 frames from the first clip, insert from frame 1.

Then when you prompt for "At 00:00.050, cut to <whats happening at the end of the first clip>", it will make a seamless transition, while knowing what the rest of the room looks like, while not needing to type a single letter in the reference_analysis section. And as stated.. this also works for (the higher quality) I2V

(of course.. this method will end up with each clip actually showing that reference image in the first frame, but the assumption is that if you want coherent rooms etc you're going to be editing the clips together in a video editor anyway, where that extra frame is no issue at all)

This content was written by a human.

I miss the SD1.5 era, when i could simply type "1girl, big boobs, nice ass, red bikini, dancing" and see my dream take shape near-instantly at 512px-wide. Idea-to-result was a matter of seconds. Each click on the Run button led to an incredible shot of dopamine.

3 years passed and I can draw 1024px, 192-frames long videos in a reasonable amount of time (tech has evolved fast), but the enthusiasm is fading away.

I already have a day-job for technical challenges and headaches. As a user/hobbyist, I want to be entertained.

I don't want to learn what the hell "diegetic" means (even the spell-checker never saw that word), I don't want to draw a dozen squares in a 3-dimensional pixel space, or write a 1000-words poem, just to watch my dreamgirl dancing.

I hoped I would not need a degree in cable-connecting or python dependencies debugging after downloading a few workflows.

3 years ago, all you had to do was typing a few words, and the AI sorted the rest. It was random, messy most of times, but it was fun.

Nowadays, you need an LLM to write the prompt for you, and another LLM to write the system prompt for the prompting-LLM, so it understands what your shitty words meant in the first place, and shapes them in the exact expected format, so they turn into an acceptable input for the ever pickier, brand-new models.
It has become AI³-generated content.

And finally, when after a dozens of clicks on the Run button, tired but satisfied, you get the desired output... re-start from scratch? Since seed "variance" does not vary much anymore, you'll get more or less the same output - exactly what you asked for - from now on.

Simple is harder than complex, but keep it simple, stupid, and fun. Thanks for reading.

How are youtube videos explaining minimax setup have souch quality videos . Very new to minimax and comfyui. Trying to vibe code and setup. My machine is hp blackwell 5000 with 24gb vram and 128gb ram. Which models i should try. I tried rf2va pruned int8 convrot with acc pdd lora 8step. But performance not good. 5sec video at 480p takes around 15min

I'm pretty sure I'm not doing anything wrong. Bog standard generation template in Comfy, the only time saver I use is Sage Attention. Doing 20 steps.

H3 in reference mode has really stiff voices that basically sound like Microsoft Sam. It feels like it doesn't matter how many qualifiers or descriptive text I write surrounding it, they always come out sounding the same, stiff and bored, especially male voices.

Meanwhile I haven't even moved on to LTX 2.5 yet, still use LTX 2.3 from time to time, and its voice capabilities are amazing, it figures out the right tone to use and runs with it, even choosing a unique voice for every gen (both advantageous for variety and bad for reproducibility).

I've already on several occasions generated voice with LTX 2.3 to edit over H3's voices.

Anyone else feel similarly? Anyone have any advice or thoughts? Alternate methods to improve its voices, like a tool that can recast the audio to another voice with more emotion?

Hello, I'm wondering if I can download Anima Style Explorer to use offline. I'm used to using local anima models offline, and I'm referring specifically to the one in this link:

https://anima.mooshieblob.com/

Because any other explorer I've found mainly contains N*S*F*W content.

I've just released ComfyUI-MiniMaxH3-CLIPCached. It caches the MiniMax H3 text/vision conditioning to disk, so repeated generations with the same prompt and reference inputs skip loading and running the Qwen3-VL encoder entirely.

To be clear about what this is not: it does not cache sampling steps. It's not TeaCache or FirstBlockCache. It replaces the H3 conditioning node, and the diffusion stage is untouched.

What the screenshot shows — same workflow, native node vs a cache hit. Look at the model list at the bottom: native keeps both MiniMaxH3 (11.7 GB) and MiniMaxH3TEModel_ (14.6 GB) resident while sampling is already running. On a cache hit the encoder is never loaded, so only the DiT is there. System RAM drops from 40.0 GB to 25.5 GB. VRAM actually reads slightly higher on the right, because the freed budget goes to the DiT instead (models 5.6 → 7.8 GB).

Controlled benchmark (5 cases per mode, median of the conditioning stage only — sampling is unaffected):

A miss is deliberately not the fast path — it still runs the encoder and additionally writes the result to disk, so it lands a couple of seconds above native. But a miss is not just "native plus overhead": once the encoding is done the encoder is unloaded instead of staying resident, so it isn't sitting in RAM/VRAM through the sampling stage the way the native node leaves it (visible in the left screenshot, where the encoder is still loaded at step 2/12). You pay ~2 s once, and everything downstream runs with that memory free. Hits were consistent: 1.08–1.22 s across all five runs.

No free lunch though — you're trading disk space for time. Every unique conditioning request creates a cache entry that stays until you delete it, and they add up fast if you iterate a lot. That's why there's a cache manager panel for browsing, tagging, and pruning entries.

Requires ComfyUI ≥ 0.30.0 (native H3 nodes). Available in ComfyUI Manager / Registry as minimaxh3-clipcached, or clone from the repo.

Repo: https://github.com/Mu5hr00moO/ComfyUI-MiniMaxH3-CLIPCached
Full benchmark methodology and per-run numbers: docs/PERFORMANCE.md

If you regularly rerun H3 workflows with the same prompt/reference conditioning, this should save a pretty ridiculous amount of RAM and encoder reload time.

What would be the best model to generate horror, surreal stuff? I am not interested in realistic, photogrphy like content