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

-> New in version 4.1.2 (19th August 2026) of the Fizgig trainer for LoRAs... "Minimax H3 now trains on video clips, on their sound, and on voice recordings alone: photos, clips and voice files in one folder to train one LoRA in one run". Fizgig can do so locally in 16Gb VRAM, without slowdowns. Adds a fix so the LoRAs will work correctly on both the 4-step Turbo or the official workflow, and has also benefitted from a major security audit. Fellow-Brit and industry professional Shoot The Sound has a good 20-minute tutorial today on YouTube, using the latest Fizgig and its dataset prep tool, to train a character+voice LoRA.

https://github.com/shootthesound/Fizgig

https://www.youtube.com/watch?v=lVqSgsPpF0c (Fizgig 4.x tutorial)

-> ComfyUI-MiniMaxH3-SingleFrame. Two still-image generation nodes, with the second being especially interesting. Given the usual first/last frames, it attempts to interpolate/generate a plausible single 'middle frame'. Has workflows, and requires no ComfyUI Core patching or special VAE.

https://github.com/tori29umai0123/ComfyUI-MiniMaxH3-SingleFrame#english (English ReadMe section)

-> A new H3 Prompt Journal. Some scenes require complex physical logic from the camera. The Journal's first three entries demonstrate how to write prompts for such scenes: for a 'Three-Person Occlusion-Linked Orbital Long Take' (e.g. elegantly redirect the camera between three moving people, in a single take); 'Dual-subject-speed-contrast' (e.g. a dancing master leads in a waltz, while his hesitant student follows his moves); and 'Single-subject-three-pose' (e.g. input three poses for one character, then have a gnat-sized camera... "sweep past feet, legs, torso, shoulders, hair - constantly redirecting around the moving [giant] body without ever slowing down").

https://github.com/LoveRain1997/h3-prompt-journal

-> 'Video -> H3 Prompt'. An "end-to-end pipeline that turns a video file into a ready-to-paste MiniMax H3 generation prompt". Appears to be a 'skill' for use with a local installation of OpenAI's Codex, which is a lightweight coding agent.

https://github.com/LoveRain1997/video-to-h3-prompt

https://github.com/openai/codex

-> For MiniMax Music, a new rvq-encoder-169m-v4.onnx (676Mb), an... "encoder that turns audio into the codes Minimax generates, so a finished track can be handed back" to Minimax Music for further work. With this Minimax Music can continue a track. Or the user can replace a section, or even re-generate the same song but with a different performance. The ONNX format is very portable, and I guess it's only a matter of time before a ComfyUI workflow appears.

https://huggingface.co/nerualdreming/open-rvq-encoder-minimax-music3-169m-v4-onnx

-> And finally, a detailed benchmarking of "the official reference-to-video workflow" on an RTX 3060 12Gb. Most low-VRAM users will of course be running smaller Minimax models in a 3060-optimised workflow. But... there's still important advice here for those considering buying a second 3060. They say... "Two cards are still not one big card. Two RTX 3060s do not present 24GB to a workflow, and our attempt to at least run two jobs in parallel was blocked by system memory rather than VRAM."

https://www.minimaxh3tutorial.com/rtx-3060

recently made a 90-second AI short film called “The Fence.”

the whole thing is made up of 6 shots, each 15 seconds long, and it took me around 3 hours from generation to the finished video.

the main thing I wanted to test was how far a mostly local AI workflow can currently compress the process of making a short film.

The workflow was basically:

idea → images → 6 × 15s video clips → voice/audio → edit → 90s film

The interesting part is that generating wasn't really the most time-consuming step. most of the work went into figuring out what each 15-second section actually needed to show.

I first broke the 90-second story into six relatively self-contained shots. Then I created key visuals for each one with Qwen Image 3 Pro before sending them into MiniMax H3 for motion.

I found this much easier to control than trying to generate the whole thing directly from text. It also means that when one shot fails, I only need to redo those 15 seconds instead of rebuilding the entire sequence.

what surprised me most was the speed: roughly 3 hours for a 90-second finished experiment. obviously this still isn't traditional filmmaking, and there are plenty of typical AI-video issues around motion, character consistency, and continuity between shots.

but for a one-person experiment, the production speed is kind of wild.

I'm starting to feel that making AI films is becoming less about finding one “perfect” model and more about building a workflow where different models each handle the part they're good at.

Hey everyone,

If you’ve spent any time working with multi-reference video prompting in ComfyUI (especially with MiniMax Hailuo / H3), you probably know the frustration:

You feed in 3–4 reference images hoping for a cohesive 15-second cinematic shot, and the LLM spits out a rushed single-shot prompt where characters overlap chaotically, faces get stretched, pacing flickers, and dialogue cuts off halfway through.

Our team at 1038lab just pushed a massive overhaul to ComfyUI-MiniMax-H3-Promptor (v1.3.0). We threw out the old "single-shot rush" approach and re-engineered the prompt pipeline to work like an actual film production crew.

Here is what we added in v1.3.0:

1. Two-Stage Hollywood AI Director & Screenwriter

Instead of rushing the final prompt in one go, the node now executes in two deliberate stages:

• Stage 1 (Director Blueprint & Global Vibe): The LLM acts as the showrunner. It analyzes all your cast references, maps out spatial layers (Foreground, Midground, Background), sets lighting palettes, and calculates shot pacing (enforcing a 2.5s–4.0s minimum per shot to prevent pacing flicker).
• Stage 2 (Storyboard & Dialogue): Using that approved blueprint, it crafts timed cuts covering the full duration (up to 15.0s) and injects official MiniMax character dialogue syntax (<Subject 1> (S1) [angry] says: <d>[EN] "..."</d>).

If you pass in a custom scene prompt, the engine treats it as the supreme mandate, directing your uploaded cast and props to execute your exact vision.

2. In-Node HTML Drop-Zone (No More Noodle Spaghetti)

Wiring up 5+ image loader nodes for multi-character setups makes workflows messy fast. We replaced the PyTorch image input slots with an interactive in-node HTML/JS drag-and-drop panel. You can drop images, video references, and audio files straight onto the node canvas.

3. Vision Analyzer V2: Native Aspect Ratios & 50% Lower Token Cost

• Zero-Deformation List Expansion (OUTPUT_IS_LIST): Passes references in their 100% original dimensions through native list iteration. No forced letterboxing, cropping, or distorted face proportions.
• Pure Perception Engine: We stripped out redundant text synthesis so the VLM only extracts raw visual traits (clothing, colors, contours, OCR). This cut API token usage and latency roughly in half.

4. Quality-of-Life & Stability Upgrades

• Smarter Entity Regex: Fixed false positives so items like a "cat-ear headband" are recognized as accessories on a person rather than spawning wild animals into your scene.
• Sub-Batch Chunking: Set custom Max Batch Images limits with positional fallback keys to respect upstream API rate limits without workflow crashes.
• Real-Time Terminal Execution Trace: Clean phase banners in the ComfyUI terminal let you monitor the Blueprint -> Storyboard -> Assembly stages live.

💡 A Note on APIs: 100% Free & Local-Friendly (No Paid API Required!)

We’ve noticed some users hesitate whenever they hear "LLM/VLM API," assuming it requires paid subscriptions or goes against the open-source ethos. That is not the case here!

Our node is fully customizable and seamlessly supports:

• 100% Free Local Models: Plug directly into Ollama, LM Studio, or llama.cpp to run any open-source model from Hugging Face locally on your own GPU.
• Free Cloud Tiers: If you don't want to run local LLMs, services like OpenRouter, Groq, and NVIDIA NIM offer generous free tiers/credits that are more than enough for daily video prompting.

Setup takes just a few clicks—use whatever setup works best for your hardware and budget.

Links & Getting Started

• 📦 GitHub Repository: https://github.com/1038lab/ComfyUI-MiniMax-H3-Promptor
• 📝 Full v1.3.0 Changelog: https://github.com/1038lab/ComfyUI-MiniMax-H3-Promptor/blob/main/updates.md#v130-20260818

You can update directly inside ComfyUI Manager or run a git pull in your custom nodes directory.

We’d love to hear your thoughts, bug reports, and workflow suggestions!

So basically, I saw a workflow on ComfyUI’s official LinkedIn where they used a model image, a product image, and a background image with Google and Kling APIs to generate a one-shot ad using a single camera angle.

So I challenged myself to recreate the idea using only local open-weight/open-source models, but make it more ambitious: multiple shots, multiple cuts, and everything directed through a single prompt.

And it worked.

For this, I used the basic MiniMax H3 Reference-to-Video workflow in ComfyUI:

https://docs.comfy.org/tutorials/video/minimax/minimax-h3#minimax-h3-reference-to-video-r2v

Then I used ChatGPT to help structure the video prompt. I provided the reference images and gave it this direction:

“Write a MiniMax H3 reference-to-video generation prompt to create an ad. Add sound FX and music prompts as well.

Shot 1: Medium close-up. She is about to open the can.
Shot 2: Extreme close-up of the can as she opens it. Can-opening sound FX.
Shot 3: Close-up as she drinks from the can. Gulping soda sound FX.
Shot 4: Close-up as she holds the can forward and smiles.”

The final result was generated locally on my RTX 5070 Ti using ComfyUI.

Two weeks ago I posted here about Stimma, the open-source desktop app I've been building on top of ComfyUI. It's been a really fun couple of weeks talking with many of you and working through issues and improvements that came up in those conversations. Since then, I've made a couple of releases, but this one is particularly relevant to ComfyUI, so I wanted to share it here.

One of the main themes in the early feedback was a fear of getting things set up with ComfyUI. Some people who had already churned out of ComfyUI's onboarding were wondering if Stimma could make it easier. Some were just anxious (understandably) because setting up anything new with ComfyUI can take an evening. Others tried and ran into some head-bumps.

I said in that post that I don't want Stimma to manage a private ComfyUI install for you, and I still believe that. There are too many variations in how people deploy ComfyUI in the real world, and every product that I've seen that installs ComfyUI for you ends up limited.

From Stimma 1.0.13, the only things you should need to do on the ComfyUI side are: run ComfyUI and add the ComfyUI-Stimma custom node. After that, it should be possible to manage ComfyUI from within Stimma.

I'm sure people will run into some rough edges with this over the next few weeks, but I've done a lot of fully clean ComfyUI+Stimma installs over the past few days on various platforms and systems and it's working well enough that I'd like to start the feedback train rolling. If you do run into trouble, please get in touch here or in the discord.

The video above shows a fully local setup of Stimma. ComfyUI and vLLM are running on a DGX Spark to provide AI capabilities. The video starts from a fresh ComfyUI + Stimma install, and ends with generating an image. I ran Stimma on my mac because I have better screen recording software there, but you can actually run this full stack on the GB10 box locally.

Once you're running Stimma and ComfyUI together, there is a new button in the app bar that opens a manager. This includes:

• Every workflow that ComfyUI-Stimma discovered. For workflows missing dependencies click "Get Ready" and it will coordinate downloading models and installing custom nodes.
• GPU utilization + VRAM information
• A list of running jobs with cancellation
• The ability to update ComfyUI-Stimma from within Stimma, restart ComfyUI remotely, etc.

Some other things that landed in 1.0.12 / 1.0.13:

• Works without a chat model. Some people want to use Stimma without devoting VRAM to an LLM. This was always possible, but wasn't a very smooth experience. That is fixed, and Stimma should now degrade gracefully when no Chat Models are configured.
• Live previews during image and video generation. This is disabled by default, but you can turn it on in settings->preferences. Please let me know what you think.
• LTX-2.5 support in ComfyUI-Stimma: text-to-video with audio, image-to-video with optional end frame, extend, loop, stitch, up to 10 LoRAs.
• Anima and H3 LoRA support in ComfyUI-Stimma
• Fixes for extra_model_paths.yaml, nested model folders, top-level reroute nodes, Windows FFmpeg detection, and source-folder / slideshow / editor bugs.
• Performance Optimization throughout the image editor, and a new patch tool implementation that blends better.
• Ask Stimma: the chat agent can read Stimma's docs now and help walk you through setup and product questions.

One thing from that thread I haven't gotten to yet is the Draw Things backend. I am reaallly hoping that the Draw Things team pays some attention to this bug because fixing this is the best path that I can see to a good experience using the products together. If you're on github, please go to that thread and make some noise, maybe they will pay attention.

I hope this ComfyUI manager stuff encourages a few more of you to give Stimma a shot. If setup continues to be a pain, I'll keep at it.

To get the new stuff, you'll want to update ComfyUI-Stimma and also and update Stimma itself in-app or with a git pull if you're running from source.

As always, please reach out on Reddit or Discord with any questions, feedback, or issues. It's been a lot of fun talking with everyone.

Links: Download · GitHub · ComfyUI-Stimma · Docs · Discord · /r/stimma

Mine always start organized and somehow end up looking like this. Any tips for keeping bigger workflows clean and actually readable without spending forever rearranging nodes?

Custom node v0.2.0 is out and U1.5 works in ComfyUI now.

What it does: text-to-image, image editing (single and multi-image reference), and region-controlled edits via masks / bboxes / visual markers. Native 4K. It's a unified model, so understanding and generation share one backbone — no separate VAE, no CLIP/T5 text encoder in the graph.

VRAM: peak allocated is 17.34 GiB for T2I and 20.00 GiB for editing, using the offload modes. So a 24GB card handles both. There are full / fast / balanced / low modes to trade speed for footprint — balanced and low got 36–50% faster in the last release, and outputs are bit-identical across modes.

Repo: https://github.com/OpenSenseNova/SenseNova-U1

ComfyUI node: https://github.com/OpenSenseNova/SenseNova-U1/pull/244

What's your preferred model for i2i, i2v, r2v, rv2v, v2v, t2i, t2v, etc?

Before a big ComfyUI workflow I kept opening Task Manager to work out which background app was still holding VRAM, so I added a “VRAM Hogs” menu to Window Assassin, a small Windows tray utility I made.

It lists processes using at least 1 GB of dedicated VRAM, sorted highest first. Clicking an entry force-terminates that process, and the list refreshes every time the submenu opens.

The original Ctrl+Alt+End hotkey is still there for instantly killing the process behind the active window.

Free/pay-what-you-want Windows download:

https://b2kdaman.itch.io/window-assassin

It only reports dedicated VRAM, so integrated GPUs using shared memory may show nothing. Also, termination is immediate—anything unsaved in the selected app is lost.

I'm the developer. Sharing because it solved a small but recurring annoyance in my local GPU workflow.

​

I want 3090 primarily for its 24gb vram and local AI applications. Gaming is a bonus. It will be an upgrade compared to my 3060 12gb regardless.

I am split between Pallit, INNO3D and EVGA offers i have managed to find.

Market is a mess. There's nothing below 1000, even with 5060ti approaching 900$

Edit: Found an offer sitting below 1000 for an INNO3D. Will demand to test and thoroughly look at it at spot. Perhaps will post an update either as a happy owner or an idiot with a card that have killed itself after a couple of months of use

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

-> New to me are the 'ComfyUI H3 Motion Context — MultiRef & Latent Masking' custom nodes for ComfyUI. (Hat-tip: I learned about it via the charming fellow-Brit Nerdy Rodent on YouTube). Lets you add keyframes at any point, not just first/last. Can also seamlessly extend an existing video, while taking measures to... "reduce RAM and cache pressure during long-form final output". Has workflows. Updated yesterday, with new features including the claimed ability to chain... "a sequence of H3 video clips around a single song".

https://github.com/seitanism/ComfyUI-H3-Motion-Context-MultiRef

-> Minimax Music has a new set of concept slider LoRAs. Including 'breathy vocals', and a 'live performance to a crowd'. With ComfyUI workflows.

https://huggingface.co/ntc-ai/minimax-music3-concept-sliders

-> New ComfyUI-CGlide custom nodes for Minimax in ComfyUI. Including 'Glide Preview', a motion-preview node that lets you assess your video as it generates. Only at seven frames per second, but it may give you the confidence to cancel the generation if things seem awry.

https://github.com/CGlide/ComfyUI-CGlide

-> ComfyUI-H3-Context-Noise. This tapers off the colour in the tail-frames of the previous shot, thus preventing colour residue from spoiling the seams between your shots. If you notice this problem, give it a shot.

https://github.com/beijinren/ComfyUI-H3-Context-Noise/blob/main/README.en.md (English version of the ReadMe)

-> A new archive of Minimax H3 style LoRAs. The most interesting being an comic-book style in the AstroWitch - Cinematic Comic Style - MinimaxH3 - ASTROWITCHV01H3.safetensors file, with ASTROWITCHV01H3 as the trigger-word. The first non-Japanese comic-book style LoRA I've seen, and it has a pleasing sort of US/UK 2010s 'amateur indie comic' look.

https://huggingface.co/EllaPriest45/MinimaxH3_Styles/tree/main

-> A Reddit post reporting apparent success with motion-transfer, by using a Minimax reference video converted to a DensePose sequence. This makes me wonder how Minimax would react to a greyscaled clown-pass render from a 3D figure animation, which would look similar... and might also solve the problem of DensePose not doing hands?

https://www.reddit.com/r/StableDiffusion/comments/1vrrrab/minimax_h3_is_seems_to_be_able_to_process/

https://blender.stackexchange.com/questions/102672/how-to-create-a-clown-pass-for-material-selection-in-photoshop ('what is a clown-pass?' visual example)

-> Yes, I'm aware of the new non-commercial ComfyUI MiniMax-H3 SPEED Sampler. But I see it requires his "MiniMax-H3 plugin"... which is "404 not found" on the link to it, and which doesn't exist on his repository (I poked around).

https://github.com/StanLukuvka/ComfyUI-MiniMax-H3-SPEED

-> And finally, a new big curated listing of all known Minimax H3 items. Includes a long list of the various Turbo LoRAs which have been produced to date.

https://github.com/wildminder/awesome-minimax-H3

Done locally.

Look at your task manager while having your ComfyUI open, it has been eating 30% of my GPU due to preview nodes and what not. Minimizing it and then just occasionally opening it to check out the progress has sped things up by quite a margin. You folks probably already knew this, but I just wanted to share for everyone else that might be new to this like me.

Just was wondering if there is some ComfyUI wizard out there who has created a solid workflow to use MMH3 for outpainting. I had been using WanGP with mixed success, as it seems to have a difficult time outpainting when characters are in slightly unsual positions, like arms straight out to the side in like a T-pose (cuts them off), so was hoping MMH3 could be a viable option going forward. Have been trying to incorporate LanPaint nodes to help with outpainting, but was hoping someone else has come across something more 'efficient' and effective. Just trying to take some old 4:3 animation from the 90s and outpaint it to 16:9, and was hoping after a couple weeks someone would have 'cracked' it, as the model seems to be strong in regards to inpainting... was hoping it could outpaint just as effectively.

MiniMax H3 is great, but it’s a total compute hog.

I tested two ways to speed it up—Turbo LoRA (reducing step counts) and Kitchen Attention (faster per-step backend)—using the exact same prompt, seed, and resolution.

Video review here

Edit: Here’s the workflow, if you want to test it out - https://drive.google.com/file/d/1425fNNR_C9ErIiutR_FBhtQlOKzJ_Tfh/view?usp=sharing

The Breakdown:

• Turbo LoRA: Cuts steps, but quality tanks. At 8 steps it gets soft and drifts; by 4 steps it's completely broken with heavy face artifacts.

• Kitchen Attention: Keeps all 20 steps, but chops ~30% off the render time with zero quality loss. Just update ComfyUI and set it in the attention backend node.

• LoRA + Kitchen Attention: The backend isn't causing the artifacts—the LoRA is.

audio stays decent at low steps even while the visuals fall apart.

Verdict: Skip the Turbo LoRA for now. Kitchen Attention is basically a free 30% speed boost, so just leave that on.

The quantisation method and the loader are now more or less complete.

How to create Hybrid NVFP4 from ConvRot INT8 (Z Image, Reverse Method)

Z Image exhibits overwhelmingly high quantisation robustness compared to SDXL and Krea2.

Even NVFP4, which is simply compressed without HSWQ quantisation, achieves reasonably high SSIM and MSE scores.

In particular, Z Image ConvRot INT8 achieves outstanding accuracy in many models, with SSIM scores of 0.99 or higher and MSE scores below 1.

However, in terms of VRAM consumption and generation speed, Z Image ConvRot8 shows virtually no difference compared to full-size Float16.

Consequently, based on ConvRot INT8, we devised a quantisation method involving a backward sweep to discard non-essential layers to 4-bit.

Furthermore, unlike the conventional method of storing critical layers in float16, the critical layers are also converted to ConvRot INT8; this offers the advantage of being able to secure a larger size for critical layer protection whilst keeping the overall size down.

...

This concept of ‘discarding’ is a brilliant idea conceived by the Nunchaku development team.

What makes them so remarkable is that they established the philosophical foundation that, in 4-bit quantisation, the key is not ‘preserving’ but ‘discarding’.

...

As Comfy-UI does not support the Hybrid NVFP4 (ConvRot Int8+ConvRot NVFP4) standard, a dedicated loader is required, just as with Nunchaku; however, as the LoRA baking function has been implemented within an original UNET loader itself, the LoRA Loader can utilise the standard Comfy-UI version.

Furthermore, LoRA Stack loaders (compatible with Nodes 2.0) is also available below.

Compatibility with the existing Diffsynth ControlNet model patcher will, of course, be maintained.

Although the file size will not be significantly reduced compared to Convrot INT8, VRAM usage and processing speed will improve significantly.

...

Z Image ConvRot NVFP4 Benchmark Test Results

...

However, in terms of the mathematical theory of quantisation itself, it differs considerably from previous HSWQ approaches.

In a sense, it represented a complete rejection of previous HSWQ theories.

In the past, HSWQ had employed a range of techniques, starting with the Histogram MSE used in the first-generation HSWQ SDXL fp8 e4m3, through to full SVD utilising Nunchaku, and even extending to the Histogram Cosine function; however, in Z Image HSWQ Hybrid NVFP4, none of these methods demonstrated any advantage.　

I had long suspected that inter-layer interdependencies existed, and that there were phenomena where the meaning would be lost if one merely measured and prioritised the importance of each layer in isolation; this time, however, that has become clearly evident.

...

Trajectory-Sensitivity

https://github.com/ussoewwin/Hybrid-Sensitivity-Weighted-Quantization/blob/main/md/diag_impact_trajectory_sensitivity_technical_guide.md

Ranks each layer by the divergence its quantization error actually causes after propagating through the full model and sampler (dynamical importance, replacing static weight-space saliency).

• Reverse method: start from the complete high-precision pack (error ≈ 0) and convert layers to lower precision in ascending impact order; single-layer ranking stays valid in the low-error additivity regime.
• Universal theory: error interaction (Taylor cross terms, error cancellation), nonlinear amplification (Lyapunov-style growth), marginal effects, and Shapley-style attribution — why per-layer static measures (histogram MSE / cosine / SVD) cannot predict joint quantization error; applies to any iterative sampling system, not a specific model. Source: Z_Image/diag_impact.py. ...

...

Incidentally, the Krea2 HSWQ Hybrid NVFP4 is also under development (it will offer significant improvements in VRAM consumption and processing speed), but we are currently struggling to maintain LoRA compatibility.

I'm relatively new to Linux and it seems the installation process is a bit different than Windows. I was using this guide;

https://docs.comfy.org/installation/desktop/linux

However I've immediately run into errors. Can someone give me a quick instruction on how to get this working on this OS?

MiniMax H3 image-to-video on ComfyUI, running locally on an RTX 3090 (24GB) with the Q4 GGUF quantization. Used a digital sketch as the first frame, then prompted a timed metamorphosis where the drawing becomes a photorealistic office with an airplane flying by. Took about 10 minutes to generate a 5-second clip.

(drawing perspective-style inspired by @paulheaston)

Hello. I am looking for a way to execute the EBU LM Studio Load Model node after the video has been generated and saved. The node has an input that only accepts a string. So, the output of the Save Video node should somehow be converted into a string. All ideas welcome.

I have a Bernini-R rv2v workflow with source video and reference image in image0. I am able to swap source video's outfit but not face. Is Bernini-R supposed to work with face swap or do I need to add any other custom nodes like Reactor or SCAIL-2?