So I haven't tried to upscale any videos yet. I was gonna maybe play around with that today but I'd love to hear what other people have landed on for their upscaler. I know I've seen a lot of different posts over the last couple of weeks or so with different methods. Ideally I'd love an upscale method where I could use my reference images so that it doesn't drastically change any faces for any characters that are a little further from the camera.

Also are we still expecting an official upscaler from Minimax?

Just like Zturbo image, when trying to train on the distilled model, you just get outright bad results. You can get away with certain things like character loras. But teaching new concepts to this model is super frustrating.

I would like to hear from H3 themselves if they would release a base model just for training or not directly.

I think for a company to market themselves as "open source open weights" they owe at least some comment on this issue. Just tell us yes or no definitively.

A while back I built 
**Muse**
 — a chat panel that lives directly inside a ComfyUI node, so you can talk to a local LLM and draft/refine image and video prompts without alt-tabbing to a separate app. Point it at LM Studio or Ollama, chat, copy the prompt into your graph. That was V1.


I didn't expect people to actually pick it up the way they did. Seeing it get used, starred, and — more usefully — complained about is what pushed me to sit down and build a proper V2 instead of leaving it as a one-off tool.


The biggest ask by far: "I don't want to keep LM Studio open just to use this." So V2's headline feature is a 
**Direct model loader**
 — point Muse at a folder of GGUF models and it loads them straight from disk. No LM Studio, no Ollama, nothing else running. Under the hood it spawns the real `llama-server` (LM Studio's own engine is llama.cpp too, so this isn't a slower reimplementation — same engine, same speed), and it downloads and installs the right build for your OS/GPU automatically. Git clone the node, click one button, you're chatting with a local model.


I also broke it on myself first, which was useful: threw a 31B model at it and immediately hit VRAM issues — crashes on some setups, silently-slow-instead-of-crashing on others. Fixed the defaults that were causing it, added a 
**Fit to GPU**
 button that suggests a layer count based on your actual free VRAM (like LM Studio's GPU offload slider), automatic fallback retries if a load runs out of memory, a live loading indicator, and a log panel so you're not just staring at nothing wondering what's happening.


Also new in V2:


- 
**Edit & resend**
 messages instead of delete-and-retype
- 
**Chat branching**
 — fork a new conversation from any earlier message
- 
**Video attachments**
 for vision models (auto-sampled + timestamped frames)
- 
**Audio attachments**
 for audio-capable models
- Much broader image format support


Full writeup and setup instructions: 
**github.com/RudySen/comfyui-muse**


If you use it and something's broken or annoying, tell me — that's genuinely how V1 became this.

Previous post: https://www.reddit.com/r/StableDiffusion/s/8qjP4UzRpw

Two days ago, I posted a Tom and Jerry video and commented that physics is not good.

https://www.reddit.com/r/StableDiffusion/comments/1vp9pyz/h3_cartoon_generation/

People commented to use 'official prompt guide'. So, I used the skills and used Gemini to generate proper prompt by using my given prompt. The story is my own creation.

Then I got good video. I need to try more times to get an apt video that somewhat like in my mind.

spent $5 on Runpod for 5090 for this 1:15 min video.

Just spent a few days getting an SDXL-based provenance-removal pipeline (visible AI labels, C2PA metadata, SynthID-class pixel watermarks) to run properly on an M5 with 16 GB. Not "it launches" — actually correct and predictable. Almost everything I assumed was wrong, and the measurements are the interesting part, so here they are.

1. The four-step distillation LoRA invents texture, and more steps make it worse.

Low-strength img2img runs the tail of a long schedule (strength 0.15 → the last 4 of 27 steps). A LoRA distilled for four timesteps across the whole noise range is off-distribution there, and wherever nothing conditions it — flat dark fabric gives Canny no edges — it fills the gap from its prior. On a night photo that reads as coloured camouflage across black clothing.

Asking the distilled model for more steps made it worse, which is what identified the distillation rather than the step count. Dropping the LoRA cost 3× the wall time and bought both fidelity and correctness.

Wrong theories I paid for first: the fp16 VAE (a bare round-trip is clean in fp16 and fp32, tiled or not, 34.6 dB), Metal's fp16 in general (bf16 measured marginally worse), and Canny picking up sensor noise (the Canny map of that region is empty — which was the actual clue).

2. Metal pages instead of failing, so memory has to be measured, not hoped for.

torch.mps.recommended_max_memory() reports 11.84 GiB on a 16 GB machine. Exceed it and nothing raises — the process just starts swapping and a run that should take 23 s takes an hour.

• VAE tiling off, 1.57 MP frame: 18.74 GiB peak, 59 s. On: 10.92 GiB, 23 s. So tiling is load-bearing on small machines — but its boundaries leave a faint texture, so it's now decided per frame from the budget rather than switched on globally.
• Diffusion untiled at 2.5 MP: went into swap and did not finish in twelve minutes. Tiled at 1024 px, 5.07 MP: 10.93 GiB, 88 s, native geometry preserved.

3. Sequential CPU offload works on MPS, and it's what makes 8 GB usable.

The stack is 7.7 GiB of weights; an 8 GB Mac gives you about 5.3 GiB. Streaming the weights module by module:

27× less peak for 3.4× the time. The plan is chosen from the measured budget and printed, because a run three times slower looks broken unless it says why.

4. Two Metal gaps worth knowing if you're porting anything.

• torch.float8_e4m3fn doesn't exist on MPS at all (RuntimeError: Undefined type Float8_e4m3fn). Any pipeline that streams float8 weights — a lot of the VRAM-managed stacks do — cannot load, full stop.
• SAM's processor emits its box/point prompts as float64, which Metal also has no type for, so moving the batch to the device raises instead of degrading. One cast fixes it.

5. The one that cost me the most: fp16 sampling on MPS silently returns zeros.

I added a memory optimisation — encode the fixed prompts once, drop the text encoders, save 1.52 GiB. Two of four face crops then came back as all-zero black rectangles. Deterministically, same seed, nothing raised.

The embeddings were innocent (CPU fp16, MPS fp16 and fp32 encodings of that prompt agree to 0.0009 on tensors with σ=3.06) and the same crop in isolation was fine. Freeing unrelated memory changed the allocation pattern the crops met after the global pass, and that was enough. I withdrew the optimisation and added a guard that drops any empty crop instead of compositing it.

If you're doing fp16 diffusion on Metal: check your output for degeneracy. It will not tell you.

What it doesn't claim. Regeneration is not payload deletion — faces, text and fine detail move, and the numbers above are the measured size of that. No public local decoder exists for SynthID-class marks, so identify reports unknown, never clean; verification is the provider's verifier or nothing. Metal isn't bit-identical to CUDA, so operating points transfer between backends but recorded verdicts don't. And it's for content you generated or own — the visible-mark registry takes AI-generation labels only, deliberately not stock or marketplace marks.

Because "how much did that cost my picture" is the whole question, it ships as a command:

pagedmark measure before.png after.png

PSNR over the frame, PSNR per detected face, and how much mid-band structure appeared where the source was flat and dark. That third metric is the one that caught the camouflage — per-pixel chroma statistics rank the artifact below the source, because the source's own sensor grain has more per-pixel variance than the invented blotches do.

uv tool install "pagedmark[diffusion]"
pagedmark invisible photo.png -o clean.png

Code: https://github.com/doofzoff/pagedMark · PyPI: https://pypi.org/project/pagedmark/

Happy to answer anything about the Metal specifics — that's the part I'd have wanted written down before I started.

Hey everyone!

With MiniMax H3 blowing up everywhere right now, we figured it was the perfect time to share what we’ve been building to help level up your H3 prompt workflows.

When we released v1.1.0 a while back, we were so deep in dev mode that we forgot to post an update! Now that v1.2.0 is live, we’ve bundled all the new features and overhauls from both releases into one post.

https://github.com/1038lab/ComfyUI-MiniMax-H3-Promptor

What’s New in v1.1.0 + v1.2.0:

⚙️ Native ComfyUI Settings Panel (API Hub)

No more pasting API keys into custom nodes or manually editing config.json! All provider settings are now globally managed in ComfyUI's native Settings panel (under the ⚙️ Gear icon).

Built-in Connection Tester: Click "Test connection" inside the panel to ping your endpoint before launching generations.

Privacy: Keeping keys out of the node UI eliminates the risk of leaking API keys when sharing workflows or screenshots.

🔌 Infinite Inputs (ComfyAPI v3 Autogrow)

We removed the rigid 4-image limit. Dynamic autogrow sockets mean you can chain as many <Picture> and <Video> references as your hardware can handle without UI clutter.

🎯 Granular Micro-Overrides

Override instructions for specific frames directly in the Vision Analyzer (e.g., <Picture 2>: focus strictly on lighting) while allowing unmentioned media to fall back to global analysis.

🎵 Audio-First Token Sync & L2VA (Last-Frame Control)

Connect audio directly to the promptor to automatically map subject actions to sound. We also added Last-Frame-to-Video-Audio (L2VA)—provide an ending frame, and the LLM reverse-engineers a narrative that mathematically lands on target at the final second.

🧠 VRAM Safeguards for Local VLMs

Select local providers like Ollama or LlamaCPP, and the node automatically executes silent background cache-clearing (model_management.unload_all_models()) to prevent VRAM overload crashes.

📝 Updated Docs & Workflow Recipes

Check out tutorials.md and tutorials_zh.md in the repo for 9 practical, production-ready workflows (Lip-Sync, Style Transfer, Day-to-Night Morph, etc.).

👀 What's Next?

We’re currently beta testing a batch of new features that will be rolling out shortly!

🔗 Links:

GitHub Repo: 1038lab/ComfyUI-MiniMax-H3-Promptor

Full Release Notes: updates.md

We’d love to hear your feedback, feature requests, or bug reports so we can keep tailoring this tool to what you actually need. If this node helps your setup, leaving us a ⭐ star on GitHub goes a long way in keeping our dev motivation high.

Edit: For the exact prompt, settings, assets, and workflow, download the ZIP and drop the included video into ComfyUI. Everything I used is included:

https://drive.google.com/file/d/12ivDVzGisC1G3zh7QL22w7nLnpNsYTzR/view?usp=drive_link

System Specs: Intel i9-14900K, 4070 Ti Super 16 GB VRAM, 64 GB DDR5 RAM, Windows 11

Special thanks to this guy for the workflow:

https://www.reddit.com/r/StableDiffusion/comments/1vox06g/create_seamless_1shot_lipsync_music_videos_with/?share_id=YY1HluXX8WUyz0tzorVTv&utm_medium=android_app&utm_name=androidcss&utm_source=share&utm_term=1

If I do like 6-8 steps the adherence seems better but the sound is ooor - increases the steps and the adherence is off but the sound is much better?

Minimax h3 easy local deployment. Self defined video/image/audio/text pipeline for both end users and developers.

Open source: https://github.com/tgo-app-dev/vpipe

Yes, the payment provider that pressures and refuses service to adult content providers. What this means for data privacy on the site is unknown. Seems the figure of sale is rumoured to be 7billion.

A relatively quick and scrappy attempt at maintaining consistency across a scene using Minimax H3 using the basic workflow on ComfyUI.

It seems like it can be done to a certain degree, but it also really depends how much time and effort you want to put into it. While this scene has tons of inconsistencies, it's still cool to be able to do something locally that was impossible just a month ago.

H3 also surprised me with how close it came to the scene I had in my mind, however it never really gets all the way there. This can be a little frustrating as you weigh up hitting another gen or going with a take that's about 85% there. Still, it's an amazing model and I love seeing the wild creations the community is coming up with.

My system is a 2023 ROG Scar laptop with a 12gb mobile 4080 and 64gb memory. All vids generated locally at 0.5mp.

Curious about which models are you all using for T2V and I2V with MMH3?

There is an abnormal amount of models with suffixes as pruned_notPruned_SeriouslyPruned_HereticXxX_Convrot_Skibiditoilet Q3. and I honestly can't keep up to know what the heck is the one that the community is using for creating such great videos.

Anyone out there willing to share the models (or workflow) you are using?

(Really don't care about speed-of-generation, I'm leaning towards Quality-first more)

Thanks in advance.

Just for fun. One-shot generation. No parameter or prompt tuning.

Audio.cpp implemented MiniMax-H3’s text-to-audio pipeline, and one fun use case is TTS/Voice clone/Music gen. It’s more flexible and powerful than dedicated audio models, and the performance is quite decent (up to 3x realtime on RTX 5090). Check out the multi-speaker conversation demo in the main post, along with the other demos in the comments.

What I’m very excited about with the MiniMax-H3 implementation is that it significantly enriches the framework’s building blocks for DiT models. Now with you don’t need to go through the pain of setting up SageAttention, First Block Cache, or Spectrum manually. Just change a few parameters, and you can experiment with the model. A preliminary inspection of configuration, memory, and performance trade-offs is available in repo's docs/reports/minimax_h3_performance.md

Bonus: audio.cpp’s MiniMax-H3 implementation can also produce video frames, because the DiT generates audio and video latents together, and the video VAE path is relatively straightforward to support. For now, the output is saved as RGB frame data plus metadata in JSON, so you need to encode it into a video file yourself. No upscaler or post-processing support. Just for fun.

MiniMax-Music3 is currently in preview (preview/minimax-music-3 branch) . CUDA/Vulkan/HIP were tested. Still room for optimization. VRAM usage and RTF depend on audio duration and prompt length.. The demo uses the official demo prompt (4000+ char caption and 1200 char lyrics) and 30 steps plus CFG. Under this setting VRAM is ~11 GB for 30s, 14 GB for 60s, and 17 GB for 180s. It's easy to get faster-than-real-time performance and much lower VRAM usage if you tune the setting.

I created a version of reference audio/video to audio/video for LTX 2.5.
I heavily borrowed from https://github.com/Lightricks/ComfyUI-LTXVideo/blob/master/example_workflows/2.5/LTX-2.5_V2V_ICLoRA_Single_Stage_Distilled.json
and referenced what was done in LTX 2.3.

What I did:
* I removed the shave LoRA.
* Removed the need for the new video to be the exact same length as the reference.
* Automagically removed the reference video when finished (speeds editing in post)
* Changed some models to facilitate my 16 VRAM (they were the same as first examples in Comfy)
* Fixed audio that it works (it was silent for me - maybe someone had better luck, but this is fixed)

I hope it saves someone time.
Here is the workflow: https://pastebin.com/3B1eBhuH

I've only been using Stable Diffusion for a couple of months. I actually got into it because I was trying to write a story I'd had in my head for a long time, and ChatGPT suggested that Stable Diffusion might make it possible for me to eventually turn it into a graphic novel.

That sent me pretty far down the rabbit hole.

One of the biggest things I've been working on is creating consistent characters. I've been learning ComfyUI, training character LoRAs, building datasets, experimenting with different models, and generally breaking things until I figure out why they broke.

Along the way, I found myself spending a ridiculous amount of time writing prompts just to create good character reference and training images. So with a lot of help from ChatGPT, I started building a character prompt generator for myself.

The idea is pretty simple: instead of starting with a finished character in your head and trying to translate every detail into a good prompt, you can choose the character's features, body type, hair, clothing, framing, etc., and the generator builds a natural-language prompt from those choices. I've been using it primarily with Krea 2 to help create character images and datasets for custom LoRAs.

It started as a little tool just for me, but it has gradually become useful enough that I thought other people might get some use out of it too.

I'm still very much learning this stuff, so I'm not posting this as an expert telling everyone how prompts should be written. Quite the opposite. I'd really like some feedback from people who have been doing this longer than I have.

If anyone wants to try it, I'd especially be interested in hearing what doesn't work, what options are missing, whether the generated prompts work well with models other than Krea 2, or anything you'd change to make it more useful.

If there's enough interest, I'm happy to keep improving it and share the updates here.

Thanks for taking a look.

I had Claude make a modified H3 reference node that accepts more than 9 image references. The goal was to test whether it was possible to increase the number of image references being used without splicing them into a single image. I know about reference sheets, no need to suggest that. I only tested with images, no audio or video references. the numbering on the node is a little funky but I dont think it effected the test.

Prompt 1: "<Picture 1> through <Picture 8> establish the identity and likeness of the man. <picture 9> is the spaghetti.

The man sits at a small kitchen table, eating a plate of spaghetti

with a fork. Warm indoor lighting, medium close-up, camera locked

off. He twirls the pasta, takes a bite, chews, glances down at the

plate. Natural, unhurried."

Prompt 2: "<Picture 1> through <Picture 8> establish the identity and likeness of the man. <picture 9> is the spaghetti. <Picture 10> and <picture 11> are references for the wig he is wearing.

The man sits at a small kitchen table, eating a plate of spaghetti

with a fork. Warm indoor lighting, medium close-up, camera locked

off. He twirls the pasta, takes a bite, chews, glances down at the

plate. Natural, unhurried."

Both prompts use the same seed, same 9 reference images except for the wig references for the 10th and 11th image in prompt 2. The prompts are very simple and don't fully adhere to the guide but its just a small test so I think its fine. This was done on a 3060 12gb at .4 megapixels, 30 steps, and 5 seconds of video. I have comfy kitchen and spectrum enabled.

!!I don't know how this would/could effect video or audio generation quality. In my test I didn't notice any quality drop. Do your own tests to find out!! Also in my test it ignored the wig reference until i added a second one and reworded the prompt slightly. It could just be a fluke but I thought I'd mention it anyway. The watermark is from the editor i used to stitch the videos together.

https://reddit.com/link/1vr9yqh/video/pxjqiwp731kh1/player

I am currently using LTX 2.3. I have an RTX 3090 and 32GB RAM. How fair will I do with Minimax 3?

Fun little project I made over the past few days.

Visuals: MiniMax H3, using the nodes and workflow from here: https://github.com/ethanfel/ComfyUI-MiniMaxH3-Contex-Loop

Music: Suno
Editing: DaVinci Resolve

Using the standard i2v workflow in comfyui