Best MiniMax H3 GGUF Workflow in ComfyUI (Q4_K_M + Q2_K, First/Last Frame, 16 GB, Free JSON)

The first question I get from people with 12 or 16 GB cards is always the same: “Is there a MiniMax H3 GGUF that actually runs in ComfyUI?” There is. I ran H3 on GGUF weights on my RTX 5080 16 GB for a while: a pruned Q4_K_M diffusion model plus a Q2_K text encoder, in a first/last-frame (FL2V) graph. This post is that exact workflow: the files, the nodes, every setting I saved, and the honest part most model cards skip. On my machine GGUF saved a lot of RAM and disk but sampled slower than the int8 safetensors. I’ll show you when that trade is worth making. The workflow JSON is free at the bottom.

Why GGUF for MiniMax H3?

MiniMax H3 generates video with native stereo audio in one pass, up to about 15 seconds at 24 fps. The catch is size. The pruned int8_convrot FL2VA diffusion model alone is about 19.5 GB on disk, more than a 16 GB card holds, and the Qwen3-VL-32B text encoder sits on top of that. ComfyUI streams what doesn’t fit from system RAM, so a single H3 job on my box held around 27 GB of RAM.

GGUF quantization shrinks the files a lot. The pruned Q4_K_M FL2VA file is 11.4 GB and the Q2_K encoder is 8.49 GB, compared with about 19.5 GB and 14.6 GB for the safetensors I normally use. In August my Windows box was sitting at 120 to 145% memory commit with no option to add RAM. Switching to these two GGUF files cut roughly 7.4 GB of committed RAM per ComfyUI instance on the UNet side (11.4 GB vs the 18.8 GB int8 file I was running then), plus about 6 GB on the encoder side. That’s why this workflow exists.

Files and Downloads

Model Files

Sizes are as shown on the Hugging Face file pages.

Loader node	File	Folder	Size
UnetLoaderGGUF	minimax_h3_fl2va_pruned-Q4_K_M.gguf	models/unet	11.4 GB
CLIPLoaderGGUF (type minimax)	qwen3vl-32B-MiniMax-H3-Q2_K.gguf	models/text_encoders	8.49 GB
VAELoader (video)	minimax_h3_video_vae_fp16.safetensors	models/vae	~5.2 GB
VAELoader (audio)	minimax_h3_audio_vae_fp32.safetensors	models/vae	~0.6 GB

Both VAEs come from Comfy-Org/MiniMax-H3. GGUF repos usually don’t include them. Inside the subgraph there’s also a bypassed plain CLIPLoader set to qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors. That’s my fallback encoder. More on why in the measurements section.

Other MiniMax H3 GGUF Repos

These are all community conversions, not official MiniMax releases:

• unsloth/MiniMax-H3-GGUF has pruned FL2VA and Ref2VA rungs from Q2_K (6.26 GiB) up to Q8_0, plus two Qwen3-VL encoders (Q2_K_M 12.20 GiB, Q4_K_M 16.97 GiB). Their minimax_h3_fl2va_pruned-Q4_K.gguf has the same SHA-256 as leejet’s Q4_K_M file, according to modelindex.dev, so don’t download both.
• Abiray/MiniMax-H3-Pruned-GGUF recommends Q4_K_M for 16 GB GPUs and Q5_K_M for 24 GB.
• molbal/MiniMax-H3-GGUF has a U16G mixed quant aimed at 16 GB cards, but it says Q8_CR and U16G need its own ComfyUI-GGUF fork.

Unsloth’s card gives a useful rule: pair the Q2_K_M encoder with the two smallest denoisers and the Q4_K_M encoder with everything else.

Custom Nodes

• ComfyUI-GGUF for UnetLoaderGGUF and CLIPLoaderGGUF. My file was saved with city96’s pack. On my install it threw “Unknown model architecture!” until I added a minimax_h3 entry to the pack’s architecture list in loader.py. leejet’s model card recommends leejet/ComfyUI-GGUF instead, because the city96 repository appears to no longer be actively maintained. If you’re starting fresh, try leejet’s fork first.
• ComfyUI-KJNodes for Resize Image v2 (ImageResizeKJv2).
• ComfyUI-Easy-Use for the easy cleanGpuUsed and easy clearCacheAll nodes.
• ComfyUI Nvidia VFX Nodes (registry name comfyui_nvidia_rtx_nodes) for RTX Video Super Resolution. Its README asks for an NVIDIA RTX GPU and a cu130 or newer PyTorch build.

Everything else, including MiniMaxH3ImageToVideo, ResolutionSelector, ComfyMathExpression and CreateVideo, is core ComfyUI. Update ComfyUI before you load the file.

The Workflow at a Glance

The H3 part lives in one subgraph called Image to Video (MiniMax H3). Outside it are the two input images, the size picker, and the finishing chain.

Load Image 1 -> Resize Image v2 (480x480) -> first_frame
Load Image 2 -> Resize Image v2 (480x480) -> last_frame
ResolutionSelector (9:16 Portrait, 0.2 MP, /32) -> width, height

[Subgraph: Image to Video (MiniMax H3)]
  UnetLoaderGGUF (fl2va_pruned Q4_K_M) -> BasicScheduler (simple, 20, 1.0) + BasicGuider
  CLIPLoaderGGUF (Q2_K, minimax) + video VAE -> MiniMaxH3ImageToVideo
  Float (duration 14) -> ComfyMathExpression -> length
  MiniMaxH3ImageToVideo -> positive -> BasicGuider
                        -> LATENT -> cleanGpuUsed -> clearCacheAll -> SamplerCustomAdvanced
  RandomNoise + KSamplerSelect (res_multistep) -> SamplerCustomAdvanced
  -> cleanGpuUsed -> clearCacheAll -> VAEDecode + VAEDecodeAudio -> CreateVideo (24 fps)

VIDEO -> cleanGpuUsed -> clearCacheAll
      -> Save Video (raw, bypassed)
      -> Get Video Components -> RTX Video Super Resolution (2x, ULTRA)
      -> Create Video (source audio + fps) -> Save Video

There’s no negative prompt and no CFG node, only BasicGuider with the positive conditioning. The raw Save Video is bypassed, so by default you only get the 2x upscaled MP4. Un-bypass it if you want the native-resolution file too.

Settings Table

These are the exact widget values saved in the file:

Node	Setting	Value
UnetLoaderGGUF	unet_name	minimax_h3_fl2va_pruned-Q4_K_M.gguf
CLIPLoaderGGUF	clip_name / type	qwen3vl-32B-MiniMax-H3-Q2_K.gguf / minimax
KSamplerSelect	sampler	res_multistep
BasicScheduler	scheduler / steps / denoise	simple / 20 / 1.0
RandomNoise	control after generate	randomize
Float (duration)	value	14 seconds
ResolutionSelector	aspect / megapixels / multiple	9:16 (Portrait) / 0.2 / 32
Resize Image v2 (both)	size / method / mode	480×480 / nvidia_rtx_vsr / resize, center, divisible by 2, device cpu
CreateVideo (subgraph)	fps	24
RTX Video Super Resolution	resize type / scale / quality	scale by multiplier / 2 / ULTRA
Save Video (final)	prefix / format / codec	video/ComfyUI / auto / auto

The width/height widgets on MiniMaxH3ImageToVideo say 1344×768, but they’re wired from ResolutionSelector, so that value is ignored. Inside the subgraph there’s also the Comfy template’s vaporwave example prompt. It’s overridden too, because the subgraph’s prompt input feeds the node.

Duration, Frames and Size

H3 wants a frame count on a 17k+5 grid at 24 fps. The ComfyMathExpression node converts the duration a into a valid length:

max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17

With the saved 14 seconds that’s 336 frames, rounded up to 345 (17 x 20 + 5). With 5 seconds you get 124 frames.

For size, the canvas note lists 608×352 for 16:9 at 0.2 MP, rounded to multiples of 32. The workflow uses the portrait version of that small size, which is why it’s practical on GGUF at all. After the RTX 2x pass the final MP4 is twice that width and height. If you want a bigger native render, the note’s table goes up to 1920×1088 at 2.0 MP. Every step up costs a lot more time on 16 GB.

Step by Step: First GGUF Render

1. Update ComfyUI and install the custom nodes above. Restart.
2. Download the four model files into the folders in the table, then refresh ComfyUI.
3. Load the workflow by dragging the JSON onto the canvas. If a loader shows red, pick the file again from its dropdown.
4. Set your frames. Load your start image in Load Image 1 and your end image in Load Image 2. My public copy expects first_frame.png and last_frame.png. For single-image animation, disconnect the last_frame input. FL2VA accepts zero, one or two frames.
5. Write the prompt on the subgraph node. Describe the motion between the two frames and the audio in one block. My MiniMax H3 prompt guide explains the timeline format I use.
6. Set the duration. I’d start with 5 seconds for a first test, not the saved 14.
7. Queue. The upscaled MP4 with audio is saved under output/video/.

GGUF vs Safetensors: My Measured Numbers

This is the section I wish someone had written before I downloaded 20 GB of GGUF files. All numbers are from my own ComfyUI logs on the RTX 5080 16 GB, launched with --reserve-vram.

Test	Result
Q4_K_M GGUF UNet vs pruned int8_convrot safetensors, 0.4 MP	35 s/it vs 25 s/it, so int8 sampled about 29% faster
Q4_0 GGUF UNet (molbal) vs int8 in a GGUF container, i2v 81 frames at 1024×1024	333 s became 431 s (+29%)
Q2_K GGUF encoder vs nvfp4_awq safetensors encoder	Sampling went from 7.94 s/it to 12.79 to 15.03 s/it

The reasons were clear in the logs:

• Dequantization costs time. The int8_convrot safetensors use ComfyUI’s native int8 kernels. GGUF weights are dequantized in plain PyTorch on every matmul. H3 sampling is mostly attention work (about 175k latent tokens per step on my jobs), so smaller weights save little time and the dequantization cost dominates. The int8 file won even though, at 19.5 GB, it partly offloads.
• The smaller UNet still didn’t fit. In i2v the 5.2 GB video VAE loads first to encode the frame and stays resident. With --reserve-vram that left only about 8.1 GB usable, so about 3 GB of the GGUF UNet offloaded anyway.
• The GGUF encoder stays in VRAM. The Q2_K encoder loaded onto cuda:0 and stayed there (9586 MB, full load). The UNet went from fully loaded to partly loaded with 1773 MB offloaded. CLIPLoaderGGUF has no device widget, so I couldn’t move the encoder to CPU.

So I switched production back to safetensors on 7 August. These days my main H3 graph runs the even smaller W4A8 model with a 4B encoder. That setup is in my MiniMax H3 image-to-video workflow. GGUF is still the right tool in one case: when system RAM or disk space is what limits you, not speed.

Which Quant Should You Pick?

• 16 GB VRAM and tight system RAM: this workflow (Q4_K_M + Q2_K). It’s the smallest combination that kept full H3 FL2VA with audio running on my card.
• 16 GB VRAM with plenty of RAM: the pruned int8_convrot or W4A8 safetensors with the nvfp4_awq encoder. They were faster in my tests. The Comfy docs also list a pruned_w6a8 build at 16 GB as the smallest official safetensors option (ComfyUI 0.38.0+).
• 12 GB VRAM: a lower rung such as unsloth’s Q3_K or Q2_K, or Abiray’s Q3_K_M, which that card labels for ~12 GB GPUs. I haven’t tested these myself.
• Reference-to-video: use a ref2va_pruned GGUF instead (leejet and unsloth have them), not the FL2VA file.

Memory Tips for 16 GB Cards

• Keep the size small. 0.2 MP portrait plus the RTX 2x upscale gives a usable vertical video without asking H3 for a big latent.
• Don’t expect the cleanup nodes to free RAM. The easy cleanGpuUsed / clearCacheAll pairs clear cached VRAM between stages, but my RAM profiling showed they don’t release the CPU-side copies of the encoder and VAEs during the job. Treat them as VRAM tidying, not a RAM fix.
• Restart between heavy sessions if renders suddenly slow down, and see my MiniMax H3 out of memory guide for 16 GB for more fixes.
• Cut duration, megapixels or steps for speed. Those were the speed levers that actually worked on my box. Smaller weight files weren’t.

Troubleshooting

• “Unknown model architecture!” from the GGUF loader: your ComfyUI-GGUF version doesn’t know H3. Update it, try the leejet fork, or add minimax_h3 to the architecture list as I did.
• The GGUF file doesn’t appear in the loader: put it in models/unet/ and refresh.
• state_dict or vision mismatch from a GGUF text encoder: the joeygambino encoder card explains that stock CLIPLoaderGGUF doesn’t merge Qwen3-VL mmproj sidecars. It recommends the H3 Clip Loader (Any) node from ComfyUI-H3-Multishot. Or un-bypass my nvfp4 CLIPLoader fallback.
• Very slow sampling: check the log for “loaded partially … offloaded”. If the encoder is hogging VRAM, switch to the safetensors encoder.
• RTX Video Super Resolution errors: it needs an RTX card and the nvidia-vfx package. Bypass it and un-bypass the raw Save Video.
• Output doesn’t land on the last frame: make sure you loaded the FL2VA GGUF, not ref2va, and that both images reach the subgraph.

Download the MiniMax H3 GGUF ComfyUI Workflow

The zip contains MiniMax_H3_FL2V_GGUF_Q4KM_Q2K_Workflow.json (ComfyUI UI format, with a subgraph). In this public copy I renamed my two input images to first_frame.png and last_frame.png and replaced my project prompt with a generic 14-second first-to-last-frame example. Every node, link and setting is otherwise the file I ran. Model weights aren’t included (MiniMax H3 Community License).

Download the MiniMax H3 GGUF ComfyUI Workflow (.zip)

What is inside the zip:

• MiniMax_H3_FL2V_GGUF_Q4KM_Q2K_Workflow.json: ComfyUI workflow in the normal canvas (UI) format. Drag it onto the canvas.
• README.txt: model files with download links and folders, custom nodes and setup steps.

Requirements:

• Custom nodes: Nvidia RTX Nodes (RTX Video Super Resolution; needs an RTX GPU and the nvidia-vfx package), ComfyUI-KJNodes, ComfyUI-GGUF (leejet fork, UnetLoaderGGUF / CLIPLoaderGGUF), ComfyUI-Easy-Use (ComfyUI Manager > Install Missing Custom Nodes also finds them).
• minimax_h3_audio_vae_fp32.safetensors in ComfyUI/models/vae/ (download)
• minimax_h3_fl2va_pruned-Q4_K_M.gguf in ComfyUI/models/diffusion_models/ (download)
• minimax_h3_video_vae_fp16.safetensors in ComfyUI/models/vae/ (download)
• qwen3vl-32B-MiniMax-H3-Q2_K.gguf in ComfyUI/models/text_encoders/ (download)
• qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors in ComfyUI/models/text_encoders/ (download)

Model weights are not included. Every node and link in these files was checked against the current ComfyUI source and the node packs listed above.

Frequently Asked Questions

Can MiniMax H3 GGUF run on 12 GB?

Abiray labels its Q3_K_M (8.9 GB) for ~12 GB GPUs, and unsloth has rungs down to 6.26 GiB. I’ve only tested Q4_K_M on 16 GB, so expect heavy offloading on smaller cards, and make sure you have plenty of system RAM.

Does this work for reference-to-video?

Not with this file. Ref2VA is a separate set of weights. Load a ref2va_pruned GGUF and use the reference node instead, as in my MiniMax H3 reference-to-video workflow.

Do I still get audio?

Yes. The audio VAE is loaded and VAEDecodeAudio feeds CreateVideo, and the final Create Video after the upscale carries that audio through.

Can I use Turbo or Acc LoRAs with GGUF?

I haven’t tested LoRAs on this GGUF graph. Keep in mind the Comfy docs say LoRAs distilled on full builds lose their adaln tensors on pruned builds, while Turbo LoRAs without adaln tensors work on either. See my best MiniMax H3 LoRAs post for the options.

Does the Q2_K encoder hurt prompt following?

That was my worry: the nvfp4_awq encoder is activation-aware, and a plain Q2_K has no such protection. I never measured adherence, though, because the speed penalty made me switch back first. If your storyboard beats stop landing on time, try the safetensors encoder.

Final Thoughts

The best MiniMax H3 GGUF setup I’ve run in ComfyUI is the one in this post: leejet’s pruned FL2VA Q4_K_M, the realrebelai Q2_K encoder, 20 steps of res_multistep/simple at a small portrait size, and an RTX 2x upscale at the end. It runs H3 with first/last frames and audio while saving a lot of RAM and disk. Just know the trade: on my RTX 5080 it was slower than the int8 safetensors. Pick GGUF when memory is the wall, and safetensors when speed is.

More H3 guides on FreakyJolly:

• Best MiniMax H3 Image-to-Video Workflow (First/Last Frame)
• Best MiniMax H3 Text-to-Video Workflow for ComfyUI
• Best MiniMax H3 8-Step Acc LoRA Workflow
• MiniMax H3 Out of Memory in ComfyUI: 16 GB Fixes
• Best MiniMax H3 RIFE Workflow: 24 to 72 FPS
• MiniMax H3 Prompt Guide