Best MiniMax H3 Reference-to-Video Workflow for ComfyUI (Consistent Characters, 16 GB, Free JSON)

If you make series content, like a recurring cartoon character or the same mascot every episode, reference-to-video (R2V) is the H3 mode you want. You give H3 one to four reference images, call them <Picture 1>, <Picture 2>… in the prompt, and it keeps that identity while you direct a brand-new shot. Unlike image-to-video, the reference is not the first frame. It’s a casting sheet.

I use R2V for my anime cooking channel and for the character-driven series on my Jolly backend. This post shares my newest R2V graph: 0.8 MP, 6-step Turbo, with a RIFE ×3 + 2× upscale finish to 1080p / 72 fps, all in one ComfyUI workflow. You can download it for free.

Quick answer: what you get

• Weights: H3 ref2va pruned W4A8 (a separate model from the FL2VA one used for t2v/i2v)
• Conditioning: core MiniMaxH3ReferenceToVideo, ref_image_size: match, refs wired into ref_images.ref_image_0…
• Speed chain: Turbo LoRA (1.0) → Sage Attention (auto) → SigmaShift 12/3 → MiniMaxH3TurboSampler + simple / 6 steps
• Encoder: Qwen3-VL-4B INT4 + ClipProj v3.1-mlp in resident mode
• Size: 16:9, 0.8 MP (1216×672), 5 s (124 frames)
• Outputs: two MP4s with synced audio: a raw 24 fps file and a finished 1920×1080 at 72 fps file
• Download: freakyjolly-minimax-h3-r2v-turbo6-1080p72.json

Why this workflow

I have five R2V graphs on my drive. Here’s why this one won:

Workflow	What it is	Verdict
r2v 0.8 MP → 1080p72 (picked)	My newest. Same Turbo chain as my backend’s minimax_h3_r2v builder, plus W4A8 weights, the 4B ClipProj encoder and a finishing branch	Most refined, 16 GB oriented, current model stack
1REF Turbo6 (Extender)	Same W4A8 + ClipProj + Turbo 6-step, but built on the H3 Extender pack for multi-clip films	Great for long films, overkill for one shot
“Deno 8-step turbo R2V – Acc fixed”	Full ref2va int8 + Alibaba Ref2VA-Acc-8Step via Deno nodes, 32B nvfp4 encoder, euler 8 steps	Good quality, needs the 32B encoder and Deno packs
MrPuppy 15 s AllLoRAs	1 MP, 15 s, ref2v turbo 8-step LoRA + 4 style LoRAs via LoraLoaderModelOnly, res_multistep 8 steps	Project-specific LoRA stack
Original video_minimax_h3_r2v	Stock-style 20 steps, res_multistep, 0.4 MP	The baseline everything above replaced

The picked graph shares its sampling chain with what my backend runs for paying users: turbo LoRA → sage → sigma shift → 6 simple steps on ref2va. On top of that it has the lighter weights I moved to after profiling showed that RAM, not GPU count, was my real limit.

Honest caveat from my own README: the finishing branch (RIFE ×3 → NomosUni 2× → Lanczos to 1920×1080) is the same recipe as my separate GPU-finishing script, but here it’s attached directly to the H3 decode. Node classes, inputs and links were checked against two running ComfyUI instances, but I haven’t completed a full combined 1080p72 render of this single-job graph yet (including on the RTX 5080). It’s heavier than my tested two-job pipeline. If VRAM or RAM gets unstable, bypass the finishing nodes and run them as a second job.

Requirements and model downloads

Tested components on my RTX 5080 16 GB (Windows, ComfyUI portable). ComfyUI must be newer than 2026-08-07 for W4A8.

Component	File	Folder	Download
Diffusion model (ref2va, pruned W4A8, ~12.5 GB)	minimax_h3_ref2va_pruned-w4a8_convrot_pruned.safetensors	models/diffusion_models/	Winnougan/MiniMax-H3-INT4_Convrot_ComfyUI
Alternative: official ref2va pruned int8 (~21 GB)	minimax_h3_ref2va_pruned_int8_convrot.safetensors	models/diffusion_models/	Comfy-Org/MiniMax-H3
Text encoder	qwen3vl_4b_int4_convrot.safetensors	models/text_encoders/	Merserk/qwen3vl-4b-int4-convrot
ClipProj	mmh3-4b-ClipProj-v3.1-mlp.safetensors	models/clip_projections/	NicoLab28/ClipProj-MiniMax-H3
Video VAE	minimax_h3_video_vae_int8_convrot.safetensors	models/vae/	Comfy-Org/MiniMax-H3
Audio VAE	minimax_h3_audio_vae_fp32.safetensors	models/vae/	Comfy-Org/MiniMax-H3
Turbo LoRA	minimax_h3_turbo_4step_ema_ckpt500.safetensors	models/loras/	larryvrh/MiniMax-H3-Turbo-Lora
RIFE model	rife47.pth	auto-downloaded by the node	ComfyUI-Frame-Interpolation
Upscaler	2xNomosUni_esrgan_multijpg.pth	models/upscale_models/	OpenModelDB – 2x-NomosUni-esrgan-multijpg

Why a separate model? ref2va and fl2va are different weights. If you point MiniMaxH3ReferenceToVideo at the FL2VA file, it loads and runs, but the reference tokens aren’t what those weights were trained on. Identity is what quietly gets worse. That’s exactly what you don’t want here.

A note on the Turbo LoRA: it was trained on FL2VA. It works on ref2va in my graphs, but if identity ever slips, test with the LoRA off first. The Comfy-Org repo also has an official minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors, and Alibaba publishes a Ref2VA Acc 8-step LoRA. I haven’t compared those ref2v-specific speed LoRAs against the larryvrh Turbo LoRA on ref2va yet.

Install steps

1. Update ComfyUI.
2. Install through ComfyUI-Manager:
   – ComfyUI-MiniMax-H3-Turbo
   – ComfyUI-ClipProj
   – ComfyUI-KJNodes (loader, Sage patch, preview override, VRAM_Debug)
   – ComfyUI-VideoHelperSuite
   – ComfyUI-Easy-Use
   – ComfyUI-Frame-Interpolation (RIFE VFI)
3. Optional: SageAttention. Otherwise set the Sage node to disabled.
4. Download the models and put your reference image in ComfyUI/input/.
5. Restart and drag in freakyjolly-minimax-h3-r2v-turbo6-1080p72.json (a regular canvas workflow).

The workflow, node by node

Node (title)	Setting	Notes
CHANGE ME: one 16:9 reference image (LoadImage)	your_reference_16x9.png	<Picture 1> in the prompt
Resolution Selector	16:9, 0.8 MP, multiple 32 → 1216×672
Float (duration) → Math Expression	5.0 s → 124 frames	17k+5 grid
Diffusion Model Loader KJ	ref2va pruned W4A8, default dtypes, sage disabled
Current H3 4B ClipProj (ClipProjLoader)	4B INT4, auto, v3.1-mlp, cuda:0, resident	Keep resident: ClipProj’s dynamic mode doesn’t support the vision inputs that ref2va needs
MiniMax-H3 Turbo LoRA	strength 1.0, low_vram False
Patch Sage Attention KJ	auto, compile True
Model Preview Override	1024 / 80 / 360 / 8 fps
MiniMax H3 Sigma Shift	video 12, audio 3
MiniMax H3 Reference to Video	prompt, ref_image_size: match	Uses vae + audio_vae. Extra refs: connect more images to the next ref_images slot.
Free resident models after conditioning (VRAM_Debug)	empty_cache, gc, unload_all	Unloads the encoder as soon as conditioning exists
RandomNoise	seed 0 (fixed)
Turbo Sampler + BasicScheduler	simple, 6 steps, denoise 1.0
Basic Guider → SamplerCustomAdvanced	—
Clean VRAM Used → Clear Cache All	—
VAE Decode / VAE Decode Audio	int8 video / fp32 audio
RAW 24 FPS + ASMR (VHS_VideoCombine)	24 fps, h264, crf 17	Raw output
Free VAE before RIFE/upscale (VRAM_Debug)	unload all
RIFE 24 → 72 FPS	rife47.pth, multiplier 3, fast_mode, ensemble, fp16, clear cache every 10 frames
NomosUni 2x → Upscale All Frames	2xNomosUni_esrgan_multijpg.pth
Fit to 1920 x 1080	lanczos, center crop
FINISHED 1080p / 72 FPS + ASMR	72 fps, crf 17, same audio	Finished output

Changes from my private copy: I removed the SpectrumApplyMiniMaxH3 node, which was already enabled: False and did nothing in this graph. I swapped my local bf16 audio VAE for the official fp32 file so everything downloads from public repos, and I flattened the LoRA path.

Prompt tips for consistent characters

The official reference prompt guide is different from the base guide, so read the right one. My rules after many episodes:

1. Give each reference a role. “<Picture 1> is the identity reference only” or “<Picture 2> is the kitchen reference”. Numbering is 1-based, in the order you wire the images.
2. Re-describe the identity in words (hair, eyes, outfit) for the details that matter most. My series prompts start with a subject_definitions: block.
3. Say what must not happen: “exactly two coherent hands”, “no eye contact”, “no captions or watermarks”, “one stable continuous shot”.
4. One action per 5-second clip.
5. A character sheet with several views is fine, but tell H3 it shows one character. Otherwise you can get a collage or twins.

Example 1: my anime cooking shot (the JSON default)

Horizontal 16:9 original anime cooking film. <Picture 1> is the identity and kitchen reference only. Adult Noki candidly prepares makki ki roti and sarson ka saag, eyes on her work, exactly two coherent hands, one stable continuous shot, immediate natural five-second cooking action. No speech, music, cuts, captions, watermarks or eye contact. Synchronized cooking ASMR and quiet rain. She rinses fresh mustard greens in a metal basin and lifts them dripping; no cooked food appears yet.

Example 2: two-character scene (wire two refs)

Hyperrealistic live-action, 16:9. Exactly two adults: the man from <Picture 1> and the woman from <Picture 2>. They walk side by side along a rainy night street, sharing one umbrella, medium tracking shot from the front. Keep both faces and outfits identical to their references. Audio: rain on the umbrella, footsteps on wet pavement, distant traffic. No music, no captions.

Example 3: mascot

<Picture 1> defines the exact identity of the mascot: the same small cream-coloured puppy with floppy ears. Keep him a realistic four-legged puppy. He chases a red ball across a sunny lawn and skids to a stop, low-angle camera following. Audio: paws on grass, happy panting, a bird chirp. No speech.

VRAM and speed tips for 16 GB

• R2V is the heaviest H3 mode. Every reference is VAE-encoded and its tokens go through every sampling step, so cost grows with the number of references, not just resolution. My backend caps refs at 4, and free users get 1 ref and 4 s.
• Drop to 0.4–0.5 MP for the raw render if 0.8 MP is tight, and let the finishing branch do the 1080p.
• Split generation and finishing into two jobs if RAM/VRAM is unstable. That’s my tested pipeline.
• ref_image_size: match keeps reference encodes at the output size. max uses larger references and costs more.
• Keep the VRAM_Debug after conditioning. It frees the encoder before sampling. It also unloads anything else that’s loaded, which is fine in a single-job graph.

Numbers I have:
– Early August, on my 5080 (x16 slot): 9.1 min per R2V job (n=2), vs ~27 min on an x4-slot card. That was the older 20-step graph with the ~21 GB int8 ref2va model, where about 9.2 GB was offloaded and streamed every step. It’s why I moved to W4A8 + Turbo.
– Current graph (raw or full with RIFE + upscale): render time, peak VRAM, and system RAM depend on your GPU and settings. Split generation and finishing if a combined job is unstable.

Troubleshooting

Identity drifts between shots. Make sure you’re on the ref2va model, not FL2VA. Give the reference an explicit role, re-describe key features, and test once with the Turbo LoRA bypassed.

Twins, collages, or extra characters. Say “exactly one/two” and state that a multi-view sheet is a single character.

OOM during RIFE or upscale. The H3 part finished; the finishing branch is what ran out. Lower RIFE clear_cache_after_n_frames, or bypass the finishing nodes and run them as a separate job on the raw MP4.

Stall during text encoding. On one of my GPUs, a SetReserveVRAM node (3 GB) fixed a Qwen encoding stall. It didn’t fix a later sampling stall, so treat it as a workaround, not a cure.

Reference video with no audio fails. If you add a reference video, only connect its soundtrack when the file actually has an audio stream. My backend checks with ffprobe before wiring ref_video_audios.

“lora key not loaded”. Use MiniMaxH3TurboLoRA, not LoraLoaderModelOnly.

Download the workflow

Download the workflow (ZIP with JSON)

It’s a regular ComfyUI canvas workflow. Change the CHANGE ME image, edit the prompt in MiniMax H3 Reference to Video, and queue. It saves two MP4s in ComfyUI/output/video/: MiniMax_H3_r2v_08mp_raw24* and MiniMax_H3_r2v_08mp_upscaled_1080p72*.

FAQ

What’s the difference between MiniMax H3 R2V and I2V?
I2V uses your image as the first frame. R2V uses it as an identity/style reference, so the shot can be completely new while the character stays the same.

How many reference images can I use?
The node accepts more, but I cap it at 4. Each extra reference costs time and memory in every step.

How do I refer to references in the prompt?
<Picture 1>, <Picture 2>… in wiring order, starting at 1.

Can I run MiniMax H3 reference-to-video on 16 GB VRAM?
Yes, with the pruned W4A8 ref2va model and the 4B ClipProj encoder. Lower the megapixels or split off the finishing branch if needed.

Why 72 fps?
RIFE ×3 turns 24 fps into smooth 72 fps for social platforms. The raw 24 fps file is saved too.

Can I add LoRAs?
Yes. Chain extra MiniMaxH3TurboLoRA nodes after the Turbo LoRA (I’ve used realism, camera-motion and physics LoRAs at 0.2–0.4).