Full Disclosure: Running MiniMax H3 Locally on an RTX 4080 — Isn’t Saving That API Money for Ice Cream Worth It?

Let me put the conclusions up front so you don’t have to scroll forever:

• MiniMax H3 now supports native ComfyUI workflows and runs locally;

• On my RTX 4080 16GB, I got it working with the pruned + int8 low-VRAM build — a 10-second video takes about 10 minutes to render;

• However, it’s very picky about model version, directory structure, and ComfyUI version — wrong file, wrong version, and you’ll basically hit an error right away, or it won’t even start;

• The one thing I still haven’t cracked: Chinese speech is unreliable. Even with repeated emphasis on Chinese in the prompt, the output isn’t necessarily in Chinese.

Apparently, learning Chinese isn’t just hard for foreigners — it’s hard for large models too. Remember how early GPT image generation would also garble Chinese text.

1. Hardware

My actual tested setup:

• GPU: NVIDIA GeForce RTX 4080 16GB

• RAM: 32GB

• OS: Windows

• ComfyUI: 0.30.0

• Method: Native MiniMax H3 workflow in ComfyUI

2. Install / Update ComfyUI (version must be ≥ 0.30.0)

Let’s nail down one critical prerequisite right here: for MiniMax H3 to work with the native workflow, your ComfyUI version must be at least 0.30.0 (that’s the version where native H3 support first landed). Below this version, the native nodes won’t even show up — no amount of tinkering will help.

• Fresh install: Download the official build from comfy.org/download, or get Comfy-Org/ComfyUI from GitHub;

• Already installed: Use ComfyUI Manager to update to the latest in one click. Easy.

3. Download the Right Model Files (easiest step to screw up)

Several sets of files live under the name MiniMax H3 — old versions, community plugins, and official native workflows all look similar, but you can’t mix them. For the native workflow, stick strictly to the official set.

The models are hosted in the official Hugging Face repo Comfy-Org/MiniMax-H3. This is the pruned low-VRAM combo I used this time:

A few key points:

• The diffusion model uses the pruned + int8 low-VRAM version — this is exactly what makes it possible on a 4080 16GB. The full bf16 / non-pruned versions are larger and won’t fit in VRAM, so don’t download them.

• This time I did image-to-video, so I only needed the T2V/I2V diffusion model (fl2va); you only need to add the ref2va one if you’re doing reference-to-video (R2V) — otherwise you can save that 19.5 GB.

• The models alone come to 40–60 GB total, so make sure you have enough disk space.

How to download:

• Directly from the web: huggingface.co/Comfy-Org/MiniMax-H3

• Command line (recommended, more reliable):

# Install huggingface_hub
pip install -U huggingface_hub
hf download Comfy-Org/MiniMax-H3 --local-dir ./models_temp
# Then manually move the files to the corresponding directories

Users in China can use a mirror for acceleration: set the environment variable HF_ENDPOINT=https://hf-mirror.com and then run the hf command above; or search ModelScope for MiniMax-H3 / Comfy-Org content.

4. Which Directory to Put the Models In

After downloading, place them in the corresponding ComfyUI directories by purpose. If a directory doesn’t exist, just create one:

ComfyUI/models/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors
ComfyUI/models/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors   # R2V, optional
ComfyUI/models/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
ComfyUI/models/vae/minimax_h3_video_vae_fp16.safetensors
ComfyUI/models/vae/minimax_h3_audio_vae_fp32.safetensors

Put both VAEs (video + audio) in the vae/ directory — don’t split them up.

5. Load a Template and Get a 5-Second Test Running First

Once the models are in place, open ComfyUI and follow this flow:

• On the left, go to Template Library → Video, select one of the MiniMax H3 templates: T2V (text-to-video), I2V (image-to-video), or R2V (reference-to-video), depending on your needs;

• The template may prompt you to download missing models — if you’ve already placed them manually, just skip it;

• Take a quick moment to verify the native nodes are present. You should be able to find these three: MiniMaxH3ImageToVideo, MiniMaxH3ReferenceToVideo, MiniMaxH3SigmaShift, and the files you just downloaded should appear in the loader dropdown. If you don’t see them, go back and check two things: is ComfyUI 0.30.0+, and are the models in the official required directories (nine out of ten “node/file not found” issues come down to these two);

• In the Resolution Selector node, first lower the Megapixels to 0.4–0.5 for a speed test, and start with 5 seconds for the duration;

• Write your prompt → Queue Prompt to run. The output is an MP4 with native stereo audio.

The key is to start small — don’t go all in. MiniMax H3 can run locally, but it’s not a model where you can just pile on parameters freely. As resolution, duration, and shot complexity go up, the time cost grows significantly. Real local measurements:

• 5 seconds at 832×480 preview: about a few minutes;

• 10 seconds: about 10 minutes to render, noticeably slower;

• 1024×576 + 10 seconds + multiple shots: will be very time-consuming locally.

Recommended progression: start with 5 seconds → start at 832×480 → start with first-frame image-to-video → once character and scene are stable, push up to 1024×576 or higher → only then attempt longer durations and complex shot sequences. To put it in one sentence: treat it as a tool for “quick iteration on short clips,” not a “go all-in and render a finished film” tool.

6. The Most Reliable Approach: Create a First Frame First, Then Generate

For video with better character consistency, the most reliable approach isn’t pure text-to-video — it’s pinning down the first frame first:

• Generate a character portrait first;

• Then create a landscape first-frame image;

• Feed that first frame into Image-to-Video.

The most stable result this time came from exactly this path: first fixing a character design for an elementary school student, then making a landscape first-frame image of “riding a bike outside a small shop entrance,” and finally feeding it into MiniMax H3 to generate the video. This was far more stable than pure prompt-based generation, especially in:

• Character outfit consistency;

• The bike not deforming randomly;

• Consistent scene style;

• Controlled starting composition of the shot.

In one sentence: the first-frame image is the anchor for the model — the sturdier the anchor, the less the video drifts.

7. Pitfalls I’ve Stepped In (this section might be more useful than the tutorial itself)

1. Don’t mix model files. The thing most likely to trip you up isn’t parameters — it’s that “everything looks like it’s called H3, but they’re not the same set of files.” Mixing old / community / official native versions together can easily lead to “text encoder structure mismatch,” “model is recognized but won’t run,” “VAE matches but CLIP doesn’t.” The most typical symptom is a shape mismatch error the moment the text encoder loads.

2. Give Windows enough page file. If the page file (virtual memory) is too small, you may get errors directly. Being able to run steadily this time was directly related to enlarging the page file. If you only have 32 GB of RAM and want to run longer videos, never turn off virtual memory.

3. Chinese speech is unreliable (the biggest remaining issue). The prompt explicitly specified Chinese voiceover and a specific line, but local testing showed: sometimes the prompt in the background appears garbled, and sometimes the Chinese speech doesn’t fully follow the requirements — the fact that the visuals come through doesn’t mean the Chinese will be stable. So if your goal is “characters acting + specific Chinese dialogue,” I’d now recommend splitting it up: let MiniMax H3 handle the visuals and motion, and add Chinese voiceover in post-production — much more controllable.

4. A portrait-oriented first frame will skew the video aspect ratio. If the first frame is portrait, even if your output parameters specify 16:9, the result can be forcibly thrown off by the first frame’s composition. I only fixed it later by deliberately creating a true 16:9 landscape first frame — this is very important, don’t take shortcuts.

8. My Honest Assessment After Running It

Honestly, the fact that I could get this whole thing running locally already feels pretty impressive to me.

Pros:

• Video generation with native audio is a fresh experience;

• It can produce character and scene atmosphere;

• Short clip testing is already fun to play with;

• When using a first-frame image for control, stability visibly improves.

The cons are equally real:

• Local inference speed isn’t fast;

• Chinese speech isn’t stable enough;

• Longer durations, more shots, and higher resolutions demand more from the machine;

• To turn it into a “reusable animation production pipeline,” the workflow still needs more polish.

So my current take is: it’s past the “you can only look at demos” stage and can be used for short animation tests; but there’s still a ways to go before “stable batch production of complete short films.” It’s playable, but let’s not mythologize it.

9. If You Also Want to Deploy Locally, Here’s Where to Start

Don’t jump straight into a complex project. The recommended starting order:

• Install / update ComfyUI to 0.30.0+;

• Download the official pruned low-VRAM files (don’t download full bf16);

• Place them in the official required directories;

• Load the MiniMax H3 template from the Template Library, set Megapixels to 0.4–0.5, 5 seconds, 832×480 and get one test run working;

• Make a first-frame image first, and verify character consistency and camera feel;

• Only then take on longer durations, complex shots, and voiceover.

This path is far more stable than going straight for “10 seconds, 15 seconds, heavy voiceover, heavy story.”

Closing

In any case, after getting MiniMax H3 running locally this time, the feeling is clear: it’s no longer a toy that can only show demos — it’s genuinely at the stage where you can start building local workflows and making short animations.

Next, I plan to keep testing these things: dual-character consistency, more stable shot control, local workflow reuse, and alternative approaches to Chinese voiceover. Once I’ve organized more complete results, I’ll share the prompts and workflows together.

And to leave you with a question — about that Chinese voiceover pitfall: if anyone has already reliably achieved “specified Chinese dialogue” locally, please ping me in the comments: is it a prompt technique problem, or is the model simply weak with Chinese? If we can crack this one, the last piece of the puzzle for creating complete Chinese short films locally will be in place.