Best MiniMax H3 8-Step Acc LoRA Workflow in ComfyUI (Ref2VA and FL2VA, 16 GB, Free JSON)

MiniMax H3 gives me the best reference-to-video results I’ve had locally, but at full step counts every render on my RTX 5080 16 GB takes a long time, because the model doesn’t fit in VRAM and weights keep streaming from system RAM. So when Alibaba PAI released official MiniMax H3 Acc LoRAs that sample in only 8 steps, I rebuilt my Ref2VA graph around them. This post is the exact ComfyUI workflow I use now: which files to download, how the 8-step Acc LoRA gets loaded (it isn’t a normal LoRA), every setting in the graph, and the optional upscale and RIFE passes at the end. The workflow JSON is free to download at the bottom.

TL;DR

Alibaba PAI’s MiniMax-H3-Acc-LoRAs repo has two official 8-step files: MiniMax-H3-FL2VA-Acc-8Step.safetensors and MiniMax-H3-Ref2VA-Acc-8Step.safetensors. They’re trained with Parallel Decoding Distillation (PDD).
They aren’t plain LoRAs. Besides the low-rank updates they add 32 time-dependent output heads, so I load them with the (Deno) MiniMax H3 Acc LoRA Loader from the Deno Custom Nodes pack instead of the stock LoRA loader.
My sampling lane: KSamplerSelect euler, BasicScheduler simple, 8 steps, denoise 1.0, BasicGuider (no negative prompt), LoRA strength 1.0, sigma shifts left at 12.0 / 3.0.
Model: the full minimax_h3_ref2va_int8_convrot checkpoint, Qwen3-VL nvfp4 text encoder, 0.5 MP 16:9 (960×544), 5 seconds = 124 frames, saved at 24 fps.
Optional bypassed tail: NVIDIA RTX VFX Deblur + RealESR AnimeVideo v3 upscale, and RIFE 24 to 60 fps, both run on the saved MP4.

What the MiniMax H3 Acc LoRAs Are

The Acc LoRAs come from Alibaba PAI, the team behind VideoX-Fun. Their model card says they applied Parallel Decoding Distillation (PDD) (Neta Shaul et al., arXiv 2607.26004) to MiniMax-H3, “enabling efficient video generation in only a few inference steps.” Both files are described as official 8-step Acc LoRAs with rank=64 and network_alpha=64 in BF16, one for each H3 task:

FL2VA: first/last-frame to video with audio. The repo’s own text-to-video example script also uses this file, because H3’s t2va mode runs on the fl2va weights.
Ref2VA: reference-to-video with audio, the mode I use for consistent characters.

The repo’s minimax_h3_pdd.py adapter explains the trick. PDD “is not a PEFT LoRA”: the backbone gets low-rank updates, but the video and audio output heads are repeated once per interval of a 32-step grid, and each step fuses a block of 4 heads into one Euler velocity. 32 / 4 = 8 transformer evaluations, hence “8-Step”. The released scheduler shifts are 12.0 (video) and 3.0 (audio).

Files and Downloads

Model Files

Everything except the Acc LoRA comes from the Comfy-Org/MiniMax-H3 repackage. File sizes are from the Hugging Face file listings.

Loader node	File	Folder	Size
`UNETLoader`	`minimax_h3_ref2va_int8_convrot.safetensors`	models/diffusion_models	~34.0 GB
`(Deno) MiniMax H3 Acc LoRA Loader`	`MiniMax-H3-Ref2VA-Acc-8Step.safetensors`	models/loras	~1.37 GB
`CLIPLoader` (type `minimax`)	`qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors`	models/text_encoders	~15.7 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

Two notes from the Comfy-Org model card: prefer the int8_convrot diffusion models if your PyTorch is a cu130 build (use fp8_scaled only if you can’t), and the nvfp4 text encoder does not require a Blackwell GPU. For the FL2VA version, swap in minimax_h3_fl2va_int8_convrot.safetensors and MiniMax-H3-FL2VA-Acc-8Step.safetensors.

Why the full int8 file and not the smaller pruned one? See the pruned checkpoint FAQ.

Custom Nodes

Deno Custom Nodes (deno-custom-nodes, GPL-3.0). Install it from ComfyUI Manager by searching “Deno Custom Nodes”. It provides the Acc LoRA Loader, (Deno) MiniMax H3 Multi Reference Image Loader, (Deno) MiniMax H3 Reference to Video, (Deno) Prompt Text, (Deno) Resize Box and (Deno) RTX Video Super Resolution. Its README says the H3 nodes need ComfyUI 0.30.0 or newer.
ComfyUI-KJNodes for Patch Sage Attention KJ (you also need the SageAttention Python package installed).
ComfyUI-VideoHelperSuite for Video Combine and Load Video.
GACLove/ComfyUI-VFI for RIFE Frame Interpolation, only if you use the optional tail.

Why Not the Stock LoRA Loader?

My first instinct was LoraLoaderModelOnly, but based on the adapter code I don’t think it can work properly: a normal LoRA loader merges low-rank deltas and knows nothing about swapping in 32 per-interval heads or arming a different block before each step. The official Quick Start doesn’t use ComfyUI at all. It runs predict_ref2v.py or predict_t2v.py on Diffusers’ MiniMax-H3 ModularPipeline (diffusers >= 0.40.0), calling apply_pdd_lora to inject the LoRA and heads.

The Deno loader brings that into ComfyUI. Its README says it “applies the static LoRA weights and the checkpoint’s 32 time-dependent PDD output heads”, and at sampling time it “reads the actual sigma boundaries supplied by ComfyUI and automatically fuses the PDD heads for those intervals.” So sampler, scheduler and steps stay in stock nodes.

The Workflow at a Glance

The canvas has four groups: Models, Generate, # Step1 (Upscale) and # Step 2 (Frame interpolation). The last two are bypassed by default.

UNETLoader (ref2va int8_convrot) -> (Deno) MiniMax H3 Acc LoRA Loader (Ref2VA-Acc-8Step)
        |-> Patch Sage Attention KJ (auto) -> BasicScheduler (simple, 8, 1.0) -> SIGMAS
        |-> BasicGuider <- positive conditioning

CLIPLoader (qwen3vl nvfp4, minimax) + video VAE + audio VAE
(Deno) Multi Reference Image Loader -> ref_images
(Deno) Prompt Text -> prompt
(Deno) Resize Box (16:9, 0.5 MP, /32) -> width, height
Seconds (5) -> ComfyMathExpression -> length
        -> (Deno) MiniMax H3 Reference to Video -> positive + LATENT

RandomNoise + BasicGuider + KSamplerSelect (euler) + SIGMAS + LATENT
        -> SamplerCustomAdvanced -> VAEDecode (video) + VAEDecodeAudio (audio)
        -> Video Combine (24 fps, h264, crf 15)

Note the wiring: the Sage Attention patch only feeds BasicScheduler, while BasicGuider takes the model straight from the Acc loader. That’s how my file is saved.

Settings Table

These are the exact widget values in my saved workflow:

Node	Setting	Value
`UNETLoader`	unet / weight dtype	`minimax_h3_ref2va_int8_convrot` / default
Acc LoRA Loader	lora	`MiniMax-H3-Ref2VA-Acc-8Step.safetensors` (strength fixed at 1.0)
`CLIPLoader`	type / device	`minimax` / default
`Patch Sage Attention KJ`	sage_attention / allow_compile	`auto` / false
`KSamplerSelect`	sampler	`euler`
`BasicScheduler`	scheduler / steps / denoise	`simple` / 8 / 1.0
`BasicGuider`	guidance	No CFG node, no negative prompt
`RandomNoise`	control after generate	randomize
`(Deno) Resize Box`	mode / ratio / megapixels / divisible by	Preset Ratio / 16:9 / 0.5 / 32, Center Crop (Fill), lanczos
Reference to Video	width x height	Wired from Resize Box (960×544 at 0.5 MP). The 1344×768 widget value is overridden.
Reference to Video	length / ref_image_size	Wired from the expression (124 for 5 s) / `match`
`Seconds` (PrimitiveFloat)	value	5
`Video Combine`	fps / format / crf	24 / `video/h264-mp4`, yuv420p / 15

The Deno README gives the official recommendation as BasicScheduler: simple, steps: 8 with KSamplerSelect: euler into SamplerCustomAdvanced. It also says to keep the native H3 video/audio sigma shifts at 12.0 / 3.0 and the LoRA strength at 1.0. The Comfy template note on the canvas suggests res_multistep with beta/normal; that’s for full-step ref2va, not the Acc LoRA.

A size note on the canvas lists 16:9 outputs: 0.5 MP = 960×544, 0.98 MP = 1344×768, 1.5 MP = 1664×928, 2.0 MP = 1920×1088. I test at 0.5 MP and go up once I like the motion.

The Seconds to Frames Expression

H3 needs a frame count on a 17k+5 grid at 24 fps. Instead of working that out by hand, a ComfyMathExpression node turns the Seconds value a into a valid length:

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

It converts seconds to frames (minimum 5) and rounds up to the next 17k+5 value:

5 s: 120 frames, rounded up to 124
10 s: 240 frames, rounded up to 243 (the same length the official predict_ref2v.py uses)
15 s: 360 frames, rounded up to 362

Step by Step: Your First 8-Step Render

Update ComfyUI (0.30.0+), install the custom nodes above and restart.
Download the models into the folders in the table. The Acc LoRA can go in models/loras/ or a dedicated models/minimax_h3_acc_loras/ folder, as the Deno README describes.
Load the workflow by dragging the JSON onto the canvas. Re-select the LoRA if it shows red.
Add your references in the Multi Reference Image Loader. My file expects two placeholders, reference_1.png and reference_2.png. Up to 9 images; order defines the tags <Picture 1>, <Picture 2> and so on.
Write the prompt in the Main prompt (manual) node. I ship a 5-second two-character example. Ref2VA is sensitive to wording, so name the tags exactly. My MiniMax H3 prompt guide covers the structure in detail.
Set Seconds (start with 5) and the megapixels in Resize Box (start with 0.5).
Queue. The MP4 with synced H3 audio is saved under output/minimax_h3_acc_8step/.

New to the reference mode? My MiniMax H3 reference-to-video workflow explains the inputs at full steps.

Using the FL2VA Acc LoRA Instead

The downloadable graph is Ref2VA. For first/last-frame (or text-to-video) work, the Deno README is clear: use the FL2VA Acc LoRA for FL2VA and T2VA, and the Ref2VA one for Ref2VA. Each LoRA must match its base model. To convert:

Change UNETLoader to minimax_h3_fl2va_int8_convrot.safetensors.
Select MiniMax-H3-FL2VA-Acc-8Step.safetensors in the Acc LoRA Loader.
Replace the Reference to Video conditioning with the first/last-frame conditioning from my H3 image-to-video workflow or the text-to-video workflow.
Keep the same sampling lane: euler, simple, 8 steps, BasicGuider.

Memory Notes for 16 GB Cards

The ref2va int8 checkpoint is about 34 GB and the text encoder about 15.7 GB, so nothing here fits in 16 GB of VRAM at once. ComfyUI offloads to system RAM, so have plenty. The Acc LoRA doesn’t shrink the model; it cuts how many times it runs. What helps me:

Stay small while testing. 0.5 MP and 5 seconds keep the token count down.
Keep ref_image_size on match. Per the canvas note, max (up to 2048 px short edge) gives stronger identity but is slower, since reference tokens ride along every step.
Reserve VRAM. Adding SetReserveVRAM in front of the text encoder path helped me get past a text-encoding stall on long H3 jobs. More fixes in my MiniMax H3 out of memory guide for 16 GB.
Release the text encoder after encoding. The Deno pack also has a text-encoder VRAM unload node. It creates headroom only.
Sage Attention is optional. Bypass the KJ patch if your SageAttention install isn’t working.

I don’t have a clean measured timing for this exact graph on my card yet, so I won’t quote one.

8-Step Acc vs Full Steps vs Turbo 4-Step

Two few-step H3 LoRA families are easy to mix up:

Acc 8-Step (Alibaba PAI, PDD): the files in this post, loaded with the Deno loader.
Turbo (LightX2V): from lightx2v/Minimax-h3-Turbo. Comfy-Org repackages them in its loras/ folder as minimax_h3_ref2v_turbo_4step_v0.1, minimax_h3_fl2v_turbo_4step_v1.0_768p and minimax_h3_fl2v_turbo_8step_v1.0 (ComfyUI bf16 versions).

The Acc LoRA README has a demo table with three columns for each task: the baseline MiniMax-H3 model, Minimax-h3-Turbo (fl2v turbo 4-step v1.1 768p for FL2VA, ref2v turbo 4-step v0.1 for Ref2VA), and the Acc 8-step LoRA. Three test cases per task come from the Minimax-H3-Turbo examples, “generated with a LoRA weight of 1.0 at both 4 and 8 NFE.” The README publishes no speed table or quality score and doesn’t declare a winner, so watch the side-by-side clips on the model card yourself.

How I pick:

Full steps (no LoRA, the template’s own sampler settings) is the reference the distilled versions are compared against. I use it for hero shots.
Acc 8-step is my default for iterating on prompts and references. It’s official for both tasks and the loader keeps the trained schedule.
Turbo 4-step halves the evaluations again; for Ref2VA it’s a v0.1 release, so compare on your own shots.

The Deno loader lets you choose any Simple scheduler step count from 4 to 12 without touching the loader, but its README states that 8-step Simple/Euler “remains the recommended and trained configuration”.

Optional Upscale and RIFE Tail

The two right-hand groups are bypassed and aren’t wired to the generator. Each starts with its own Load Video, so you render first and finish the saved MP4 as a separate job, keeping VRAM free for H3.

# Step1 (Upscale): Load Video (input.mp4) feeds (Deno) RTX Video Super Resolution on Deblur Ultra at Same Size, then ImageUpscaleWithModel with realesr-animevideov3.pth, then Video Combine at 24 fps, crf 19, with the source audio passed through. The RTX node needs NVIDIA’s optional VFX runtime (Windows, RTX GPU); the node’s “How to install” button opens the guide. Upscale models go in models/upscale_models/ (links are on the canvas).

# Step 2 (Frame interpolation): Load Video feeds RIFE Frame Interpolation with source 24 and target 60, scale 1.0, flownet.pkl, then Video Combine at 60 fps with the audio. 60 isn’t a whole multiple of 24, so for every H3 frame kept exactly, use the 3x approach in my MiniMax H3 RIFE 24 to 72 FPS workflow.

Troubleshooting

Red “missing node” boxes: install Deno Custom Nodes, KJNodes, VideoHelperSuite and (for the tail) ComfyUI-VFI from Manager, then restart ComfyUI.
The LoRA doesn’t show in the loader list: check that it’s in models/loras/ or models/minimax_h3_acc_loras/, then refresh.
Error about sigma shifts 12.0 / 3.0: the loader refuses other shifts. Remove any extra model-sampling or shift node you added between the loader and the sampler.
“Curve-pruned compatibility mode” warning: you’re on a *_pruned_* checkpoint without the matching full checkpoint on disk. See the pruned FAQ.
Garbage or noisy output: check that the LoRA matches the base (Ref2VA with ref2va, FL2VA with fl2va), that you’re on euler + simple, and that denoise is 1.0.
Sage Attention errors: bypass Patch Sage Attention KJ.
Out of memory or a stall at the text encoder: drop to 0.5 MP and 5 s, keep match, and apply the fixes in the 16 GB OOM guide.

Download the Workflow

The zip contains MiniMax_H3_Ref2VA_Acc_8Step_Workflow.json (ComfyUI UI format). Unzip it and drag the JSON onto the canvas. In this public copy I swapped my file names for reference_1.png, reference_2.png and input.mp4, replaced my project prompt with a generic 5-second example, and added the int8 checkpoint and Acc LoRA links to the Model Links note. Every node, link and sampler setting is otherwise what I run. Model weights aren’t included (MiniMax-H3 community license).

Download MiniMax H3 8-Step Acc LoRA Workflow (.zip)

Frequently Asked Questions

What is the MiniMax H3 Acc LoRA?

An official Alibaba PAI acceleration adapter, trained with Parallel Decoding Distillation, that lets MiniMax H3 generate video with audio in 8 steps. One file covers FL2VA/T2VA, the other Ref2VA.

Can I use fewer or more than 8 steps?

With the Deno loader you can choose any Simple scheduler step count from 4 to 12, and it fuses the PDD heads for whatever sigma intervals it gets. The README still recommends 8 steps with Simple and Euler, because that’s the trained configuration. Treat other values as experiments.

Does it work with the pruned H3 checkpoints?

Yes, but read the details. According to the Deno README, full non-pruned models (including the native int8 ones) get the complete adapter. For a curve-pruned model, the loader looks for the matching full checkpoint in models/diffusion_models/ and reads only its small time-embedder section to rebase 50 AdaLN LoRA updates. If no full checkpoint is there, it runs in compatibility mode, skips those 50 updates, and warns once. That’s why my workflow loads the full minimax_h3_ref2va_int8_convrot file.

Do I need CFG or a negative prompt?

My graph uses BasicGuider with only the positive conditioning: no CFG guider and no negative prompt.

Can I stack the Acc LoRA with a Turbo LoRA?

I wouldn’t. They’re separate few-step distillations of the same base, each with its own step schedule, and none of the sources describes combining them. Pick one per render.

Final Thoughts

The MiniMax H3 Acc LoRA is the easiest way I’ve found to cut H3’s step count without leaving stock ComfyUI sampling. Use a PDD-aware loader, match FL2VA or Ref2VA to its base, keep euler + simple at 8 steps with shifts 12.0 / 3.0, and use the full int8 checkpoint. Test at 0.5 MP for 5 seconds, then scale up.

More H3 guides on FreakyJolly: