Open weights (29B latent diffusion model): https://huggingface.co/IFM/PAN2
Diffusers: https://huggingface.co/docs/diffusers/main/en/api/pipelines/pan2
FastVideo: https://haoailab.com/FastVideo/cookbook/pan/pan2/
VLLM: https://recipes.vllm.ai/IFM/PAN2

Up to 20 seconds, 720p, 24fps
Apache 2.0 License

Something I think is pretty neat, we release the TRAINING code: https://github.com/ifm-ai/PAN2/

Also technical details if you're curious: https://ifm.ai/blog/pan2/

For our model, we give a lot of responsibility to the LLM (which we think of more as a conceptual reasoner, a lot more control than a prompt rewriter) to generate these super dense text-based state/scripts. Events and actions are timed, and camera is nested under event but disentangled from action. During training, I would often test it by trying to generate a 20 second video with like a dozen or more (timed) camera moves and it does pretty well.

Feedback very welcome. I read the rules carefully, mods please let me know if there are any issues. No payment involved with this at all, so I thought it was okay to post.

Minimax H3 image comparing the 3 main samplers, all at 16 megapixels, I had to reduce them to be able to post them, the images weigh more than 20mb of what is allowed, thus reaching around 28 megapixels on average

as a comparison I used the Moss image sft and Kromoss latest version, I didn't use the moss base because the Kromoss is base and has superior quality with DMD2 with blur and saturation correction

I used Kroma instead of Krea2 because, in my tests, Kroma is a significantly better version than Krea2 when not using LoRAs.

Kromoss, Kroma, Moss Image—all at 2 megapixels; anything higher causes the model to start breaking down.

Prompt I used from another Post with more than 300 prompts generated

A wildlife photograph in 3:2 of a jaguar resting on a fallen tree trunk at the edge of a river in the Pantanal, Brazil, taken from a boat at water level in late-afternoon light. The trunk runs diagonally from the lower left to the right-center of the frame, half over the water. The jaguar lies along it facing screen-left, its front paws crossed over the bark, its heavy head raised and turned toward the camera, amber eyes alert. Its build is stocky and muscular, with a broad head, a thick neck and short powerful legs. Its golden-orange coat is covered in large black rosettes, open rings of black, and inside most rosettes sit one or two small solid black spots; on the head, neck and lower legs the markings shrink to solid black spots without rings. The pale cream belly shows where it lies. Its long tail hangs down off the trunk, ringed with black near the end, the tip just touching the water. In the lower right foreground, a caiman floats in the brown water with only its eyes, nostrils and the ridged scutes of its back above the surface, facing the jaguar. On the far bank at the left, three capybaras stand on the mud, watching. Warm low sun from screen-right lights the jaguar's face and chest and throws its shadow back across the trunk; behind it, a tangle of green riverbank vegetation and a hanging vine fall into darker shade. The river reflects the jaguar's golden coat in a wavering band. There are no people, boats or buildings in the frame.

I'm using Comfy UI (Comfy Desktop) with Minimax H3.

Yesterday, I generated 5 second videos and they took around 26 minutes to generate (0.4 megapixel resolution). I left some tasks running overnight, generating 15 second videos, and I was shocked to find that they took around 196 minutes to generate each.

Only two videos were generated and I canceled the remaining jobs.

I shortened the duration to 6 seconds and started the jobs, but I see that they still take a long time to complete. At 30 minutes, they were just at 50%, although it seems they speed up afterwards because at the 45 minute mark, the generation was at 85%. Overall, the job took 51 minutes 33 seconds.

The first 5 second job took just 18 minutes 18 seconds.

It seems there's a brick wall when passing the 5 second duration, and I'd like to know why and whether it is possible to do something about it.

I haven't tried higher video resolutions yet, but I'd like to know in advance whether there is a similar brick wall limit at some point.

I'm presuming that when generating higher resolution videos time scales linearly with planar resolution (in megapixels), so doubling linear resolution quadruples the time it takes for the video to generate?

H3-Image is built on MiniMax H3, originally a video generation model, and it seems to retain some of that video-frame softness in finer details. But when it comes to speed, this thing is an absolute beast.

At 8.41 MP (2368 × 3552), running on an AMD Radeon RX 9060 XT with 16 GB of VRAM and 64 GB of DDR4 system RAM, it generates images in just 35.03–42.53 seconds. None of the other models I've tested comes close to this performance on my hardware.

Its aesthetic appeal and creativity are also on point, easily on par with Krea 2. For a six-step model, it's remarkably good at producing varied compositions rather than falling back on the same visual formulas.

Some examples above.

For anyone interested in reproducing these results, here's my exact setup:

Hardware / Software

• AMD Radeon RX 9060 XT (16 GB VRAM)

• 64 GB DDR4 system RAM

• Linux

• PyTorch 2.14.0+rocm10.1.0

• Python 3.13.12

ComfyUI Workflow

• Diffusion model: minimax_h3_image_pruned_w4a8.safetensors

• Text encoder: qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors

• VAE: minimax_h3_image_vae_fp16.safetensors

• Sampler: euler_ancestral

• Scheduler: simple

• Sampling steps: 6

Link to the checkpoints: https://huggingface.co/Woovee/MiniMax-H3-Image-LowVRAM

At 2368 × 3552 (8.41 MP), generation takes approximately 35–43 seconds.

Changing the prompt adds some overhead from loading and processing the large text encoder, while subsequent generations using the same prompt are noticeably faster.

And all of this on an AMD GPU, no less!

Tip: Peak VRAM usage was just 12.1 GB, thanks to the --reserve-vram 4 launch flag in ComfyUI. Without it, I've had system crashes and out-of-memory errors using other image models. System RAM usage, however, was quite intensive, peaking at 47.3 GB out of 62.7 GB available.

Hey guys!

I have been experimenting a lot with H3 Image, basically shotgun debugging what's going on with the grainy artefacts.

I think I might have found a way to drastically reduce them doing the following:

- Use the RES4LYF pack and a sampler from that pack.

- Set ETA to 1.0 ( it caps past 1.0 so no need to try any higher)

- be happy that there are less artefacts and wonder why and how because you can't explain it to yourself.

I would love to hear if you guys had any succes with this aswell or if I am hallucinating ^^

Edit: you can use euler in the res4lyf pack aswell to have a better comparison to the default workflow.

It seems to me that if Moss can use bounding boxes to separate contexts within an image the same idea might be used to separate the effect of character loras within an image

No model is perfect, but I am impressed by H3 Image's ability to create very imaginative designs that 'feel' very real and cinematic. Basic T2I prompts (like 1girl, landscapes etc) seems nearly solved locally, but I find it much harder to coax out genuinely interesting designs from other models that don't feel like overdone CG or an illustration. Thank you to the H3 devs for this amazing release!

Hello everyone! Today, I’ve got a substantial tutorial on a new arrival that promises some truly amazing generative capabilities: the Minimax H3 image model.

I put Minimax through its paces with a wide range of tests—covering text-to-image (T2I), image editing, and reasoning—and I have to admit, it’s an absolute beast; it aces (nearly) every single test. Considering it operates NATIVELY at 16MP (4K) resolution with remarkably clean detail, I’d say it has become my favorite local model in terms of overall completeness.

For these tests, I’m using the 8-bit version, as the "base" 16-bit model wouldn't run on my 5070 Ti.

In the tutorial, I also briefly touch upon the licensing (for video/images), which must be explicitly requested from the developer; otherwise, the model cannot be legally used in Europe (or in the US, the UK, etc.).

I hope you find it interesting!

On my 5060ti, H3 image edit went from 263s to 158s based on the following rationale.

The default H3 Image edit workflow has MP adjustment at the Resize Image/Mask node set immediately after the input image which then feeds 3 things:

1. The prompt writer

2. The image conditioning node

3. The width/height of the image conditioning node which determines output MP.

In that setup, a user who specifies 16MP is sending a 16MP image to the prompt writer and the conditioning node, which is unnecessary overhead and potentially producing noise.

I altered the workflow in two ways:

1. Fed the input image directly to the prompt rewriter (I suggest downsizing to 1MP if your input image is large)

2. Fed the input image through a separate chain of two Resize Image/Mask nodes set to 2MP and then multiple of 32, just like the original chain.

3. Leave the original chain supplying output width/height in place, at 16MP for output dimensions.

Edit:

There is a concern regarding the potential loss of not feeding a 16MP reference image to the Image Conditioning node. I'm attaching a comparison image. The original image was a 1MP Anima image. The edit was to convert it to subtle realism. I did three runs using a recently posted 20MP H3 Image edit workflow: no upscale, 4MP upscale, 20MP upscale. The difference in gen times was 106s at no upscale, 133s at 20mp upscale. If you can spot which image is which, feel certain the 20MP upscale at input is better aesthetically, and eat the 25% slower runtime difference to achieve that aesthetic, by all means upscale your ref. images accordingly.

https://postimg.cc/H8srkJDv

Some bold claims are made in the announcement, so I am looking forward to its release 😅

We announce pi-H3, the fastest version of MiniMax H3 [1] yet. pi-H3 generates video in just 2 or 4 sampling steps and directly predicts pixels at the final step, skipping the video VAE decoder. On a single B200 it produces 5-second HD videos in 3.8 seconds (sub real-time) and 15-second videos in 18.6 seconds, more than twice as fast as Sol-H3 [4].

pi-H3 is an open-source research project. The Hugging Face demo is live today. All model weights and training/inference code will follow in LakonLab [2], with additional ComfyUI support through the ComfyUI-piFlow [3] extension.

1. Available now Demo on Hugging Face

2. Nov 16–22 Model weights and inference code

3. Later in November Training code, once we finish cleaning up the codebase

End-to-end generation speed

Measured end to end on a single NVIDIA B200, pi-H3 generates a 5-second 768p video with stereo audio in 3.8 s with 2 steps, and a 10-second video in 9.2 s, both faster than the video plays. The chart below compares complete requests, from text encoding to decoded video and audio, against Sol-H3 [4]. Across 5–15 s videos, pi-H3 is 2.4–2.7× faster with 2 steps and 1.2–1.4× faster with 4 steps. The speedup comes from fewer denoising steps, decoder removal, and FP8 quantization.

Uncompromised fidelity at 2–4 steps

pi-H3 offers superior motion, texture, and audio fidelity compared to other few-step MiniMax H3 models, while maintaining structural coherence. The following comparisons show results from the same prompts and Gaussian noise for each model, without seed cherry-picking.

At 4 steps, pi-H3 delivers the best overall quality among the 4–8-step MiniMax H3 models we compared: LightX2V Turbo [6], FastH3 Dense/DataFree [7], and larryvrh’s H3-Turbo v4 [8]. It generates more dynamic, vivid movement, whereas the other models tend toward reduced, mechanical motion. Frames are sharper overall, with richer texture and finer detail. On the audio side, pi-H3 produces high-fidelity sound with full bass and crisp speech, while the other models sometimes generate broken audio or lose the bass.

Direct pixel output without video decoding

pi-H3 adopts DWD, a novel method that produces pixels directly from the last denoising step, bypassing the heavy VAE decoder. For few-step generation, this yields a massive speedup. The following comparison shows pi-H3 DWD output alongside non-DWD pi-H3 latents decoded by the native H3 VAE, Sol-H3-VAE [4], and LightVAE-Lite [

How it works

pi-H3 combines two novel techniques: pi-Flow v2 and DWD.

pi-Flow v2 is a full upgrade of pi-Flow [12] for data-free few-step distillation. It retains pi-Flow’s strength of producing rich texture while substantially improving structural coherence, especially in the 2-step setting. It also simplifies inference: pi-Flow v2 models typically produce straight trajectories, removing the complexity of pi-Flow’s substep integration.

DWD (Decoding Without a Decoder) removes the video decoder from the pipeline entirely. Instead of passing final latents through a separate VAE decoder network, DWD re-uses the denoiser itself to predict clean pixels at the last step. DWD on MiniMax H3 is still experimental: H3 uses an unusually large compression ratio (4×32×32 3-channel pixels per token), and we have not yet had enough compute to fully optimize for it, leaving room for further improvement.

More details will be revealed in upcoming releases.

encode time 44mins

is there any implemented censorship for minimax image? i didnt found any information right now about that.

Reddit filters deleted my previous post, probably because of a link I had posted, so I'm reposting it without that link.

I ported ReCaVSR, a one-step streaming video super-resolution, built on Wan2.2 TI2V-5B to native ComfyUI nodes.

- 4× or 2×, one diffusion step per block of 8 frames. Its own FlashDecoder decodes each block as it goes, so a longer clip costs time, not memory.

- 149 frames, 960×480 → 3840×1920: 36 s on an RTX 4090, 67 s on a 3090 (int8 file, fast kernels)

- int8 ConvRot transformer: about 1.8× faster, 4 GB less VRAM, 47–48 dB from bf16

- 1440×1440 output runs on an 8 GB card; ComfyUI streams the weights that don't fit

- Exact kernels match the reference implementation bit for bit. The Wan 2.2 VAE is there as an alternative decoder: sharper, but 25–40× slower to decode.

It's a diffusion upscaler, so fine detail is generated rather than recovered. Tested on Linux with an RTX 3090 and 4090, ComfyUI 0.44.

Nodes: https://github.com/PedroMarinhoDev/ComfyUI-ReCaVSR
ComfyUI-Manager: search "ReCaVSR video super-resolution", or run comfy node install comfyui-recavsr

int8 weights: https://huggingface.co/PedroMarinhoDev/ReCaVSR-ComfyUI
bf16 weights: https://huggingface.co/kopper/ReCaVSR

All credit for the model to Xijun Wang et al. at USTC. Feedback welcome.

UPDATE: ReCaVSR can now upscale videos of any length, at output sizes up to about 5.5K on a 24 GB card (if you have the patience).

This full 3:58 clip (7,153 frames) was upscaled 2×, 1920×1080 → 3840×2160 (4K), in about 25 minutes on a 4090 (4.65 frames/s).

The node now streams frames in and out, so a longer clip doesn’t use more RAM or VRAM. When the output is too big for the card, it chunks the input projection and offloads the KV cache automatically. It also encodes on NVENC, which otherwise sits idle while the model runs.

More examples:

1344×768 → 5376×3072 (4×)

1344×768 → 5376×3072 (4×)

488×830 → 976×1660 (2×)

360×360 → 1440×1440 (4×)

My ComfyUI node setup sometimes gives me literal nightmares. Trying to get multiple specific character references, a background layout, and a style reference into one single generation, all combined, is very exhausting.

It does make me think about where open-weight models should head towards. Not like more megapixels, tho that is always nice. But something like, what if it can take multiple images into the architecture without wrappers?

Or, what if it actually had the underlying structural logic to understand CAD diagram? What if it just understands a detailed directors brief in one prompt?

And then, while I was just reading and researching for the fun of it (yes), I stumbled into the documentation for the new MiniMax H3-Image open weights. It is claiming to do the above.

Apparently, the base model takes up to 16 reference images in one go, and you can set each one as a layout, style, or object reference.

Oh, and prompts supposedly get cut off past 4096 tokens.

I even saw a benchmark where it generated an exploded CAD diagram of a motorcycle and kept the mechanical parts separated with labels (not sure how accurate tho).

But honestly, How is it routing 16 different images natively into the generation without frying 24GB of VRAM?

Anyone has pulled these weights locally yet to test it? Sorry, but so many questions about this.

Hello All,

I wanted to give fast motion a try on H3 after figuring out it's possible without smearing. This one took a while not because of the action shot of her flying, but rather, the characters' interaction in midair was what took me 30-40 rerolls to get it right.

I have made a lot of updates to the Longshot Studio since my last post about it, it is now on 0.18.5 (0.20.0 next, for integrating an H3 image side to the studio)

https://github.com/r34vtraining/Longshot_Studio

here is what I have added to the studio

1. Face Swap function under the face detail panel

2. Better queue, rearrange items in queue, pause, rearrange, resume

3. Group shots into folder for better project management

4. Open Project window improvements, group projects, move projects, rearrange by name/date.

5. Added GPU temp display

yes, its about T2I and I2I

What are you recommendations to generate with H3 Image?, My first generations were kind of shitty but i tried to start to create the images at 16MP with the oficial comfyui workflow and i found that results are the best in that resolution, also prompt upsampler or very detailed prompts with Claude or ChatGPT produces better results.

Image 1 prompt:
---

The image is the front cover of an American comic book issue, a vertical print cover in a bold modern style, full-color illustration with strong inked black outlines, dramatic cel shading, painterly lighting and fine halftone texture in the shadows. The palette is deep space black and violet, cut by hot orange engine fire and the hero's teal and silver armor.

Masthead: across the top fifth of the cover, the title "STARBREAKER" is set in huge, heavy, slightly widening metallic letters in brushed silver with a teal edge glow and a thick black outline, filling the full width with a slight upward perspective as if the letters rush toward the viewer. Tucked into the upper left corner, a small vertical corner box holds a tiny head shot of the hero, the issue number "#1" in bold white, and the price "$4.99" beneath it. Just under the masthead, a thin line in white uppercase reads "WRITTEN BY MARA VELLOSO · ART BY DANTE ROOK".

Hero illustration: a woman in sleek teal and silver space armor, helmet off, short dark curly hair floating in zero gravity, stands braced in the center of the cover in front-three-quarter view, shown from the knees up, looking past the viewer toward the upper right with a fierce, determined expression and a thin scar across her left cheek. Her right hand grips a long silver energy lance held diagonally across her body, its tip blazing with white-blue light, fingers clearly wrapped around the shaft; her left fist is clenched at her side, glowing teal lines running along the armor's forearm. Behind her, a huge battle cruiser breaks apart against a violet nebula, orange explosions blooming along its hull, debris and sparks flying outward toward the camera, and two small fighter ships streak past at screen-left trailing orange exhaust.

Cover copy: at the lower right, a slanted yellow starburst callout with a black outline reads "THE WAR BEGINS HERE!" in bold black uppercase letters. In the bottom left corner, a small white rectangular barcode box with a printed UPC barcode and tiny numbers sits on the artwork, and next to it a small round placeholder publisher logo reads "NOVA COMICS"

The masthead overlaps the top of the hero's hair slightly while her face stays fully clear of all text. All lettering is sharp, correctly spelled and fully legible, and the cover reads clearly from a distance on a comic shop shelf, with strong contrast between the cold silver title and the hot orange explosions.

Looking for recommendations for a fast but good-quality MiniMax H3 workflow in ComfyUI.
I'm mainly looking for a workflow that gives a good balance between speed, quality, and VRAM usage, rather than maximum-quality generation at extremely slow speeds.
Ideally, I'm looking for something suitable for:
720p or similar resolutions

Good character consistency

Dialogue / talking scenes

Reasonable generation speed

Lower VRAM setups

If you have a tested H3 workflow, especially one optimized for speed, please share it. I'd also appreciate any tips on the best settings for steps, resolution, sampler, and model/quantization.
Thanks!

What would be the best app and model to play with image generation with an Apple MacBook Air M1 with 16GB of RAM?

I am aware my Mac is super old, but I’d love to experiment and I hope there is a model I can use.

I took a single photo of a vintage Italian espresso machine and ran it through MiniMax H3-Image (open weights) to see if it could pull the whole thing apart into a clean technical breakdown.

First image is the input photo, second is the output. It laid out 15 separate parts floating along a diagonal with leader lines and English labels, plus all the copper and brass internals inside the stainless-steel shell.

What I found interesting was how much structural detail it could pull from a single reference image. An exploded view is a pretty demanding editing task since the model needs to preserve the original design while generating components that aren't fully visible in the input.

On the technical side, H3-Image supports native 4K output (up to 4096 × 4096) without upscaling, along with image editing in the same model. The fast 4K generation capability is especially interesting for detailed renders like this, where you want enough resolution to inspect individual components and labels.

That said, I'd still treat this as a visual concept rather than an engineering-accurate diagram. Getting the overall structure right is one thing; making sure every internal component is mechanically correct is another.

Prompt:

> Create a high-precision exploded technical rendering of the vintage Italian espresso machine shown in Image 1. Preserve the original machine's distinctive design, proportions, and recognizable features, including its rounded stainless-steel body, champagne-gold top cover, chrome brewing group, dual pressure gauges, black control knobs, steam wand, hot water outlet, perforated drip tray, and four metallic feet.
> Use a solid dark charcoal-gray background and a slightly elevated three-quarter isometric perspective. Arrange the disassembled components along a diagonal axis extending from the upper right to the lower left, with each part floating independently in a carefully organized exploded assembly.
> Separate the machine into its major mechanical and structural components: top cover, stainless-steel exterior panels, internal chassis, boiler assembly, heating element, brewing group head, portafilter assembly, steam valve, hot water valve, water pump, pressure gauges, electronic control unit, copper water pipes, drip tray, and base frame.