Best MiniMax H3 RIFE Workflow in ComfyUI: 24 to 72 FPS Frame Interpolation (Free JSON)

MiniMax H3 renders video at 24 fps. That’s the native output frame rate on the model card, and every H3 graph I run in ComfyUI ends with a CreateVideo node set to 24. For cinematic shots that’s fine. For fast action, sword trails, camera whips or slow pans on a big screen, 24 fps can look steppy. Generating more frames with H3 itself costs far more than interpolating them afterwards, so I added a RIFE branch to my reference-to-video workflow that turns the same render into a 72 fps file with the original H3 audio. This post walks through that exact graph: the nodes, every RIFE setting, the frame math, and the heavier 1080p version with an upscaler. The workflow JSON is attached for download.

Why Interpolate MiniMax H3 Instead of Generating More Frames

H3 generates video and stereo audio together in one pass, and the official model card lists its output frame rate as 24 FPS. The ComfyUI node docs describe the length input as a frame count at 24 fps snapped to a 17k+5 grid, with a trained range of roughly 124 to 362 frames. So there’s no “render at 72 fps” switch, and asking for three times the frames would mean three times the sequence length, which is exactly what pushes a 16 GB card into out-of-memory territory.

Frame interpolation solves this differently. H3 renders its normal 24 fps clip, and a small optical-flow model (RIFE) predicts the in-between frames. RIFE is tiny compared with H3 and works on finished RGB frames, so it doesn’t touch the diffusion model, the text encoder or the latent at all. The result is a smoother clip with the same content, the same composition and the same audio.

The honest trade-off: interpolated frames are predictions. On very fast motion, thin objects and things crossing each other (a sword passing through smoke, fingers, hair in wind) RIFE can produce warping or ghosting. Always check the 72 fps file next to the raw 24 fps one, which is why my graph saves both.

Why 72 FPS and Not 60

RIFE VFI multiplies the frame rate by a whole number. With a 24 fps source:

Multiplier	Output fps	Notes
2	48	One new frame between each pair
3	72	Two new frames between each pair, what I use
2.5	60	Not possible directly; needs 5x (120 fps) and then dropping every second frame

With an integer multiplier, every original H3 frame survives untouched and sits exactly on the new timeline. 60 fps from 24 needs a non-integer ratio, so you either interpolate to 120 and drop frames (some community H3 delivery nodes do exactly that) or let a video encoder resample. I prefer the clean 3x. If the platform you’re publishing to doesn’t accept 72 fps, use multiplier = 2 for 48 fps instead and set the second CreateVideo to 48.

What You Need (Nodes and Models)

For the main workflow:

• An up-to-date ComfyUI with the native MiniMax H3 nodes (MiniMaxH3ReferenceToVideo). The official setup is in the ComfyUI MiniMax H3 tutorial.
• ComfyUI-Frame-Interpolation by Fannovel16, which provides the RIFE VFI node. Install it from ComfyUI Manager. The node downloads the selected RIFE checkpoint (rife47.pth in my graph) on first use.
• The H3 models from Comfy-Org/MiniMax-H3, sizes as listed in the official template note:

Folder	File	Size
diffusion_models	minimax_h3_ref2va_pruned_int8_convrot.safetensors	19.53 GB
text_encoders	qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors	14.61 GB
vae	minimax_h3_video_vae_int8_convrot.safetensors	2.62 GB
vae	minimax_h3_audio_vae_fp32.safetensors	577.2 MB
loras (optional)	minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors	1.82 GB

For the 1080p version you also need KJNodes (for VRAM_Debug), VideoHelperSuite (for VHS_VideoCombine) and the 2xNomosUni_esrgan_multijpg upscaler by Philip Hofmann (CC BY 4.0) in models/upscale_models.

The Workflow at a Glance

My base graph is the official H3 reference-to-video template with a few switches added. The RIFE part is just three extra nodes hanging off the existing decode:

SamplerCustomAdvanced (LATENT)
 ├─ VAEDecode ──────┬─ CreateVideo (24 fps) ── SaveVideo  video/MiniMax_H3
 │                  └─ RIFE VFI (x3) ─┐
 └─ VAEDecodeAudio ─┬─ (24 fps video) │
                    └─────────────────┴─ CreateVideo (72 fps) ── SaveVideo  video/MiniMax_H3_RIFE72

The key detail is that both CreateVideo nodes get the same audio from VAEDecodeAudio. Nothing upstream changes, so you can drop this branch into any H3 graph (text-to-video, image-to-video, first/last frame) as long as you have a decoded IMAGE batch and the decoded AUDIO.

H3 Generation Settings in My Graph

These are the values saved in my video_minimax_h3_r2v_RIFE72.json:

Node	Setting
UNETLoader	A pruned int8 ref2va checkpoint, weight dtype default (the download uses the official minimax_h3_ref2va_pruned_int8_convrot file)
CLIPLoader	qwen3vl_32b_minimax_h3_nvfp4_awq, type minimax
KSamplerSelect	res_multistep
BasicScheduler	simple, steps from the switch, denoise 1.0
BasicGuider	Conditioning from MiniMaxH3ReferenceToVideo
Steps switch	20 steps (full), or 4 steps when “Enable Lightning LoRA” is on; off by default
LoraLoaderModelOnly	4-step turbo LoRA, strength 1.0, only used when the switch is on
ResolutionSelector	9:16 portrait, 1.0 MP, multiple of 32
Duration	15 seconds in my file (5 seconds in the download), converted to frames by a ComfyMathExpression
MiniMaxH3ReferenceToVideo	ref_image_size = match
CreateVideo (raw)	24 fps

Two notes from the official template that’s embedded in the graph: match scales references down to the generation resolution (faster), while max keeps up to a 2048 px short edge for stronger identity, and the template says beta or normal schedulers tend to beat simple for reference-heavy prompts. I kept simple because the turbo LoRA is meant for it.

The duration expression is the same one I use in all my H3 graphs:

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

It rounds seconds to 24 fps frames and snaps up to the next 17k+5 value. For prompting rules around these durations, see my MiniMax H3 prompt guide.

RIFE VFI Settings Explained

Here are the nine widget values on my RIFE VFI node, in order, and what each one does according to the node’s source code:

Input	My value	What it does
ckpt_name	rife47.pth	RIFE 4.7 weights. The node also lists rife49, rife417 and rife426.
clear_cache_after_n_frames	10	Empties the CUDA cache after every 10 frame pairs. Lower is safer on memory but slower.
multiplier	3	24 fps becomes 72 fps.
fast_mode	false	The README notes it does nothing from RIFE 4.5 onward, so it doesn’t matter for rife47.
ensemble	true	RIFE ensemble inference, on by default. The node turns it off automatically for 4.26.
scale_factor	1.0	The default scale. The node also offers 0.25, 0.5, 2.0 and 4.0.
dtype	float32	Safest precision. The source says float16 uses about half the VRAM.
torch_compile	false	Off by default. When on, the first run is slow while it compiles, and the source says to disable it if you hit errors.
batch_size	1	One interpolated frame per GPU call, the most conservative option.

In the heavier 1080p graph I switch dtype to float16 and fast_mode to true (no effect on rife47, as noted above). Everything else stays the same. I haven’t tried the newer RIFE 4.26 in this graph, so I’m not going to claim it’s better or worse for H3 footage.

Audio Sync and the Frame Math

RIFE doesn’t output exactly three times the frames. It keeps every original frame and inserts multiplier - 1 new frames between each pair, so the count is (frames - 1) x 3 + 1. Working that through for H3’s grid:

Duration typed	H3 frames (24 fps)	Raw length	RIFE frames	Length at 72 fps
5 s	124	5.17 s	370	5.14 s
8 s	192	8.00 s	574	7.97 s
15 s	362	15.08 s	1084	15.06 s

The 72 fps video ends two interpolated frames (about 0.03 s) earlier than the 24 fps one. That’s far below anything you’d notice as lip-sync drift, so it’s safe to mux the original H3 audio straight into the 72 fps CreateVideo. In the VHS version I leave trim_to_audio off, so nothing gets cut to match.

How I Patched My Existing Workflow With a Script

I didn’t rebuild the graph by hand. I wrote a small Python script, update_h3_rife72_workflow.py, that loads my existing H3 R2V workflow, copies the RIFE VFI node from my 1080p template, and wires in the three new nodes. The important part is that it asserts nothing else changed:

rife['widgets_values'] = ['rife47.pth', 10, 3, False, True, 1.0, 'float32', False, 1]
create['widgets_values'][0] = 72          # second CreateVideo at 72 fps
save['widgets_values'][0] = 'video/MiniMax_H3_RIFE72'

workflow['links'].extend([
    [292, 122, 0, 147, 0, 'IMAGE'],   # VAEDecode   -> RIFE VFI
    [293, 147, 0, 148, 0, 'IMAGE'],   # RIFE VFI    -> CreateVideo 72
    [294, 121, 0, 148, 1, 'AUDIO'],   # VAEDecodeAudio -> CreateVideo 72
    [295, 148, 0, 149, 0, 'VIDEO'],   # CreateVideo 72 -> SaveVideo
])

# every original node except the two decoders must be identical
for node in original['nodes']:
    if node['id'] not in (121, 122):
        assert indexed[node['id']] == node
assert indexed[130]['widgets_values'][0] == 24
assert create['widgets_values'][0] == 24 * rife['widgets_values'][2]

The last assertion is the one I like most: the 72 fps value is checked against 24 x multiplier, so if I ever change the multiplier to 2 and forget the fps, the script fails instead of writing a video that plays at the wrong speed. The script also checks that every link ID appears on both ends. The patched graph ends up with 30 nodes and 35 links.

The 1080p 72 FPS Version With NomosUni Upscale

For my anime cooking clips I wanted a finished 1920×1080 file straight out of ComfyUI. That graph (minimax_h3_r2v_08mp_1080p72_comfyui.json) generates at 16:9, 0.8 MP (1216×672 according to the size table in the template), 5 seconds, and then runs this finishing chain:

1. VRAM_Debug “Free VAE before RIFE/upscale” with empty cache, gc collect and unload all models on.
2. RIFE VFI: rife47, multiplier 3, float16.
3. UpscaleModelLoader + ImageUpscaleWithModel with 2xNomosUni_esrgan_multijpg.pth on all interpolated frames.
4. ImageScale: Lanczos to 1920×1080 with crop = center. 1216×672 is slightly wider than 16:9, so a thin strip is trimmed from the sides rather than stretching.
5. VHS_VideoCombine at 72 fps, video/h264-mp4, yuv420p, CRF 17, with the H3 audio.

A second VHS_VideoCombine saves the raw 24 fps clip with audio as well, so I always have the untouched render.

The generation side of this graph is my lighter turbo setup: DiffusionModelLoaderKJ with a pruned w4a8 convrot ref2va model, the MiniMaxH3TurboLoRA (4-step EMA checkpoint, strength 1.0, low_vram off) with MiniMaxH3TurboSampler, BasicScheduler simple at 6 steps, MiniMaxH3SigmaShift at 12.0 video and 3.0 audio, KJ Sage attention on auto, and a VRAM_Debug right after conditioning to flush the text encoder before sampling. The turbo nodes come from ComfyUI-MiniMax-H3-Turbo, whose README says 4 steps is the minimum and 4 to 8 is the useful range, with the scheduler kept on simple.

One honest warning I wrote into the README for this graph: the finishing branch is joined directly to the H3 decode, so this single-job graph is heavier than my two-job pipeline (generate first, finish in a separate run), and I haven’t completed a full combined render with it yet. Node classes, inputs, model names and links were checked against both of my running ComfyUI instances. If RAM or VRAM gets unstable, split it into two jobs.

Memory Tips for 16 GB Cards

RIFE itself is light on VRAM. The pressure comes from where frames live. ComfyUI keeps IMAGE batches as float32, so every frame costs width x height x 3 x 4 bytes of system RAM. By that arithmetic:

• A 1216×672 frame is about 9.8 MB, so 370 RIFE frames for a 5-second clip are about 3.6 GB.
• After the 2x NomosUni upscale (2432×1344) the same 370 frames are about 14.5 GB.
• After scaling to 1920×1080 they’re about 9.2 GB, and both batches can be in memory at the same time.
• A 15-second clip at roughly 1 MP becomes 1084 frames after RIFE, which is around 13 GB before any upscaling.

That’s why the single-job 1080p graph is heavier, and why the order matters. What I do:

• Interpolate before upscaling only if you have the RAM. Upscaling 124 frames is cheaper than upscaling 370. If RAM is short, run RIFE in a second job on the saved 24 fps MP4.
• Flush the VAE and H3 before RIFE. The VRAM_Debug node with unload all models gives the finishing chain a clean GPU.
• Keep clear_cache_after_n_frames at 10 or lower and batch_size at 1.
• Use float16 RIFE if VRAM is the limit.
• Keep clips around 5 seconds when chaining an upscaler.

If H3 itself crashes before you ever reach RIFE, my MiniMax H3 out of memory fixes for 16 GB cover the text encoding, sampling and decode stages.

Alternative: ComfyUI’s Native Frame Interpolate Node

ComfyUI now has built-in interpolation nodes: Load Frame Interpolation Model (FrameInterpolationModelLoader) and Run Frame Interpolation Model (FrameInterpolate). Models go in ComfyUI/models/frame_interpolation/, and the repackaged files at Comfy-Org/frame_interpolation include film_net_fp16, rife_v4.25 (plus heavy and lite) and rife_v4.26 (plus heavy). According to the node docs, the multiplier goes from 2 to 16 and the output is (input frames - 1) x multiplier + 1, the same math as above.

To use it here, replace RIFE VFI with those two nodes, set the multiplier to 3 and keep the second CreateVideo at 72. My graphs use the Fannovel16 node, which exposes the cache, precision and batch controls I described above. I haven’t compared the two on the same H3 clip, so I can’t tell you which looks better.

Download the Workflow

The download attached below is a cleaned copy of my video_minimax_h3_r2v_RIFE72.json. Changes from my local file: the model loader points to the official minimax_h3_ref2va_pruned_int8_convrot.safetensors, the optional LoRA points to the official minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors, the duration is set to 5 seconds, and the prompt is a short example in the official reference format. All RIFE settings are exactly as described in this post.

Download the MiniMax H3 RIFE 72 fps ComfyUI workflow (.zip)

After loading it: check the four model loaders, write your prompt in the “Input Text (Prompt)” node, connect a reference image to ref_images if you want one (and mention it as <Picture 1>), and queue. You’ll get two files in ComfyUI/output/video/: MiniMax_H3_* at 24 fps and MiniMax_H3_RIFE72_* at 72 fps.

Frequently Asked Questions

What frame rate does MiniMax H3 generate?

24 fps. The official MiniMax-H3 model card lists 24 FPS output with 32 kHz stereo audio, and the ComfyUI H3 nodes measure length in 24 fps frames.

Does RIFE interpolation break H3’s audio sync?

No, as long as you feed the original VAEDecodeAudio output into the 72 fps CreateVideo. The interpolated clip is only about two 72 fps frames shorter than the original, so the audio lines up.

Can I get 60 fps instead of 72?

Not with a single integer multiplier from 24 fps. Either interpolate 5x to 120 fps and drop every second frame, or use 2x for 48 fps. I use 3x for 72 because every original frame is kept.

Does this work with H3 text-to-video and image-to-video?

Yes. The RIFE branch only needs the decoded frames and audio, so it attaches the same way after VAEDecode in my text-to-video and image-to-video workflows.

Should I upscale before or after interpolation?

My 1080p graph interpolates first and then upscales, which means the upscaler processes three times as many frames. Upscaling first makes RIFE work on bigger frames instead. Either way it’s heavy on RAM, so on a 16 GB GPU system I’d run the finishing steps as a separate job.

Why do some interpolated frames look warped?

RIFE estimates motion between two frames. Very fast movement, thin objects and overlapping layers like smoke, hair or sword trails are the hardest cases. Compare the 72 fps file against the raw 24 fps one, and keep the 24 fps version for shots where interpolation looks wrong.

Final Thoughts

Adding RIFE to MiniMax H3 is one of the cheapest upgrades you can make to a local H3 workflow. H3 does the expensive work once at 24 fps, three small nodes turn it into 72 fps, and the generated audio carries over unchanged. Keep the raw 24 fps file, check fast-motion shots for artifacts, and split the upscale into its own job if memory gets tight.

More H3 guides on FreakyJolly:

• Best MiniMax H3 Reference-to-Video Workflow for ComfyUI
• Best MiniMax H3 Text-to-Video Workflow for ComfyUI
• Best MiniMax H3 Image-to-Video Workflow (First/Last Frame)
• MiniMax H3 Prompt Guide
• MiniMax H3 Out of Memory in ComfyUI: 16 GB Fixes