GenVidKit: Set Up, Run, and Fix MiniMax H3 Local Workflows

Who this MiniMax H3 tutorial is for

This page is for the person who has heard that MiniMax H3 generates video with sound, has a consumer graphics card in the machine under the desk, and wants two answers before spending an evening on it: will it run here, and what do I click first.

It is written for a local ComfyUI install. You do not need to write inference code, fine-tune anything, or understand diffusion schedulers to finish a first clip. You do need about 20GB of free disk for the diffusion weights alone (20,970,379,616 bytes), a graphics card this guide can place in one of three brackets, and considerably more system RAM than most hardware threads suggest.

The order below is the order a first run happens in: what the model is, what has to be on disk, the four-step quickstart, what a first clip actually comes out as, what our own bench measured, how to make a run shorter, the four problems that stop most first attempts, and the license question that decides whether you should be running the weights locally at all.

Two habits save most of the time this page exists to save. Change one thing per run — one resolution, one step count, one launch flag — so that a result means something. And get one short clip to finish before touching quality: a workflow that cannot complete once is not a prompt problem.

Every measured figure below comes from one machine, an RTX 3060 12GB with 47.05 GiB of system RAM running ComfyUI 0.31.0 and PyTorch 2.13.0+cu130. Where a number came from somewhere else, the sentence says so.

What is MiniMax H3?

MiniMax H3 is an open omni-modal video generation model from the MiniMax / Hailuo video family. It is designed to understand mixed context such as text, image, video, and audio, then generate short video with native stereo audio in the same workflow.

For beginners, the most practical way to try MiniMax H3 is through ComfyUI. ComfyUI gives you visual workflow files for text-to-video, image-to-video, and reference-to-video generation, so you do not need to write inference code from scratch.

"Omni-modal" is concrete once you open the template list. The official collection ships three local graphs — video_minimax_h3_t2v.json, video_minimax_h3_i2v.json and video_minimax_h3_r2v.json — and three graphs that call a hosted API instead: api_minimax_h3_t2v.json, api_minimax_h3_flf2v.json and api_minimax_h3_r2v.json. The prefix tells you where the work happens and the suffix tells you what you feed it. The pairing is not symmetrical, so do not go looking for files that were never published: there is no video_minimax_h3_flf2v.json and no api_minimax_h3_i2v.json.

Audio comes out of the same pass as the picture rather than from a second tool. On this bench the short text-to-video and image-to-video checks ran with audio enabled; the reference-to-video check ran with it off. That one switch is worth knowing about before you compare anybody's timings with your own.

One naming rule prevents an hour of confusion at download time. A trailing a marks the diffusion weights: fl2va and ref2va are the large model files, while fl2v and ref2v without the a are the distilled Turbo LoRAs that only change how many steps you sample. They are not interchangeable, and a graph that loads one where it expects the other fails in a way that looks like a broken install.

What has to be on disk before anything runs

A MiniMax H3 graph needs four kinds of file, and ComfyUI looks for each kind in its own folder: the diffusion weights in ComfyUI/models/diffusion_models/, the Qwen3-VL text encoder in ComfyUI/models/text_encoders/, and both the video VAE and the audio VAE in ComfyUI/models/vae/. Nearly every "model not found" on a first attempt is a correct file in the wrong one of those three folders.

Download only the variants the workflow you picked actually loads. The Comfy-Org MiniMax H3 repository is the current file index, and treating it as a shopping list rather than a mirror is the difference between 20GB and most of a terabyte. Each graph's loader nodes tell you what it wants: a UNETLoader for the diffusion weights, a CLIPLoader whose type has to be set to minimax, and two VAELoader nodes, one per VAE.

When a filename on your disk does not match the one in a screenshot, do not rename the file. Open the loader's dropdown and pick the file you actually installed — the graph stores whatever string you choose, and renaming to match a tutorial is how people end up with two copies of a 20GB weight file.

The generated, folder-by-folder version of this list, including which bytes belong to which variant, is the MiniMax H3 ComfyUI setup guide. It takes your card and your chosen variant and prints the file list for that combination instead of the whole catalogue.

MiniMax H3 quickstart

Update ComfyUI

Use a recent ComfyUI build so the MiniMax H3 nodes and workflow templates are available. Restart ComfyUI after updating.

Get the model files

Download the diffusion model, Qwen3-VL text encoder, video VAE, and audio VAE from the Comfy-Org MiniMax H3 repository.

Load a workflow JSON

Import the official T2V or I2V workflow JSON. Beginners should start with T2V because it needs no source image.

Run one short clip

Run one short test clip, check motion and audio, then improve the prompt before increasing resolution or duration.

This quickstart shows the shape of a first run. The complete file list, folder mapping, pinned downloads and fixes live in the ComfyUI guide.

What a first run actually produces

Two things about the output surprise people often enough to be worth stating before you queue anything.

The first is duration. Frames are allocated in blocks of 17, so a requested length snaps to the nearest block that fits it: asking for 5 seconds gives you 124 frames, which is 5.1667 seconds at 24fps, and asking for 10 seconds gives you 243 frames. The clip is therefore slightly longer than the number you typed. That is the model's frame arithmetic, not a bug, and the fix is to trim after download rather than to hunt for a setting.

The second is resolution, which is reported in two places at once. The canvas control ships set to 16:9 at 0.4 MP in multiples of 32, which the template's own size mapping turns into 864 × 480, while the H3 node shows 1344 × 768. Both numbers are real; they describe different points in the graph. Read the node if you want to know what is being rendered.

Short smoke runs are the right first milestone, and they finish in about a minute each. On this bench, with a fixed seed:

• Text-to-video finished in 51.8 s, peaking at 11,625 MiB of VRAM and 42,511 MiB of system RAM, with audio enabled.
• Image-to-video finished in 54.1 s, peaking at 11,689 MiB of VRAM and 42,348 MiB of system RAM, with audio enabled.
• Reference-to-video finished in 55.6 s, peaking at 11,591 MiB of VRAM and 43,176 MiB of system RAM, with audio off.

Notice what those three lines already tell you. The run that takes a minute and the run that takes most of an hour put almost the same pressure on memory — a point the next two sections come back to, because it decides what you should change when something fails.

T2V and I2V in one minute each

Text-to-video

Text-to-video is the easiest MiniMax H3 mode.

Load the T2V workflow, write a prompt that describes the subject, motion, camera, environment, and audio mood, then queue a short generation.

Example T2V prompt

A cinematic close-up of a glass tea cup on a rainy window sill, warm indoor lighting, slow camera push-in, soft reflections, natural steam movement, gentle ambient room tone.

video_minimax_h3_t2v.json

Image-to-video

Image-to-video is best when you want character, product, or composition consistency.

Use a clean starting image, then describe the motion you want instead of rewriting everything in the image.

Example I2V prompt

Animate the portrait into a subtle talking-head video. The person smiles gently, blinks naturally, and turns slightly toward camera. Keep the face identity stable. Quiet studio ambience, soft voice tone.

video_minimax_h3_i2v.json

Where reference-to-video fits

The third local template, R2V, conditions generation on a reference rather than on a single starting frame. It is the one this site's longest runs use, so it is also the one the timings further down describe, and it is the heaviest of the three on system memory.

It is also where the 12GB ceiling shows up first. One community report has the Ref2VA VSA variant running out of memory immediately on a 12GB card, with a streaming-gate build or a 24GB-class card as the way around it. That is somebody else's machine rather than a measurement taken here, which is exactly why it is labelled as a report — but if you are on 12GB, start with the pruned INT8 variant this bench used instead of the VSA one.

Why trust this site

Every number on this page comes from a protocol-compliant run on this site's own test bench: fixed seed, two runs, raw values, failures kept.

1344×768 / 124 frames on our RTX 3060 12GB (two runs each, raw values):

Measured wall times from two runs for each workflow.

Full matrix, every run record, and untested cells marked "not tested": /gpus

Two runs per workload is the whole method, and it is there to catch the thing a single run cannot tell you: whether a number is repeatable. The pairs above differ by well under a percent, which is why the rest of this page is willing to quote them to one decimal place. The 43-minute R2V pair produced a 5.17-second clip at 1344 × 768 with no audio track — useful context for anyone budgeting an afternoon against a shot list.

What those timings mean for your own card

Start with VRAM, because that is the number people check first. The R2V run peaked at 11,649 MiB on a card that has 12,288 MiB, which is 94.8% of it. The T2V pair peaked lower, at 11,023 and 10,863 MiB. So a 12GB card does fit this workload — with nothing at all to spare.

Then look at the number that actually decides whether your machine finishes: system RAM. Peak system RAM on the full run reached 43,587 MiB. A 32GB machine has 32,768 MiB in total, so it is short by roughly 10.6GB before the operating system takes its own share. This is the most common mismatch between what people plan for and what the run needs, and it is why the system requirements checker exists as its own page.

The counter-intuitive part is what happens when you try to fix that by shrinking the output. Between the smallest and largest workloads measured here — a difference of about 40× in pixel-frames — wall time moved by roughly 46×, while peak VRAM moved by 58 MiB (0.5%) and peak system RAM by 411 MiB (1.0%). The memory budget is dominated by resident weights and working buffers, not by output size. Lowering resolution buys time, not memory. Two points are not a curve, and these two do not describe other variants, runs with audio enabled, or outputs large enough to spill out of VRAM — but they are enough to stop you spending an evening lowering resolution to escape an out-of-memory kill.

Brackets are the practical summary. Under 8,192 MiB of VRAM sits the band where the evidence says a run does not finish. From 8,192 to 12,287 MiB is the band where it finishes but is not a production setup — the site's own card lives there. Above that you are mostly buying wall time rather than feasibility. One flag can move a machine between bands on the system-RAM side: with pinned memory off, an RTX 3090 report dropped system RAM use from 29.8GB to 7.5GB. That is a report, not a figure from this bench, and it is the first thing to test if your VRAM looks fine while the machine itself runs out of memory.

Two calculators turn these bands into a number for your own hardware: the VRAM requirement calculator goes from the output you want to the memory it needs, and the GPU benchmark matrix goes from a card to an expected wall time, with every measured row shown next to the estimate.

Three ways to make a run shorter

Forty-three minutes per clip is a real constraint on iteration, so it is worth knowing which levers move it and by how much.

Sample fewer steps with a distilled Turbo LoRA. Three files cover the three tasks: an 8-step v1.0 bf16 LoRA for T2V and I2V at 8 steps, a 4-step v1.0 768p LoRA for the same two tasks at 4 steps, and a ref2v 4-step v0.1 LoRA for R2V at 4 steps. Each expects its own shift value, so read the file's row before wiring it in. On this bench the Turbo path measured 4.113× to 4.132× faster than the same workload without it, which is the largest single lever on this list. The cost is quality: one report describes visible degradation and motion smear at four steps and below, and a separate report describes audio quality suffering, which raising the step count does not address. Details and the full A/B are on the Turbo LoRA page.

Add a caching node. Caching reuses work between steps instead of removing steps. Against a three-run baseline of 596.9, 597.0 and 597.2 seconds on the same load, the candidates measured here came out between 1.336× and 1.937× faster, every ratio taken against the same 597.0-second reference. That is a smaller lever than Turbo, but it does not change your sampler settings. The install notes, the measurements and the maintenance status of each node are on the cache node page.

Render less. Shorter durations and smaller frames finish sooner in almost exact proportion to the pixel-frames removed. Use this to iterate on a prompt, then render the final clip at the size you actually want. Just do not expect it to rescue a machine that is out of memory — see the previous section.

If none of those three make the maths work, the honest fourth option is not to run it locally. MiniMax H3 Max is available as a hosted endpoint (minimax/h3-max/text-to-video and minimax/h3-max/image-to-video) at 480P or 768P for 5 to 15 seconds per request, priced at $0.05 per second of video at 480p and $0.08 at 768p. That works out to $0.25 or $0.40 for a 5-second clip, $0.50 or $0.80 for 10 seconds, and $0.75 or $1.20 for 15 seconds; prompt expansion on the balanced setting adds about a second of latency, and the quality setting can add up to about thirty. The numbers and the caveats are on the hosted H3 Max page. One thing to be clear about: a hosted provider's terms are a separate document from the model's own license, and using an API does not rewrite the license's territory clause.

Common setup problems

Out of memory

Use lighter model variants, lower resolution, shorter duration, or a cloud GPU. Do not debug prompt quality before the workflow can run once.

Missing model

Check folder names exactly: diffusion models, text encoders, and VAEs belong in different ComfyUI model folders.

Weak motion

Add explicit verbs and camera language. “A woman in a cafe” is weaker than “a woman lifts a cup while the camera slowly pushes in”.

Audio mismatch

Describe sound in the same prompt: ambience, dialogue tone, music style, and sound effects. Keep the audio request simple at first.

Two further failure shapes are common enough to name. If each step takes longer than the one before it, watch RAM and swap growth alongside the per-step times rather than changing the prompt — that pattern is about memory, not sampling. And if the whole machine freezes rather than the job failing, the first suspect is system memory and the pinned-memory flag. Test one launch flag at a time; a whole group of them pasted at once tells you nothing about which one helped. On AMD hardware, a hipMemAddressReserve failure is its own diagnostic path through ROCm, Torch, Triton and launch flags rather than a memory problem. Symptom-first walkthroughs for all of these, with the exact first thing to change, are on the troubleshooting page.

License and territory, before you download anything

The weights are openly downloadable, which is not the same as being free to use wherever you are. The MiniMax H3 Community License Agreement is dated August 2, 2026, and it names the EU, the UK, the Republic of Korea and the United States as Excluded Territories; §II points organizations in those territories at MiniMax's own authorization route.

Two details are easy to miss. Running the weights on your own machine is one of the acts the agreement enumerates, so the territory clause is not only about redistributing files. And §V.4 reaches the Outputs as well as the weights, which means generated clips sit under the same clause as the model that made them.

Which downloaded file carries which license is not uniform either. The distilled Turbo LoRAs from the previous section are third-party Apache-2.0 works, while the base weights they accelerate keep the territory clause — so a single folder can hold files under two different licenses. The file-by-file map, with the dates and the hash of the text we read, is on the license page.

This site quotes and links the license rather than advising on it. Read the map and the original agreement for your own situation.

MiniMax H3 frequently asked questions

How much VRAM do I need for MiniMax H3?

Community reports show MiniMax H3 running on GPUs from 8GB to 20GB VRAM, but model precision, frames, resolution, task, cache and system RAM all change what fits. On our own 12GB card the official REF2VA workflow peaked at 11,649 MiB of VRAM, and system memory was the tighter constraint at over 43,000 MiB. See the VRAM requirements guide.

Can I use MiniMax H3 for free?

The weights are openly downloadable, but that does not make local use universally permitted or cost-free. The MiniMax H3 Community License grants use only in its Applicable Territory and names the EU, UK, Republic of Korea and United States as Excluded Territories; §II points organizations in those territories to MiniMax's authorization route. Where your use is permitted, you still pay for hardware, electricity, storage, or cloud GPU rental. This is a source summary, not legal advice.

Does MiniMax H3 support text-to-video and image-to-video?

Yes. The Comfy-Org workflow templates include local T2V and I2V workflows, plus an R2V reference workflow. Start with T2V for the simplest first test.

Does MiniMax H3 support audio generation?

Yes. MiniMax H3 workflows can generate video with native stereo audio, including simple dialogue tone, ambience, music, and sound effects described in the prompt. For the best first result, keep the audio request short and concrete.

How to fix "model not found" error in MiniMax H3?

A model not found error usually means the file is missing, renamed, or placed in the wrong ComfyUI folder. Check that diffusion models are in models/diffusion_models, text encoders are in models/text_encoders, and VAEs are in models/vae, then restart ComfyUI and reload the workflow.

Where can I download the MiniMax H3 workflow JSON?

On the workflows hub — it lists the official T2V, I2V and R2V JSON templates, and each file has its own page with our measured runs.

Can MiniMax H3 run on RTX 3060 / 4090?

Yes. We ran the official reference-to-video workflow twice on our own RTX 3060 12GB and measured about 43 minutes per run for a 1344x768, 124-frame clip, with no Turbo LoRA and no SageAttention. Community reports that use smaller output sizes and acceleration extras describe much shorter times on the same card. See the RTX 3060 test card.

Where to go next

Pick the page that matches the question you still have:

• ComfyUI setup — the file list and folder mapping for your card and variant, plus the smoke test to prove the install.
• Workflows — which template to start with, what has to be on disk first, and the defaults each graph actually sends.
• System requirements — whether your RAM and pagefile clear the bar, flag by flag.
• VRAM requirements — from the output you want to the memory it needs.
• GPU benchmarks — the measured matrix, with untested cells marked as untested.
• Troubleshooting — symptom first, then the one thing to change.
• Turbo LoRAs and cache nodes — the two acceleration paths, measured.
• Hosted H3 Max — endpoints, limits and per-second pricing when local is not the answer.
• RTX 3060 test card — the full environment and output properties behind every number above.
• License map — which file carries which license, and the territory clause in full.