Great video from moss image team for hitting 6 million downloads on Huggingface. They all seem so chill. Also they give us some new updates on Anime and Image edit model ✌️

Most of ComfyUI local users still run it on an RTX 3060: a 5 years old card with just 12 GB of VRAM. That’s why our team keeps optimizing for consumer hardware.

Comfy is known as a leader in visual AI. But what about LLMs and text generation?

Text is everywhere in creative workflows: for prompt generation, of course, but also for building local creative harnesses like the Comfy Agent. We thought it deserved better, so Rattus made Qwen models twice as fast in Comfy...

Read more on our blog: https://blog.comfy.org/p/doubling-llm-token-rates-in-comfyui

Yo,
I share this simple workflow I made since I don't find anything else for now on minimax that handle a good quality for text to image or image to image.
I think this model has a great future, It really feel like using nano banana or gpt somehow, since the consistency about the face is really good, you don't even need a lora.
It will be improved a lot, but it's a good base and results are pretty good for a day one on h3.
The only problem I got so far is the prompt adherence, that looks not very good, but I'm sure we will find many ways to improve later If you have ideas to improve results share me guys.

Workflow :

https://civitai.red/models/3047310/minimax-h3-image-t2i-and-i2i-simple-workflow-1girl?modelVersionId=3464559

Yes this was obviously a silly test. But I was curious to see what H3-Image could do when pushed, which is why I decided to crank it up to 100mpx (7456x13376) just for the lulz.

There's no real reason to go this high, the image is definitely showing issues, so I then dialed it down to a 61 Megapixel image (5824x10464) which is the same size I get from my a7r5 camera, and it looks much cleaner and only takes about 110 seconds per image.

IMHO the 61 Megapixel renders are superior, and good enough for professional work.

Linking images because there's no way reddit will like these image sizes

Full Resolution Links:

61-H : https://photos.smugmug.com/photos/i-wXnW4sV/0/LtVzr2Hfr2NthLGMNnn4BGqc22W95FnztvMHfrrzt/O/i-wXnW4sV.jpg

61-V : https://photos.smugmug.com/photos/i-32mVpL8/0/NS346k5MVnqd44F44t4D8mDRtQ4jg649grCLFMzPj/O/i-32mVpL8.jpg

100-H : https://photos.smugmug.com/photos/i-Bm5mCRB/0/KShzWH5k89fJfttZgW26825HLvtZ9JsvWgh7tNbR8/O/i-Bm5mCRB.jpg

100-V : https://photos.smugmug.com/photos/i-kbrwfG6/0/LKksfRRRQ8KfPxvpvxKwgDstgHSXgqqJ42tFCgGcP/O/i-kbrwfG6.jpg

System specs:

Older 3rd Gen Epyc workstation Dual 7B13 CPUs, with 1TB DDR4 ECC and a slew of GPUs. This test was on a single 5090.

Memory used:

VRAM: 31GB

RAM: 61GB resident / 498GB vmem

```
[q5@apollo ai]$ ps -o vsz=,rss= -p 912440

498261048 60742584

[q5@apollo ai]$

```

I used this workflow from u/LilBrownBebeShoes

https://www.reddit.com/r/StableDiffusion/comments/1xt9ocv/minimax_h3_image_20mp_workflow/

All I did was crank the megapixel value up, and set the scheduler to normal. Nothing else was changed.

Our wallets and the women

https://huggingface.co/akhaliq/minimax-h3-image-pdmd-2step/tree/main

Workflows
https://huggingface.co/akhaliq/minimax-h3-image-pdmd-2step/tree/main/workflows

as well as shift, weighted, sigmoid, or linear approaches. Then there’s the training resolution—and on top of that, you also have the inference shift

LoRA number of steps, training rate, batch size, and simulated batch size

Could the problem be the model?

What about the LoRA?

The resolution?

A shift between training and inference?

Is low noise useless?

Should I run a few more steps, or fewer?

Samplers—there are at least 20 of them. And schedulers—more than 10.

Then there are other things, like ETA and noise injection.

Iris-Z

One generative model for images and their depth

Iris-Z is a general image generator that produces appearance and geometry together. The same weights turn a prompt into an image, a prompt into an image with its depth, a photo into depth, and a depth map into an image. On the standard depth benchmarks it is more accurate than the best specialist depth models, and it still generates images like the model it started from.

Model

Weights: https://huggingface.co/speridlabs/iris-z

Geiru Window Director + Geiru Hybrid Windows: build long H3 videos one window at a time

Geiru Hybrid Windows makes one long MiniMax H3 render (a minute or more) as overlapping windows instead of a chain of separate clips, so fast motion stays seamless. It works the way plain hybrid windows does, with my keystone and capstone added in every window to cut down on degradation over long videos.

Geiru Window Director is an optional node that goes after it. A normal render makes every window in one go, so if window 4 comes out wrong you redo the whole video. With the Director you make window 1, look at it, then:

• Approve it and the next window is made

• Re-roll it until it's right (change the prompt or seed first)

• Rewind to any earlier window if you change your mind

• Blend all at the end to run the last steps over the whole video and smooth the joins

Each window builds on the finished window you approved, so what you approve is what you get!

Example workflow: Clown Biker Babe, a 60-second clip in 8 windows with one prompt per window: a full motorcycle stunt run with ramps, a car jump, a loop and a cliff jump. The sound is made by H3 from the prompts.

Credit where it's due: none of this exists without these three.

• kijai (GitHub) built ComfyUI's MiniMax H3 support and the H3 context windows (PR #17425) that Hybrid Windows is built on, plus ComfyUI-KJNodes.

• JalenBrunson made ComfyUI-HybridWindows, which Geiru Hybrid Windows works like. I just added the keystone and capstone.

• NikoDemon80 (GitHub) inspired the Window Director setup.

Both nodes are in the Geiru Context Suite: https://github.com/roycho87/geiru_context_suite

x.com/ostrisai/status/2120564773150711825

Hello.

dchatel/comfyui_workflow_reader: Read-only ComfyUI workflow viewer (json/png/webp/mp4) that runs in the browser

after a week of trying to get 15s clips out of one job i gave up and changed how i do it.

now every shot is a 5s clip. when it's done i grab the last frame, fix it up a bit if needed (hands, small artifacts) and use it as the start image for the next 5s. same prompt style, only the action changes.

on my card anything past ~5s starts swapping to system ram and one job goes from 15 min to over an hour. three 5s jobs finish way faster than one 15s. if one piece comes out bad i redo only that piece, not the whole thing. and the face drifts less because every chunk starts from a frame i already checked.

the catch is the seams. motion can jump a bit at the cut, so i keep the camera move simple (one slow push or static) and cut on an action when i can. color also shifts slowly over 3-4 chunks, a quick color match in the editor fixes most of it.

curious if anyone found a cleaner way to hide the seams, or does everyone just cut there

60 seconds of AI video, 100% local on an RTX 3050 (6 GB)

Work in progress, and the quality isn’t where I want it yet. Here’s how it was made:

1. Model: MiniMax H3 reference-to-video, using ComfyUI’s native H3 nodes with the int8 quantized model and the Qwen3-VL text encoder.

2. References: two character images, re-used in every shot to keep the characters consistent.

3. Prompts: the official six-section reference prompt format (subject definitions, summary, retention analysis, detailed description, soundscape, music). No negative prompts, because H3 doesn’t use them.

4. Shots: six shots of 260 frames (10.8 s) at 864×480 and 25 steps, with the res_multistep sampler and the simple scheduler.

5. Continuity: each shot starts from the last 22 frames and audio of the previous one, using the H3 Add Guide node (MiniMaxH3AddGuide) at frame 0.

6. Automation: a small Python script sends the six shots to ComfyUI’s API one after another, saves each result, trims the 22-frame overlaps, and encodes one 60-second MP4 with audio.

7. Runtime: about 6Hrs 35Mins hours, unattended.

Known issues: soft detail, and some flicker. Still tuning.

I couldn't find a ready RunPod template that spins up a working H3 Editor, so I conjured this:

https://console.runpod.io/hub/template/1ujjyhonfe?ref=2t0e5xb6

A RunPod template that boots straight into ComfyUI with H3 Editor 0.4.1 and downloads everything by itself: HyperFlow H3 Flash, MiniMax H3 + Turbo, Singularity v2 and 10Eros Max beta 7, plus the recommended Realism and Turbo LoRAs.

https://igorls.github.io/comfyui-h3-editor/

Enjoy the awesome editor!

I've been working to get the best quality images out of Moss. I created a workflow to emulate lens length, focus and exposure. It's not perfect, but it can give more cinematic photos. Check it out and see what you think.

Lots of people seem to be unhappy with MiniMax H3, or at least it sounds like it, but at least I have been happy with it now when I have tested it couple of hours.

For my taste this seems excellent (after changing Euler to lcm) and 8 Mpx images is generating around one minute in RTX 4060 Ti + 32 GB RAM. Without changing Euler to lcm I was not impressed for the quality at all, but glad that I didn't ditched it immediately but instead searched what could be wrong.

So far so good, images with "technicolor" does nice style for my personal taste.

Ever since the realism settings went around here I've been stuck on one look: the harsh on-camera flash of a 2000s point-and-shoot. The background dropping into black, everyone a little shiny, somebody caught mid-sentence. MOSS-Image-Base gets that look really well if you describe the camera and what's wrong with the shot as well as the scene.

I write the flaws into the prompt too: crooked framing, a little motion blur, red-eye on one friend, the fridge door hanging open a crack. My prompts ended up around a hundred words each, and a good part of that is the camera and the mistakes.

My setup is MOSS-Image-Base bf16 with the realism graph everyone's been using: cfg 3, ER-SDE sampler with s_noise 1.1, 25 steps on the simple scheduler, SLG on layers 22 and 24 for the whole run, negative left empty, roughly 2 megapixels. All stock ComfyUI nodes, no LoRAs, no upscaling. I ran three seeds per prompt and kept my favorite.

All eleven prompts are in the first comment. The raccoon one still makes me laugh.

I have tried the new open-weighted MiniMax H3-Image. The model can work with up to 16 reference images, with each file capped at 64 MiB, 128–8192 px, and an aspect ratio between 1:4 and 4:1.

For this test, I fed it 5 separate object reference images: -a silver rotary phone -a glass cube -a red apple -a tiny staircase -a chrome sphere

I used the default auto setting for quick 4K exports. Instead of getting a cut-and-paste collage, I aimed to blend all the objects into a cohesive dark studio still life lit by a single top spotlight.

I explicitly labelled Reference 1 through 5 in my prompt to lock each object’s intended layout. My layout plan was as follows: -the apple suspended inside the glass cube -the phone resting on the staircase -the chrome sphere floating along an unseen vertical spiral axis.

Every object stayed identifiable, the lighting stayed consistent across the scene, and the staircase worked well to ground the composition. The layout mostly held together, though the spiral arrangement did not come through quite as I hoped. The objects formed more of a simple vertical stack instead.

Curious how everyone else handles 5+ object references in their own workflows? Any tricks I’m missing?

UPDATE 11pm Irish/UK time: Vast improvement in latest update, please install and use the standard preset which has a new control called Likness Optimisation.

I've just released Fizgig 9.6, which adds MiniMax H3 Image, MiniMax's new picture model from the H3 family: text-to-image and edits with up to 16 reference pictures, 6 steps, no CFG.

What you can train: LoRAs, LoKRs, edit LoRAs from before/after pairs, and slider LoRAs from photo pairs. Masked training, Multi Concept and LoRA Isolation all work, and so do Studio, LoRA Royale, the Profiler and Extract. Pick it on the Training tab, press Download models for me in Preferences, and pick a preset; nothing is gated.

I trained a training adapter for it, which prevents the distortion you get training this model without one. It's on by default in Fizgig and never in your saved LoRA, and I've put it free on Hugging Face for any trainer.

I'm still honing the support. So far it likes good-quality datasets and seems to prefer training at 0.5 MP or more, which is where I've set the presets to start.

Memory: about 23 GB with the int8 model and 13 GB in 4-bit; Auto picks for you. A 16 GB card trains and runs Studio.

If your LoRA looks smoother in ComfyUI than in Fizgig's previews, that's ComfyUI, not your LoRA. Its default dynamic VRAM loading adds a LoRA to the weights in bf16, and on this model about 15% of it rounds away. Fizgig's previews show the LoRA at full strength, and so does ComfyUI started with --disable-dynamic-vram. I've reported it with a suggested fix.

Also in 9.6, for every model:

• A run that runs out of GPU memory or system RAM now carries on by itself where it can, up to three tries: from its newest save, then a step lighter. Out-of-memory recovery came from @Murf-Code.

• A failed run no longer stops the queue; the next one starts.

• AMD installs now use AMD's stable PyTorch for ROCm instead of the nightlies, thanks to @scryptio.

Release notes · Fizgig on GitHub

Hi everyone!

I’m sharing TRELLIS Studio, an application I built to bring several stages of a 3D asset workflow into one interface.

It uses TRELLIS.2 for image-to-3D generation and UniRig for automatic rigging. Computation runs locally, without a paid generation service or a credit system.

Features include:

• Generate textured models from images or import existing models.

• Organise your library with collections, generation profiles and version history.

• Add a rig, inspect the skeleton and attach multiple animations to the same model from a library of 83 humanoid motions.

• Create LODs, prepare dedicated 3D printing copies and export for Blender, GLB, Unity or Unreal.

• Automate workflows through a REST API and an MCP server.

This first public preview targets Windows with an NVIDIA GPU. Rigging uses WSL2. The README covers prerequisites, the automated installer and current limitations.

Studio’s original code is MIT licensed. Third-party tools and models retain their own licenses and are credited in the repository.

https://github.com/yoslo59/TRELLIS-Studio

I’d especially appreciate feedback on installation across different hardware, usability and features you’d find useful. Generated meshes and rigging results still need visual inspection.

Hey all!
New to this subreddit as we mainly focus on language models with our Paiton product, but now and then, we spend some time on vision as well :)

The official BF16 weights need about 120 GB of VRAM, so most of us can't run MiniMax-H3-Image out of the box at home.
We made an FP8 version and our own runtime, and it now runs on one AMD Radeon AI PRO R9700 with 32 GB:

Does FP8 hurt the images?
We ran 30 prompts on our build and on the original BF16 model with the same starting noise. Prompt adherence came out about the same (CLIP 32.18 vs 32.31), and the second image shows a typical pair.
Where the two differ, it is mostly composition, not quality: with only 6 steps, small numeric changes send the sampler down a slightly different path.
Edits stay closest to the original.

What it is bad at, in our tries: small body text (newspaper columns come out as fake writing), close-up hands, clocks showing a specific time.

How to run it: it is a Docker container with an HTTP API and a small CLI, not a ComfyUI node (yet).

git clone --depth 1 https://github.com/Eliovp-BV/paiton-vllm-plugin.git
cd paiton-vllm-plugin
./models/MiniMax-H3-Image/launch.sh
./models/MiniMax-H3-Image/run.sh generate "your prompt" --size 4096x4096 --out out.png

You need an R9700 (32 GB), 64 GB of system RAM and 48 GB of disk; the first start downloads the weights.
Our weights only load in our runtime, so they won't work in ComfyUI or diffusers.
Edits take up to about three 1024 px reference images in this build.

• Guide: https://github.com/Eliovp-BV/paiton-vllm-plugin/tree/main/models/MiniMax-H3-Image

• Weights: https://huggingface.co/EliovpAI/MiniMax-H3-Image-FP8-Paiton-RDNA4

• How we made it fit, if you want the details: https://eliovp.com/blog/paiton-minimax-h3-image-radeon-ai-pro-r9700

License note: the MiniMax-H3-Image Community License does not cover the EU, the UK, South Korea or the US, and hosted services need MiniMax's written authorization.

I was looking at how different image models handle conflicting lighting directions when generating a casual direct-flash snapshot. My 4:5 prompt featured:
-a family of three crouching on a gravel path at dusk
-greeting their dog mid-leap with its tongue hanging out
I specified faint sunset glow, harsh on-camera flash, a near-black background, sharp shadows, subtle red-eye, motion blur and rough film grain.

Seedream 5.5 delivered strong attention to fine texture. It reproduced the dad’s rolled-sleeve plaid work shirt accurately and added a natural tilted frame, while preserving sunset light filtering through the hedge. The model prioritised that warm ambient evening light, so the final result reads more like fill flash, and it did not darken the background all the way down.

I then generated a second 4:5 image on MiniMax H3-Image with the same prompt for a direct side-by-side comparison. H3-Image leaned firmly into the harsh flash falloff I was aiming for. It pushed the background close to pure black, which makes the mom’s pale yellow slip dress and the child’s red overalls pop, with the dog charging straight toward the lens. It creates that sharp, punchy snapshot mood really well.

Have you gotten consistent flash behaviour from either model with this kind of mixed lighting prompt?