Apply VDN-H3 24GB Optimized

The one node that fits MiniMax-H3 onto a 24 GB card

By Speach1sdef178·Created 2 days ago·Updated 2 days ago· 4

model
auto_memory_latent

MODEL

◄vdn_checkpoint▾►

◄apply_turbo_adaptertrue►

◄strength1.00►

◄lora_modemerge►

◄branch_weightsstream►

◄retain_buffersauto►

◄verbosefalse►

◄attention_backendgrouped►

MiniMax-H3, the ~33B open-weight video model from August 2026, is genuinely good and genuinely heavy. Full self-attention across a 10-second clip stops being a quality problem and becomes a VRAM problem: on a 24 GB card you watch the memory meter climb and lose. VDN-H3 is the trick that changes the math, and ApplyVDNH3_24GB - shown in the menu as Apply VDN-H3 24GB Optimized - is the tuned, ready-to-go entry point to it from the ComfyUI-VDN-H3-24GB pack. It's a model-patch node: chain it once between your H3 model loader and the sampler, and what comes out the other end handles 5–15 second clips at 0.4–1.0 MP inside 24 GB.

Nothing here calls an API and nothing needs a key. You download some big weights, you patch a model, you wait. The author validated this exact build on an RTX 3090 Ti 24 GB: a 10 s, 0.4 MP, 8-step render finished in 2:08 at 16.06 s/it.

How it works

Instead of making every frame attend to every frame, VDN-H3 (from the released OpenVDN/VideoDeltaNet work, Apache-2.0) keeps exact softmax attention only over a window of nearby frames, and pushes distant context through a separate linear "Video Delta Attention" branch - a stateful, near-linear cost path. Your clip keeps its long-range coherence without the quadratic attention bill. The branch's weights (~4.3 GB) and two adapters live in a VDN stage checkpoint that ships separately on Hugging Face.

The stage-dmd-* prefix means 8-step DMD-distilled. apply_turbo_adapter turns on the "turbo" adapter that makes the 8-step model work - leave it ON and sample at 8 steps, or OFF and sample the 50-step teacher at 50.

The inputs that matter

model - the MiniMax-H3 diffusion model from your loader. Chain once, between loader and sampler.
vdn_checkpoint - the stage folder under models/vdn. This is where the enum reads from, so it's empty until you place the checkpoint.
apply_turbo_adapter (ON) - 8 sampler steps with it on, 50 with it off.
lora_mode - keep merge. merge folds the adapters into the weights and reproduces the validated model; bypass injects them in activation space, which the README says visibly degrades 8-step DMD output.
branch_weights - where the ~4.3 GB branch lives. stream (the tested 24 GB default) streams it per block per step; cache_gpu keeps it resident if you can spare the VRAM; auto decides.
auto_memory_latent (optional, but connect it) - feed the same H3 LATENT that goes to the sampler. The node reads the spatial workload from it and picks the 24 GB Ampere headroom and LongCache policy automatically.

strength is 1.0 (the released model). retain_buffers auto-trades ~0.5–1 GiB of scratch for churn-free steps. attention_backend can flip the windowed softmax to one compiled FlexAttention kernel (flex) instead of per-group SDPA (grouped) - faster on long clips, compiles on first run, falls back if it fails. verbose just logs what it applied.

The output

One MODEL, wired into your sampler - exactly like any Apply-style patch node. The example workflow bundled in the repo shows the full t2v graph: the pruned INT8 ConvRot H3 base, the Qwen text encoder, the video and audio VAEs, 8 steps on a res_multistep/simple schedule, then VAEDecode + VAEDecodeAudio into SaveVideo. Copy that workflow rather than rebuilding from memory.

Installing

ComfyUI Manager (search "VDN-H3"), or:

cd ComfyUI/custom_nodes
git clone https://github.com/Speach1sdef178/ComfyUI-VDN-H3-24GB

The path must land exactly on custom_nodes/ComfyUI-VDN-H3-24GB/ - no extra nested folder. Restart ComfyUI. Requirements.txt is empty; the node runs on ComfyUI's stock torch, with SageAttention an optional speed-up the bundled Windows launcher (Start_VDN_H3_24GB.bat) enables if it finds it.

Then the checkpoint - this is the step people skip. From speach1sdef178/VDN-H3-INT8-ConvRot-ComfyUI, download the whole stage-dmd-step-250-int8_convrot_comfyui folder and place it at ComfyUI/models/vdn/stage-dmd-step-250-int8_convrot_comfyui/. Do not grab only the linear-branch .safetensors: the stage also needs model_spec.json plus the default and turbo adapters, or the node has nothing to apply.

The gotchas that bite

The hook. LongCache patches one file inside ComfyUI core, comfy/ldm/minimax/model.py, via tools/install_minimax_block_loop_hook.py. It's idempotent and backs up to model.py.vdn_longcache.bak - but a ComfyUI update overwrites it, and then your cache silently doesn't work. Re-run the installer after upgrading. To undo: python custom_nodes\ComfyUI-VDN-H3-24GB\tools\install_minimax_block_loop_hook.py --comfy-ui . --revert.
Match the base. This stack assumes the INT8 ConvRot H3 conversion, not the full-precision weights. H3 also ships under a Community License whose grant excludes the US, EU, UK and Korea - that restriction travels with the weights regardless of what node loads them.
This is a 24 GB-card pack, not a "runs on anything" node. The whole tuning assumes Ampere/24 GB headroom. Expect seconds-per-iteration, not realtime.

If your vdn_checkpoint dropdown is empty, the stage folder isn't where the code looks. If renders look washed out, check you're at 8 steps with the turbo adapter on and lora_mode still on merge.

Categorymodel_patch/video

Inputs (10)

Name	Type	Default	Description
model	MODEL		The MiniMax-H3 diffusion model to patch. Chain once, between the model loader and the sampler.
vdn_checkpoint	COMBO		The VDN stage directory (models/vdn) holding the linear-branch weights and spec. Must match the loaded base (stage-dmd-* = 8-step distilled model).
apply_turbo_adapter	BOOLEAN	true	Apply the 'turbo' adapter when the checkpoint carries one (stage-dmd = the 8-step VDN-H3 model). OFF gives the 50-step model the checkpoint was distilled from. Use 8 sampler steps with it ON, 50 with it OFF.
strength	FLOAT	1.000–2	Adapter strength. 1.0 is the released model.
lora_mode	COMBO	merge	merge: adapters folded into the weights -- reproduces the validated model exactly. REQUIRED for 8-step DMD checkpoints (stage-dmd-*): bypass's activation-space rounding noise is amplified by the deep blocks and visibly degrades output.
branch_weights	COMBO	stream	stream (24GB tested default): branch weights are moved to the GPU per block per step. auto: cache_gpu when the free VRAM after the base load exceeds 1.5x the stage size + 4 GiB headroom, else stream (prefers the int8_convrot stage file under memory pressure). stream: the ~4.3 GB of linear-branch weights are moved to the GPU per block per step, with a one-block lookahead prefetch (safe on small cards). cache_gpu: resident on the GPU after the first step (faster; keep ~4.3 GB VRAM free).
retain_buffers	COMBO	auto	Retained branch scratch/banks (scan banks, delta solve, window gather, q/k/v copies + prefetch) trade ~0.5-1 GiB VRAM for churn-free steps. auto: retain when free VRAM >= stage + 10 GiB headroom, else transient (v1.3.1 allocation pattern, peak VRAM priority on small cards). on/off override.
verbose	BOOLEAN	false	Log the applied adapters and the per-forward layout to the console.
attention_backend	COMBO	grouped	How the windowed softmax runs. grouped: one dense SDPA per window group (portable, exact). flex: the whole pattern as one compiled FlexAttention kernel over the full sequence (faster on long clips; first run compiles, falls back to grouped if compile fails).
auto_memory_latentopt	LATENT		v49 AutoLongCache: connect the SAME H3 LATENT that goes to the sampler. The node derives spatial workload before H3 lazy-load and automatically chooses 24 GiB Ampere headroom/cache for ~0.2-1.0 MP and up to ~15 s.

Outputs (1)

Name	Type	Description
MODEL	MODEL	—