ComfyUI-MAINodes
MatlowAI's MiniMax-H3 nodes: Dials (training-free steering sliders, rack, time curves), Contact-Sheet diffusion, and Motion Lab (test-time de-roping of fast motion via oracle-guided v2v time-smear)
Nodes (105)
The audio half of the de-rope fix, where dialogue goes to survive
The audio seed that keeps dialogue honest through a de-rope
Ask the running ComfyUI what it can actually do for H3
De-rope any model, not just MiniMax H3
Encode your prompt once, stop paying for the text encoder every time
Five views of one subject, packed into one H3 latent
The mandatory other half of the contact sheet
Stop the chain of clips from slowly getting darker
Draw the timing envelope in the web editor, wire it into the graph
The node that stops chained segments from going mushy
Give the true clock only to the blocks that can afford it
Shove the 15 GB text encoder out of VRAM the moment it's done
The boring node that makes the de-rope honest
Base model starts the structure, turbo finishes the polish
Do the grid math for chaining H3 clips so you don't have to
Pretend the activations are 4-bit, measure what breaks
A 17 GB refund you can collect with one node
A second oracle that reads the model's doubt, not the motion
The one knob that decides if your de-rope actually fixes the smear
Watch the de-rope oracle think, then trust it a little less
The oracle that reads H3's latent and finds the frames that smear
Keep the pass-1 latent so window items stop re-rendering it
Upscale the video latent, keep the audio bit-exact, skip the VAE round trip
Steal a hold map from another model's graph without loading that model
Tired of the oracle being overzealous? Type the ranges yourself
Find out what's eating VRAM, block by block, without guessing
Insert token-times mid-denoise, so the coarse pass and the dense pass share one trajectory
One graph, two pipelines, a dropdown that only runs the branch you picked
Keep the subject regenerated, hand the background back to the baseline
Paint where the de-rope should act
Price a plan before you run it — from your own recorded renders, not a spec sheet
Pull a plan's execution settings out as typed wires, so the graph can't drift
Which activations could survive 4-bit? This node measures before you commit
Give the carried prefix a freeze mask so pass 2 doesn't re-texture the seam
Read the oracle early and don't pay for the rest
Stop the de-rope from retiming the continuity anchor you're carrying over
The front half of the flight recorder that calibrates your cost estimates
Read the peaks, append the line, pass the wire on
'Frames 45 to 47 are wrong' → the whole arithmetic of a repair pass
Stitch the repaired frames back in, and prove nothing else changed
A de-rope render without its hold map is a secret that dies when you close the graph
The thermometer for colour drift across chained segments
The hidden prefix is a calibration chart, and this node reads it
Stop regenerating the frames that were already fine
Put the clip back together so nobody can find the cut
The de-rope pass on a 16 GB card, bit-equal to the 96 GB one
How the next segment gets to know how this one ended
The de-rope done in latent space, so your good frames never get re-rendered
Turn two oracles' opinions into a retiming plan the graph obeys
Compile a plan into a legal graph, and price it before you queue
The node that teaches MiniMax-H3 to draw fast motion twice as slowly
Checkpoint your sampling run every step, so branching isn't a re-run
Resume a sampling run at step 18, not step 0
Throw away the hidden prefix without throwing away your timeline
Why your held frames play back at double speed, and the fix that's off-distribution
The node that turns a slowed-down clip into a regen ready to go
Why your MP4 doesn't run through H3, and the node that fixes it
Bank every window to disk so an OOM costs you one frame, not the run
The internal node you'll touch only when a window plan is lying to you
Rolling regeneration for clips too long for your VRAM
The whole de-rope chain, inside one node, on a VRAM leash
The internal no-op you'll see in a windowed graph
Cut a de-rope pass into N affordable windows
Pin-and-trim where two windows meet mid-burst
Tap a model's insides and see what a reference actually does
The 'now file it' node of a Concept Lab capture
Put a measured capture back into the model
A video in, by path, as ComfyUI's VIDEO type
Find the keepable seed by watching 2-6 candidates side by side
The uniform frame decimation for the no-hold-map case
2-6 renders, synchronized, in the browser, for zero VRAM
Save a render with its provenance sitting right beside it
ComfyUI-MAINodes
Custom nodes for MiniMax H3 video. Three parts:
- Motion Lab fixes fast-motion smear (backflips, sword arcs, whip-fast turns) at inference time by re-rendering the clip as a slowed-down copy of itself and dropping the held frames afterward. No extra model, no training.
- Dials (alpha) are training-free steering sliders: make one from two prompts or two groups of pictures, stack them in a Dial Rack, and change them over the clip. Also runs on MOSS-Image, and with limits on Krea 2.
- Contact-Sheet diffusion makes five views of one subject from one reference image.
Around them: a video compare player, low-VRAM nodes for 16 to 24 GB cards,
and research nodes marked (alpha).

The baseline (left) smears the aerial spin; the two de-roped versions keep it clean with the same choreography. Default settings, no per-clip tuning. More demos: Motion Lab page, Dials page.
Like it? A star helps. Want to feed the GPU? Sponsor the experiments.
Start here
| you want to | start from | read |
|---|---|---|
| make an H3 video (recommended start): Pika H3 Flex + de-rope; steer look, mood or motion with Dials sliders | examples/dials/dials_simple_pika_derope.json | dials/README.md |
| fix smeared fast motion (Motion Lab graphs) | examples/motion_pipeline_ref2va_audioinit.json | Motion Lab, TUNING.md |
| five views of one subject | examples/contact_sheet.json | below |
| upscale a video 2x or 4x (RelayVSR) | examples/relayvsr/workflow_comfyui_native_video.json | relayvsr/README.md |
| run on a 16 to 24 GB card | examples/motion_pipeline_lowvram.json | LOWVRAM.md, HARDWARE.md |
| compare renders side by side | the MAI Video Compare node | VIDEO_TOOLS.md |
| pick among all the graphs | | examples/README.md |
Every graph comes as name.json (drag onto the canvas) and usually
name_api.json (the same graph for scripts). Most Motion Lab graphs need
ComfyUI-KJNodes.
Motion Lab (de-rope)
One latent token spans four video frames, and at high speed those four frames need four poses one token cannot hold, so H3 smears. The pipeline reads where motion runs too hot from the clip's own latent (the oracle), holds those frames so the model has room, regenerates video-to-video from that slowed init at partial denoise, and recovers the original frame rate by exact frame selection.
(baseline video) -> VAEDecode frames (baseline latent)
| |
v v
H3TimeSmear <-- hold_map ------------- H3JerkOracle
| (integer holds) |
v |
VAEEncode -> H3V2VInit -> SamplerCustomAdvanced
^
H3InjectSchedule ---/
|
VAEDecode -> H3ExactRecover -> original fps
Start from
motion_pipeline_ref2va_audioinit.json:
pass 1 at 12 steps on the base model, the turbo LoRA at 6 steps for the
de-rope, dialogue kept intact by the audio init. 192 frames at 1 MP take
about 12 minutes end to end on an RTX PRO 6000 (36 for 25 steps both
passes without turbo). Reach for inject (0.50 sharper, 0.70 safer)
before any other setting, and try a 2 to 3 second clip first.
The full guide, with every graph, node table, timing table and the alpha
features (repair, window mode, DyRoPE, chaining, the editor), is
docs/MOTION_LAB.md.
Dials (alpha)
Training-free steering sliders for MiniMax H3 (also MOSS-Image, and Krea 2 with limits). A dial is a ~14 KB file
made from the difference between two prompts (or two groups of pictures); a negative strength pushes every generation
toward the first side, a positive one toward the second. No training, about a minute to make one. Stack them in a
Dial Rack, see how they interact, and vary them over the clip. Full guide: dials/README.md;
what we learned: dials/LESSONS.md; what's next: dials/ROADMAP.md;
dial library on Hugging Face. See it in action: the
Dials project page and demo video. The original stable release, with the
simple Load/Apply Dial nodes, is ComfyUI-Dials; both packs share the same dial files.
What you can do with them
| capability | what it gives you |
|---|---|
| Make a dial from prompts | A ||| B pairs, prompt sets with weights, hold pairs (!) that keep a quality fixed |
| Make a dial from pictures or clips | two groups of pictures of any size (or matched video clips); pick how they are read: content, look, bare, all averaged or your own sentence |
| Dial Rack | any number of dials on one model: on/off, strength, solo, and H to hold a direction out of the mix. Row order should not change the result (one render did; under investigation) |
| See what dials do | a 2D map of two dials with their useful and overcooked ranges, an interaction matrix (who reinforces or cancels whom), a "who pushes" bar, and an influence wheel over 14 probe axes (motion, light, colour, mood, voice...) |
| Edit a dial | open a dial, see its probe profile, drag bars to add or remove a component (say, take the colour out of a dial), and export a new dial with its parentage recorded; Combine Dials mixes two dials into one file |
| Control it over time | draw a strength curve over the clip with the mouse (click to add a point, drag, double-click to delete, snap to seconds or beats) or drive it from audio; the dial switches inside one generation, not in a second pass |
| Control it over depth | a 50-cell strip sets how much of the dial each DiT block gets |
| Keep audio clean | an "audio: protect" option leaves the soundtrack undialled (measured: speech errors 0.29 to 0.00 in 3 of 4 cases) |
| Works with de-rope | a hold-map link keeps time curves in real clip time through a de-rope run |
| Other models | the same nodes detect MOSS-Image (works, about 2-4x H3's strengths) and Krea 2 (partial); dial files remember their model family |
| Examples and help | a Simple front door (Render Preset, Dial Rack, one blueprint; core-only and KJNodes variants) and Pika H3 Flex + de-rope workflows for the rack, picture dials (folders, two pictures, groups) and prompt sets in examples/dials/; Node Info guides on the Dial Rack, Make Dial from Pictures, Render Preset and H3 De-rope Sigmas |
Honest limits. Dials are alpha. Strengths are starting points measured on Pika H3 Flex's 6-step schedule, mostly one seed. Time curves switch smoothly (a lighting dial ramps over about 1.5 s; colour and style dials switch much faster) and cannot follow individual drum hits. Picture dials come out weaker than text dials. Krea 2 steers on one side only. A dial can leak into other qualities (a "psychedelic" dial also brings rave outfits); the lessons file lists the known ones.
Quick start. Load examples/dials/dials_simple_pika_derope.json
(core ComfyUI only; _kj adds KJNodes' VRAM savers and folder loader):
pick a Render Preset (Pika, Pika + reference pictures, DMAD, or your own), write a prompt, drag a slider on the Dial
Rack, and queue; de-rope is one choice on the same node (off, oracle or flat; 79 s off at 1280x704). dials_rack_pika_derope.json
is the same render with every node in view. To make your own, add Make Dial, write two prompts that differ in one
quality, and wire its output into a rack row.
Contact-Sheet diffusion
Five standalone image latents packed on the model's time axis, jointly
denoised, decoded independently. Use with a Turnaround LoRA from
matlod/minimax-h3-turnaround.
Nodes: H3 Contact Sheet, H3 Contact Sheet Decode.
Drag-in workflow: examples/contact_sheet.json
(API twin alongside) — point the LoadImage at your reference image, pick
your downloaded LoRA file, queue. ref_image is optional: leave it
unconnected for a text-only sheet (drop the <Picture 1> tag from the
prompt); examples/contact_sheet_t2i.json
is that graph. Stock loaders and sampler throughout;
28 steps of res_multistep at denoise 1.0, LoRA strength 0.75. A scripted
example is in example_api_workflow.py.
Previously published as ComfyUI-H3-ContactSheet; that repo remains up for
existing installs.
More
- Video tools: MAI Video Out (file plus hold-map and metadata
sidecars), MAI Video Compare (2 to 6 renders, synchronized, with
frame-exact export), MAI Seed Hunter, and a standalone compare deck.
VIDEO_TOOLS.md. - Small cards:
H3 Streamed Blocks,H3 Memory Probe,H3 Free Cacheand friends render a long de-rope that OOMed a 96 GB card on a 16 GB card in a 32 GB machine.LOWVRAM.md, speed dials inFASTER.md. - De-rope for any model (alpha):
H3 Clock Remapretimes one hold map onto another model's clock from a preset (minimax-h3,ltx-2.5, Wan 2.2). The LTX-2.5 de-rope deck behind https://matlowai.github.io/flipbook/derope.html was built with it.DEROPE_ANY_MODEL.md. - What is stable: the Motion Lab pipeline and the contact sheet. Concept
Lab, the timeline surface, the motion adapter, manual masks, the audio
init and Dials are alpha:
ALPHA.mdsays what each can do and where it was tested. Alpha nodes carry(alpha)in the menu and load behind a guarded loader, so a broken one cannot take the pack down. - Snap (pre-alpha): a snap-together view over the ComfyUI graph, with agent tools. It works but is not polished
yet. How to try it, known issues and the third-party model licenses:
docs/snap/README.md. It is off until you turn it on (Extensions menu: "Snap (pre-alpha): turn on"), and off it adds nothing to ComfyUI but that one entry. - Node Shelf: hide node packs, or single nodes, you don't use. Open it from ComfyUI's command palette ("Node Shelf"), the Extensions menu, or Snap's top bar. Hidden nodes leave node search, the node library, the right-click Add Node menu and Snap's Add brick; they stay installed, so workflows that use them still load and run. Needs a ComfyUI interface from about August 2025 or later; on an older one the dialog says so and hides nothing. Also available by itself: comfyui-node-shelf (installing both is fine: one copy runs).
- What's new: RelayVSR upscaling with quality presets and 16 / 24 GB tiers (
relayvsr/README.md, 2026-11-03). Older notes indocs/NEWS.md; open questions inROADMAP.md.
Install
cd ComfyUI/custom_nodes
git clone https://github.com/matlowai/ComfyUI-MAINodes
Most Motion Lab example graphs also need ComfyUI-KJNodes
(the Dials picture-folder example uses its LoadImagesFromFolderKJ too).
They use PathchSageAttentionKJ,
MiniMaxH3MemoryEfficientSageAttentionPatch and MiniMaxChunkFeedForward
from it. Without KJNodes a graph loads with those three missing and will
not run. The nodes in this pack themselves have no such dependency.
Cloned before 2026-08-19 and git pull errors? Run
git fetch origin && git reset --hard origin/main, or re-clone.
Restart ComfyUI. Nodes appear under latent/minimax/motion,
image/minimax/motion, sampling/custom_sampling/schedulers and MAINodes/Dials.
Support MAINodes
MAINodes is free and open source. If it saved you time, fixed a workflow or made something cool possible, you can help fund the next round of GPU time, benchmarking and increasingly questionable experiments:
- Support MAINodes on Ko-fi
- Or just star the repo; that helps too.
License
GPL-3.0-or-later. Copyright (C) 2026 MATLOWAI. See LICENSE.