pi-H3: MiniMax H3 videos with sound in just 2 to 4 steps, running locally in ComfyUI

The pi-H3 project makes the MiniMax H3 video model a lot faster. Instead of many sampling steps, two or four are enough, and the final step outputs video frames directly, no VAE decoder needed. According to the developer, a 5-second 480p clip with sound takes about 15 seconds on an RTX 3090.

Tools Try it yourself Nov 21, 2026 6 min read Source: Reddit r/StableDiffusion
Illustrative image, AI-generated

What's going on

The developer behind the GitHub project ComfyUI-piFlow (username Lakonik) has released pi-H3, an accelerated version of the MiniMax H3 video model that generates videos along with matching audio. A diffusion model like this normally needs many sampling steps. Diffusion works an image or video out of noise step by step, a bit like a photo slowly coming into focus. pi-H3 gets by with 2 or 4 steps. On top of that, there's a second shortcut: in the recommended variant, the finished video frames come straight out of the final step, so the usual VAE decoder isn't needed.

The weights are free to download. Everything is built for ComfyUI, the popular interface where you wire AI image generators together from building blocks (nodes) into workflows. The guide and workflow files are on the project page at github.com/Lakonik/ComfyUI-piFlow. The project was announced on the r/StableDiffusion subreddit.

How the speedup works

pi-H3 is a distillation: a large, slow "teacher" model (here, MiniMax H3) teaches a faster "student" to produce nearly the same result in far fewer steps. The name refers to pi-Flow, the method the ComfyUI project is built on. Technically, the result doesn't ship as a standalone model but as an adapter. These extra weights are applied on top of the base model like a LoRA (a small add-on file that modifies an existing model). There's one adapter for 2 steps and one for 4. You pick which one to use with the steps value in the "pi-H3 Adapter" node.

The second innovation is called DWD. The source doesn't explain what the acronym stands for, but it's clear what it does. Video models normally compute in a compressed intermediate format, the so-called latent space. At the end, a VAE decoder has to turn that format back into real images. It's like unzipping a ZIP file, and for long, high-resolution videos it eats up a lot of time and memory. The DWD adapters predict the video frames directly in the final step, so the decoder drops out. The video VAE is then only needed to feed a given first or last frame into the model. For the non-DWD variant there's a separate workflow (pi-H3.json) that decodes through the VAE the traditional way.

What the model can do

It supports the MiniMax H3 FL2VA variant, short for "first-last-frame to video and audio". The model generates a video with synchronized audio from a text description. Optionally, you can provide a start frame, an end frame or both, and the model fills in the motion in between. That lets you animate a photo, for example, or deliberately bridge two scenes. According to the table, clips can be 5, 10 or 15 seconds long at 864x480 or 1344x768 pixels.

Speed, according to the developer

The benchmarks come from the developer and apply to the 2-step DWD workflow. They used the INT8 model with the "ConvRot" quantization method (quantization stores the model's numbers at lower precision so it needs less memory and runs faster) and "Sol sparse attention". Sparse attention is a leaner version of the attention mechanism that doesn't compute every part of the image against every other part. Testing was done on an RTX 3090 with CUDA 13. The card had been "unlocked" with a tool called "gpu-unlock". The developer recommends it, but the source doesn't explain what the tool actually does. The times assume the models are already loaded and the prompt has already been processed:

Resolution 5 s video 10 s video 15 s video
864x480 15.5 s 37.3 s 69.2 s
1344x768 38.5 s 97.6 s 186.1 s

So a 5-second 480p clip with sound takes roughly three times real time, on a graphics card from 2020. The developer calls the DWD workflows "the fastest way to generate MiniMax H3 videos". The source doesn't include independent benchmarks or quality comparisons with the original model.

The files at a glance

You need several files, each of which goes into a specific ComfyUI folder:

  • Base model: minimax_h3_fl2va_pruned_int8_convrot.safetensors → models/diffusion_models/ (a "pruned" version, meaning unnecessary parts have been stripped out, in INT8)
  • DWD adapters (recommended): pi_h3_2step_dwd_adapter_int8_convrot.safetensors and pi_h3_4step_dwd_adapter_int8_convrot.safetensors → models/loras/, or alternatively in full precision
  • Non-DWD adapters: pi_h3_2step_adapter and pi_h3_4step_adapter → models/loras/
  • Text encoder: qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors → models/text_encoders/. The text encoder translates your prompt into a form the video model understands. Here it's a Qwen3-VL with 32 billion parameters, compressed to 4 bits (NVFP4, AWQ).
  • VAE: minimax_h3_video_vae_int8_convrot.safetensors and minimax_h3_audio_vae_fp32.safetensors → models/vae/

Just drag the pi-H3-DWD.json or pi-H3.json workflow into the ComfyUI window. When you switch the step count, the adapter node automatically sets the recommended scheduler values: max_raw_t 0.93 for 2 steps, 0.96 for 4 steps, and final_step_size_scale 0.6 in both cases.

What you need to try it

The only hardware the source mentions is an NVIDIA RTX 3090 with 24 GB of VRAM, which was used for all the timings. So treat a card in that class with 24 GB as a realistic starting point. The source doesn't say whether it runs on smaller cards with 12 or 16 GB. You'll also need a recent NVIDIA driver with CUDA 13 and an up-to-date ComfyUI install with the ComfyUI-piFlow extension. Since the 32-billion-parameter text encoder alone and the video model come as several large files, plan for plenty of disk space and a lot of system RAM; something on the order of 32 GB of RAM or more makes sense. The source doesn't give exact numbers. Macs and CPU-only setups aren't mentioned. The workflows are designed for NVIDIA cards.

The bigger picture

pi-H3 is a good example of how the community makes big video models practical on home PCs. Fewer steps, INT8 quantization, sparse attention and dropping the VAE decoder all work together. Skipping the decoder is especially interesting, because that step often becomes the time and memory bottleneck for long, high-resolution videos. And the fact that it generates audio too sets the project apart from many video-only accelerators.

What's still unclear is how much quality the aggressive shortcut costs. In practice, distilled few-step models often lose some detail or variety, and there are no solid comparisons yet. The source also doesn't mention the license for MiniMax H3 or the adapters. If you want to use the output commercially, check that first. The timings come from the developer and assume a specially configured system (unlocked card, CUDA 13, models preloaded). On a standard PC, the first run will likely take considerably longer.

Related videos

Minimax-H3 Just Got Faster! Pi-H3 Fine-Tune, No VAE, 4 Steps Winnougan · YouTube

Sources

#video generation#comfyui#minimax#distillation#audio
Read the original source

Try it yourself: pi-H3 (MiniMax H3 FL2VA, 2/4-Step-Adapter)

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

pi-H3 uses the MiniMax H3 video model to generate short 5-, 10- or 15-second clips with matching audio, in just 2 or 4 steps instead of many. You type a text description and can also provide a start frame, an end frame or both. The model then fills in the motion in between. In the recommended DWD variant, the slow VAE decoder drops out and the frames come straight from the final step. According to the developer, that gets you a 5-second clip at 864x480 in about 15 seconds on an RTX 3090, or just under 40 seconds at 1344x768. Limitations: how much quality suffers compared to the full MiniMax H3 hasn't been independently verified, and the setup, with seven files spread across different folders, takes more work than a simple Ollama model. Compared to the original model, this is mainly about speed, so you can try out lots of ideas quickly.

Who is it worth it for?

Worth it if you already work with ComfyUI, have an NVIDIA card with around 24 GB of VRAM and want to generate videos with sound locally, for social media clips, storyboards or experiments. If you only have a small GPU or a Mac, or you don't feel like tinkering with workflows, you're better off with online video services for now.

Ideas: What you can do with it

Bring photos to life

Load one of your own vacation or family photos as the start frame and describe a gentle motion along with sounds. You get a short clip with audio, like crashing waves or a murmuring crowd, perfect for a birthday slideshow.

Storyboards for short films

Generate a 5-second 480p clip for each scene in your script. Since each clip takes only about 15 seconds, you can try lots of variations and show your team how the camera work and mood should feel.

Social media clips with sound

Describe short, eye-catching scenes like a steaming coffee cup or a skater at sunset, including the audio. The finished 5- to 10-second clips work well as backgrounds for Reels or Shorts.

Transitions between two images

Provide a start and an end frame, for example a room before and after a renovation. The model generates the motion in between, which is handy for presentations or before-and-after videos.

Atmosphere for games and tabletop RPGs

Generate short mood clips for role-playing sessions, like a tavern with a crackling fire and voices. Played on a second screen, they add atmosphere to the table with both picture and sound.

Download11 GB (about 15 min at 100 Mbit/s)
TypeVideo generator

What your computer needs

Graphics card (NVIDIA) at least 6 GB VRAM, recommended 13 GBe.g. RTX 4060 Ti 16 GB, RTX 4080, RTX 5080, RX 7800 XT
Mac (Apple Silicon M1–M5) from 24 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
Storage approx. 13 GB freeModel download plus programs
Google Colab runs for freeThe free Tesla T4 GPU with 15 GB is enough

Which variant is right for me?

Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.

VariantDownloadNeeds approx.Compatible graphics cards
IQ1_S 4.1 GB6 GBe.g. RTX 2060, RTX 3050 8 GB, RX 6600
IQ1_M 4.5 GB6 GBe.g. RTX 2060, RTX 3050 8 GB, RX 6600
UD-IQ1_S Default 11 GB13 GBe.g. RTX 4060 Ti 16 GB, RTX 4080, RTX 5080, RX 7800 XT
UD-IQ1_M 11 GB14 GBe.g. RTX 4060 Ti 16 GB, RTX 4080, RTX 5080, RX 7800 XT

The recommended setup is the pi-H3-DWD.json workflow with the INT8 ConvRot adapters, the same combination used for the speed benchmarks. The 2-step adapter is the fastest; the 4-step adapter is worth it if you want more quality. The full-precision adapters are an alternative if you have enough memory. You only need the non-DWD workflow (pi-H3.json, decoding through the VAE) for comparison or if the DWD variant gives you trouble. To get started, 864x480 at 5 seconds is ideal.

  • All benchmarks in the source come from an NVIDIA RTX 3090 with 24 GB of VRAM. Plan on a card in that class.
  • The developer uses CUDA 13 and recommends unlocking the card with the "gpu-unlock" tool. The source doesn't explain exactly what it does.
  • Higher resolutions and longer clips take a lot more time: according to the developer, 15 seconds at 1344x768 takes about 186 seconds, versus 15.5 seconds for 5 seconds at 480p.
  • On top of the video model, you have to load a 32-billion-parameter text encoder (Qwen3-VL, 4-bit). Expect to need lots of disk space and plenty of system RAM.
  • Macs and CPU-only setups aren't mentioned in the source. The workflows are designed for NVIDIA GPUs.
How do I find out what my computer has?
  • Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
  • Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
  • Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: runs for free – The free Tesla T4 GPU with 15 GB is enough.

  1. Download the notebook. Click the button and save the file.

    Download colab.ipynb

  2. Open Colab. Go to colab.research.google.com and sign in with your Google account.
  3. Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
  4. Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU → Save.
  5. Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
  6. Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 8 minutes here.
  7. Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter.
  8. Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

This model runs on Python. Our script handles the setup automatically: it creates an isolated Python environment, installs the required packages (PyTorch, approx. 3 GB) and downloads the model (11 GB (about 15 min at 100 Mbit/s)).

  1. Update your graphics driver (NVIDIA): install the latest driver. Without an NVIDIA card, it runs on the CPU – much more slowly.
  2. Install Python. Download Python 3.12 from python.org and run the installer. Important: At the bottom of the first window, tick Add python.exe to PATH, then click Install Now.
  3. Create a folder and download the files. Create a folder, e.g. Documents\AI-Test, and save both files into it:

    try_windows.ps1 demo.py

  4. Open a terminal in the folder. Open the folder in File Explorer, right-click an empty spot → Open in Terminal.
  5. Run it. Paste this command and press Enter:
    powershell -ExecutionPolicy Bypass -File try_windows.ps1
    Installation and download are running now. The first time, this can take 10–30 minutes.
  6. Result. The model is in the models subfolder. For exactly how to use it, see the Model Card on Hugging Face.
  7. Try your own input: Open demo.py in an editor, change the sample text, and save. Then run this in the terminal:
    .\.venv-pi-h3-minimax-h3-fl2va-2-4-ste\Scripts\Activate.ps1
    python demo.py

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

  1. Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
  2. Install the developer tools (first time only; includes Python):
    xcode-select --install
    Click Install in the window. If you see "already installed," everything is already in place.
  3. Download the files – both end up in your Downloads folder:

    try_mac.sh demo.py

  4. Run it:
    cd ~/Downloads
    bash try_mac.sh
    The first time, installation and download take 10–30 minutes.
  5. Result. The model is in the models subfolder. For exactly how to use it, see the Model Card on Hugging Face.

Linux

  1. Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
    sudo ubuntu-drivers install
  2. Install the Python basics (Ubuntu/Debian):
    sudo apt update && sudo apt install -y python3-venv python3-pip git
  3. Put the files in a folder and open a terminal there:

    try_linux.sh demo.py

  4. Run it:
    bash try_linux.sh
  5. Result. The model is in the models subfolder. For exactly how to use it, see the Model Card on Hugging Face.

Try it

A cat jumps onto a windowsill and looks out at the rain, with the sound of raindrops hitting the glass.
An old man plays the accordion on a park bench as pigeons flutter up, sunny autumn afternoon, music and birdsong.
Close-up of an espresso machine pouring espresso into a cup, with hissing and gurgling, warm morning light.
(With a beach photo as the start frame) The waves slowly roll onto the beach, a seagull cries, the camera pans gently to the right.
(With start and end frames) Transform the sunny market square from the first image into the illuminated nighttime scene from the last image, with a murmuring crowd and street music starting up.

Tips for better results

  • You only set the step count (2 or 4) in the "pi-H3 Adapter" node. The node automatically sets the matching scheduler values (max_raw_t 0.93 or 0.96, final_step_size_scale 0.6), so don't change them by hand.
  • Test at 864x480 and 5 seconds first until the prompt and motion are right. Then render the ideas that work at 1344x768 or at longer lengths.
  • Describe the audio explicitly in your prompt too (sounds, music, voices), since the model generates audio in sync with the picture.
  • Start and end frames give you the most control. That way you can, for example, link two of your own photos with a transition.
  • If 2 steps look too mushy or jittery, switch to 4 steps. It takes a bit longer but usually gives cleaner results.

If something goes wrong

The files have to go into exactly the right folders: base model in models/diffusion_models, adapters in models/loras, text encoder in models/text_encoders, and both VAEs (video and audio) in models/vae. Otherwise the workflow won't find them.

The ComfyUI-piFlow extension has to be installed. If you see red nodes when loading the workflow, install the missing custom nodes through ComfyUI Manager.

The DWD and non-DWD adapters aren't interchangeable: use the DWD adapters for pi-H3-DWD.json and the regular adapters for pi-H3.json.

The audio VAE (minimax_h3_audio_vae_fp32) is needed in the DWD workflow too. Without it, you get no sound.

The listed times assume the models are already loaded. The first run takes much longer because of loading, and that's normal.

The source doesn't mention the MiniMax H3 license. Check the model page before using it commercially.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

  1. Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.