IAMCCS-nodes
Custom nodes by IAMCCS, including a critical fix for LoRA loading in native WANAnimate workflows, especially useful for advanced models like FLUX and WAN 2.1. This bypasses the need for the WanVideoWrapper for LoRA functionality.
Nodes (453)
Fix the seams on a finished long video without re-rendering it
How to actually apply a WAN LoRA stack — without the 15-minute stalls
The scheduler that reads the prompt
A DAW-style audio lane editor inside ComfyUI
The node that keeps your AudioBoard branch honest about the Shotboard's clock
The channel-strip mixer for your Shotboard audio
Hand each video segment the audio context it needs
The calculator that keeps audio and video in sync
Fix the waveform layout before the LTX audio VAE
A gate that only wakes up the stage of the pipeline you actually want to run
Turn any audio track into LTX-2 segment math so you don't have to
The node that stitches your per-segment audio back into one full track
Keep generating, or stop?
Trim the right slice of audio for the segment you're about to generate
The overlap trimmer that keeps chunk-to-chunk video from feeling stitched
The low-RAM version of the extension chain that swaps RAM for disk
Frames folder → finished video
Decide where the keyframes go and how often the video refreshes itself
The head of the AU+IMG2VID chain that decides how many segments your video needs
Plan the whole project in one pass instead of one segment at a time
Lock the video back to a reference frame before the next chunk drifts
The node that decides how hard to re-anchor each segment to keep identity alive
The adapter that turns planning payloads into something a sampling backend can run
The config node for a graph-wiring helper (no, it doesn't generate anything)
Clean up your node spaghetti with one click
Plan a cinematic shot beat-by-beat, then hand the plan to a generator
Storyboard a two-person dialogue scene with the sound design built into the plan
Pre-build every LoRA variant once, so your generation loop never patches mid-run
A node with no inputs and no outputs — the mute/solo controller that lives in the UI
Pull the master bus and up to five stems out of your AudioBoard mix
Your LTX timeline, condensed into one conditioning node
The one-liner that tells you exactly how long your audio actually is
The two-way audio bridge between your TTS, the AudioBoard, and the Shotboard
Fold scene, action, dialogue and voice into one prompt the audio model actually obeys
Put actual spoken dialogue into your LTX prompt, automatically
LTX won't take your shot length — this node makes the math cooperate
Turn a script into a lip-sync timeline before you generate a single frame
Stop untangling dialogue lines by hand — pull them straight out of the board
Write the scene once — get a global prompt, per-beat prompts, and a script
Your audio is 6.4s but the shot is 192 frames — here's the delta
The guide stage that turns shotboard data into real conditioning
Type 'fear, urgent' and get an acting direction an actor could actually follow
IAMCCS_CineFilmGrainPro is a name, not a node — it's the old ID for CinePostEfx v2
The breakout hub for your cine_linx
Turn a shotboard plan into a samplable LTX pipeline
Cut the guide tail off your latent — the cleanup step nobody tells you about
Push reference frames into your shot with one strength knob
The guide applicator that matches LTX Director behavior exactly — with scaling
Dialogue + foley, one node, no audio-suite detour
FLF keyframes without a wall of widgets — frame | ref | strength, one line each
The same FLF engine, plus the attention lock for motion-heavy shots
The frame math for the FLF path — guides included, tails accounted for
Feed it a guide plan, get back a guided shot — the production FLF backend
The production FLF backend, plus a switch for guide attention
Turn the Shotboard's hidden audio lanes into real AUDIO sockets
Pose, depth and edge frames, prepped the way MiniMax H3 actually wants them
The node that merges eight mini-workflows into one MiniMax H3 shot
A local VLM that reads your reference frames like a script supervisor
One cine_linx in, the whole workflow plan out — the simplest breakout
The dialogue and foley breakout — scripts, TTS text, and sound cues, extracted
This is how you tell MiniMax H3 REF2VA which reference means what
Source in, directions set
Read the whole Cine plan out of one wire
One node that unpacks your whole video-to-video shoot
Bridge your shotboard into V2V — the one node that speaks to pose-transfer backends
This node turns a V2V plan into a pose-transfer run without the spaghetti
Let a shot plan drive your motion-transfer run
WanAnimate segment control without hand-wiring every shot
The silent fixer that trims your video latent down to size
The boring node that feeds the planners
Keyframe your LTX video on a timeline instead of praying for a good first frame
50 keyframe slots, no surprises
Storyboard your camera move as strokes before you ever generate a frame
The multi-shot planner that runs your dialogue scene shot by shot
Planning a music video shot by shot, beat by beat, from one node
Film grain, tape damage and broadcast rot in one node
Same film-grain node, underscored name, one-character history
Jagged edges on your video frames? Edge-aware anti-aliasing that doesn't smear detail
A prompt building block for people who think in shots, not sentences
Stop hand-typing 'medium close-up, subtle handheld, low-key' every shot
The adapter that turns a shotboard plan into PromptRelay's format
The width/height mismatch that silently kills PromptRelay, fixed
One encode node that works whether or not PromptRelay is installed
Turn 'at second 3 the camera pushes in' into PromptRelay segment data
One text box, fifty reference frames, all pre-sized for the pipeline
Inject reference frames into the latent so identity survives the whole shot
Run PromptRelay only when there's actually something to relay
Prove your shot at low res, then port the plan to the big render
Pick shot 4's audio, pad it, and hand it to the sampler — in one node
Plan data in, sampler-ready conditioning out
Sweeping the ghost frames off the end of your shot before it's saved
The on-ramp to IAMCCS's shotboards — FLF guides, none of the PromptRelay drama
A shot list that becomes timed FLF guides, without the graph cycles
Same planner as Pro, but with the old sockets — for workflows that predate the LINX contract
The same contract, a nicer frontend, and automatic action-beat transitions
The editor-grade timeline that finally carries audio with it
The shot planner that turns a timeline into an LTX 2.5 bounding-box movie
A neutral multi-track timeline contract that's built for whatever comes next
The planning brain that decides what your V2V video actually is
A tiny node that tells the pipeline how many LTX tail frames to lose
The full single-generation shotboard that drives FLF guides and PromptRelay from one table
Where a shotboard plan actually becomes a conditioned model and latents
Trims the LTX tail off your latent so output matches the edit
Guide data in, sampler-ready conditioning out
Let the timeline own the retake prompt — this node just encodes it
The bridge that makes Shotboard retakes work with official LTX 2.3 inpaint
The junction that turns the planner's plan into backend-ready buses
Write one cinematic shot, get a prompt-worthy line for the multigen
Decide where your reference frames land in time, not just what they show
Turn dialogue rows into LTX speech prompts with one token swap
How long is that line of dialogue on screen? This node counts the words for you
Pick which stage's latents get decoded, without a graph cycle
Kill the TAELTX preview that's OOMing your render
Keep PromptRelay out of the graph until your shotboard actually has relay rows
Forcing hard cuts inside a single generation (experimental, obviously)
The one IAMCCS node you can actually run standalone (and it looks great)
Place dialogue lines on the shotboard timeline and mix in foley
Edge-aware AA so your video doesn't look like jaggies on a CRT
Route the right source video and references for each shot
Write a shot list in one text box, get a plan back
The shot-line node with source ranges bolted on
Turn a generated clip into frames and a Woosh-ready video for foley
Chunk your foley pass so a long clip doesn't explode mid-run
A linter for IAMCCS cine graphs, before you burn a GPU hour
The deprecated version of IAMCCS's AudioBoard effect controller
The interactive effect-control panel for the IAMCCS AudioBoard
LTX-2 upscale math, solved once — 22 recipe outputs so you stop hand-tuning
The fine-tuning layer for the LTX-2 Detail Atelier sampler
The LTX-2 detail pass that actually fits in your VRAM
Turn dialogue tags into real audio lanes without rebuilding anything
Write dialogue once, get timing, speakers, and lip-sync prompts for free
Give FlashVSR enough frames, even when your shot is only 6
Get your original shot count back after FlashVSR
One image, a dozen prompts, zero duplicated sampling chains
Batch-refine a photo against a whole list of prompts in one run
Skip the LLM call entirely when you don't need the assistant
Save a Gemma suggestion to disk and see it on the graph at once
Wireless connections without the rat's nest of edges
The GGUF LoRA speedup you didn't know you needed
Paint an inpaint mask with a real brush, not by guessing pixels
Joins Your Upscaled Segments — and Refuses to Join Bad Ones
Park the Latent on Disk Before You Upscale It
Bigger H3 Clips With No Tiles and No Seams
The Loader That Checks Your Checkpoint's Papers Before Handing It Back
A Sampled Upscale That Never Holds the Whole Clip at Once
Give MiniMax H3 two views of a face and it holds the identity
The IAMCCS H3 PREVIS node
Kick ComfyUI's RAM hoarding out the door between long runs
Let it probe your GPU and tell you what settings to use
One node that sets your VRAM headroom, attention, and torch knobs — or leaves them alone
Global hardware tuning on anything, without MODEL/CLIP/VAE wiring
A checkpoint for the exact JSON your Ideogram prompt is built on
The Ideogram 4 prompt builder that thinks in boxes
A storyboard contact-sheet prompt you can actually steal
Did the image actually change? This node tells you.
The adapter that resurrects the old FrameDesigner outputs
Get your image and mask to the exact frame before inpainting
Make the model actually see the hole you're inpainting
Verify the seed actually reached the sampler
Same image every seed? This noise node proves whether caching is lying to you
Translate a plain LLM prompt into Ideogram 4's fussy JSON
Six images in, one batch out — that's the whole job
Slice a frame batch without a RAM spike
KJ-style resize without the RAM spike at the end
The Krea graph's latent prep, without a third-party VAE utility
RES4LYF-flavored sampling without the RES4LYF dependency
See the number that's driving your batch loop
One identity, a dozen prompt variations, a single queue
Regional boxes on Krea 2, without a second engine
Regional prompts as soft masks, no external node required
Grab the last N latent frames for the next video segment
A switch that only runs the branch you pick
Re-read your saved frames for the next LTX-2 segment
Load a frame segment already sized for the sampler
The Settings Panel That Turns One H3 Clip Into a Sequence
The backend half of the V3B shot
Weld the end of the last segment to the start of the next
Lock the overlap so the next segment has nowhere to drift
Feed real frames as locked context for LTX-2 continuation
Grayscale, threshold and edges for control-style workflows
Make any frame batch LTX-2-safe
LTX-2 Ensure Minimum Frames
The sampler that actually extends your LTX-2 video
The all-in-one LTX-2 extension module, knob by knob
Extend LTX-2 video without blowing up your RAM
The no-frills LTX-2 extension module you'll actually use
Lock LTX-2's first and last frames without touching a VAE
Lock your start and end frames inside the latent
First/Last Latent Pro
Check your 8n+1 math before the VAE eats it
LTX-2 FrameRate Sync
Slice frames without breaking the 8n+1 rule
Slice the soundtrack to match each LTX-2 segment
Stitch LTX-2 segments together without the seam
Low-RAM segment stitching, fully automated
Turn your frames into a finished video
Decide when long LTX-2 video needs a refresh
The planner that ends LTX-2 segment-math headaches
See the whole LTX-2 project before you render a frame
Drag a drifting LTX-2 video back to its anchors
Turn 'when to refresh' into 'how hard to refresh'
The metadata node that tells an IAMCCS SuperNode how to run
Trim frames to LTX-2's grid without doing the math yourself
Pad a frame batch up to LTX-2's grid with edges that don't look fake
A single-pass sampler for segment detailer passes that don't drift
Refresh identity mid-clip without re-generating the whole segment
The same identity refresh, but with your start frames on disk
Pass the last frame from one segment to the next, through disk
Save the last frame where the next segment can actually find it
Start the next segment with the previous one's latent tail
Hand each segment of a 3-minute video the exact frames it owns
Chop a whole song into LTX-2-ready segments without the frame math
Sample long video in temporal tiles without the seams
Stack three LTX-2 LoRAs into one bundle without key-remap voodoo
LTX-2 needs its LoRAs in a specific key shape — this stack fixes that
Stack and apply LTX-2 LoRAs in one node — MODEL in, MODEL out
Six stacks for a three-segment, two-stage video
One LoRA stack, two strengths, for two-stage LTX-2 sampling
Pin a frame in the middle of an LTX-2 clip, not just the ends
Six different LoRA'd models for a three-segment video, in one node
Loop a whole long video in one graph run, on a tight VRAM budget
Pick your reference frame without rewiring the graph
Actually get the reference into the conditioning, not just into the graph
Hand the raw latent tail to the next segment, not just a PNG
The boring node that keeps long videos alive
LTX-2 won't take 80 frames. This node remembers that for you
The LTX-2 validator that builds your empty latent AND checks the math
The make-room-for-the-22B node your long LTX runs are missing
Snip the corrupt tail frames LTX-2 adds to every clip
The node that decides which audio actually drives each H3 chunk
The conditioning heart of the atomic H3 pipeline
The node that decides whether this H3 segment is FL2VA or REF2VA
Stitch per-chunk H3 audio back together without clicks at the seams
What actually lands on the H3 master timeline
The simple select-and-gain between H3's audio and your driven source
The mixdown that respects the H3 chunk grid — and the 5.1667s truth
The node that turns your shot list into an H3 render
Two whole generation branches in one graph, only one ever actually runs
The tiny node that keeps shot B picking up where shot A ended
Find the Frame Where the Shot Actually Stops Moving
Hand the Next Clip the Previous Latent, Not a Last Frame
Pick Up a Continuation Chain at Clip Three
Store the Latent, Not Just the Video
Anchor Both Ends and Let H3 Fill the Middle
Cut the Duplicated Head and the Dead Tail Before You Concatenate
Read one A→B shot from the H3 plan before you render it
Four H3 continuity engines on one graph, only one of them ever runs
Preview a long H3 delivery without spawning 400 temp files
Native, latent-upres, or RTX frames for delivery
Pick the final frames, upscale or not, and optionally smooth to 60fps
FL2VA conditioning with the planned keyframes kept authoritative
Load only the model family the current segment actually needs
Feeding the finished shot back into the video editor as a real clip
The Gate That Stops Your H3 Editor From Exporting Every Pass
Turn H3 Chunks Into Editable Takes Without the Concat Headache
The lazy CLIP loader that only materializes the 4B or 8B encoder you chose
Fixing the frame count drift after an 8n+1 LTX round trip
Your LTX upscale gave you the processing canvas, not the delivery size. This fixes that
Face detailer on H3, only when you actually enable it
A quality second pass that streams straight to disk, audio untouched
Write exactly one final film, after the upscale is actually done
Chain H3 shots by handing over the latent, not the video
Turbo, acceleration, and a clean decode
UNet, CLIP, and both VAEs
IAMCCS_MiniMaxH3HerrgottsDirectAVChain is the same node as FL2VA Continuous AV
The legacy ID for the Shotboard interval reader
Keep H3's own latent history so long takes stop compounding their own error
Why this node renders nothing when you queue it on its own
Parking upscaled chunks to disk so the master only assembles when it's ready
A second encode, or a smart reuse
The planner that turns H3 Settings into a tile-by-tile upscale recipe
The hardware upscale leg
Small steps, low denoise, done in latent space
Iterate shots without re-running everything
The Gemma text encode that frees its own encoder afterward
Use H3's own text encoder to rewrite H3 prompts
Stop H3 from leaking the end of the shot into the start
The H3 sampler that solves continuity in latent space instead of pixels
Carry motion between FLF segments instead of cutting to black
Carrying the previous shot's motion into the next one (MiniMax H3, chained)
Render a chunk, then cut the context tail off cleanly
Saving the AV latent so the next shot can inherit it
The segment saver that makes an upscale failure survivable
The gate that hands the whole film to the upscaler only when it's done
One switchable LoRA for the LTX finishing pass, no hardcoded filenames
Second-pass quality without blowing up the seam
Where your winning H3 take gets the expensive pass
Look up the planned first and last keyframes for a shot
The control hub that decides the upscale pass without loading it
Coarse-to-fine H3 sampling that leaves the audio latent alone
The prompt lookup that exists to keep old workflows alive
A Thumbnail for Your RefMod Bundle, Because Mod Names Are Not Helpful
The sampler-and-decode backend, minus the bells and whistles
The optional 4K finish for your MiniMax H3 renders — Nvidia VSR, not a diffusion upscaler
Pick the Take Without Running Both Branches
Cheap H3 seed candidates, so the expensive render isn't a coin flip
Look at the H3 seed candidates before you commit to the full render
The R40 selector that picks a cached candidate without rerunning anything
The node that renders MiniMax H3 in segments, then stitches the master
Where the winning R40 take becomes real frames and locked audio
The R40 knobs that can only touch delivery — never the native take
One node decides how a whole MiniMax H3 shot gets made
Two widgets that decide the winning take — and which latent stage-2 starts from
H3 delivery that keeps one tile in VRAM at a time
Make a 20-segment film look like one finished master
The fast latent two-pass route, brought inside the R42 universal graph
Where the R42 master film finally gets written to disk
Always save native, only queue when the route demands it
The safe native/windowed delivery branch inside R42
Four Deliverables, One Chosen Lazily
The lazy switchboard that executes exactly one delivery route
Who gets to queue the next segment
Native H3 out, RTX VSR up — streamed so it never touches a full-res batch
Switch Animation Branches at the Finish Line
A lazy switcher so MiniMax H3 doesn't pay for an upscale it isn't using
The node that slices your source video and builds object-swap conditioning for MiniMax H3
The trim node that makes MiniMax H3 V2V segments come back the exact right length
The fix that made WANAnimate LoRAs actually load
Same job, minus the log spam
Two LTX-2 LoRAs, two stages, one node — when one strength isn't enough
Sneak a WAN LoRA in mid-run, keyed to the generation index
Pick up exactly where the last WAN segment left off
Save a WAN segment's tail so the next chunk can pick up cleanly
Turn a motion sketch into a real LTX-2 guide, one node
The LTX-2 IC-LoRA applicator that glues motion control into conditioning
Make WAN 2.2 move faster without touching the prompt
MotionScale, plus the RoPE theta dial nobody agrees on
Draw the motion, get the control frames LTX-2 can actually read
FreeLong spectral blending for WAN 2.2, minus the academic paper
When MoveAhead still drifts, lock the motion skeleton
One multiline prompt, eight clean outputs, zero copy-paste
The five-input any-type switch that keeps your graph readable
Chop a master audio timeline into chunked generations, automatically
Choose take 3 of chunk 7, get the audio timeline to match
Drop a bookmark on the canvas so future-you can find the shot
A storyboard node that secretly runs a whole Qwen Image Edit chain
Turn your approved storyboard frames into a shotplan the video pipeline understands
Save the generated storyboard frame so it can be the next scene's start
Plan a 3-minute LTX-2 project in segments before you render a frame
Write the scene in sections, not one giant prompt
It writes your prompt with the encoder you already loaded
Fire a dozen Qwen edit prompts at one image without touching the graph
A boost pedal for Krea 2's text-fusion path
The same KSampler, minus the UI overhead
SCAIL-2 wants a plan before it wants your GPU — do the chunk math first
Run SCAIL-2 past 81 frames without hand-chaining samplers
Stop SCAIL-2 from merging two people into one tracked blob
Lock a person down across a video with SAM3
Stack six characters into one SCAIL-2 shot (experimental, with a caveat)
Re-derive one segment's numbers without re-running the whole song plan
Turn a song into an LTX-2 segment plan without doing the frame math yourself
Segment Planner, but the total length is frames you already know
One set of segment settings, a hundred copies of the planner — this is how
The one settings node that keeps every segment planner in your LTX graph honest
A per-segment switch that routes different prompts to different LTX chunks
Pick the right WAN model per loop iteration without patching LoRAs mid-loop
Schedule WAN's high and low expert models together, per generation
A virtual node that only exists to keep your graph tidy
The pro exporter that turns a Shotboard master into ProRes, DNxHR, or an RTX-VSR'd 4K deliverable
All the MiniMax H3 Shotboard settings, exported as one CineLinX config
The node that decides what your MiniMax H3 Shotboard actually renders
One panel that plans an entire LTX-2.3 v2v shotboard run and hands it downstream
The compatibility shim that lets Shotboard V4 timelines feed the multigen backend
Turn the shotboard edit manifest back into an actual video
Collect rendered takes into an edit manifest without leaving ComfyUI
Cache your source video frames once so long LTX runs stop re-reading the file
Slice the exact source frames each LTX segment needs, overlap included
Same start-frame injection, but reading from disk so long runs stay low-RAM
Inject start frames into your LTX latent so every segment continues cleanly
Slice a storyboard grid sheet into individual panel images, in reading order
The storyboard slicer that respects your target panel aspect ratio
A finished-looking storyboard sheet with titles and per-panel captions
Ideogram layouts, minus the guesswork
A six-panel contact sheet prompt, with an actual image canvas for i2i
A no-frills contact sheet that prints each panel's prompt under it
The SuperNode that does nothing — and why your graph needs it
The LEGO brick of IAMCCS's SuperNodes system
Frames in, finished video out
One node to plan a whole audio-driven LTX video shoot
One node where the LTX audio+image pipeline used to be fifty
Decode your SuperNode latent to frames (and pick how much RAM you spend)
The optional LTX-2 spatial-upscale refinement stage for IAMCCS SuperNodes
The guardrail that makes multigen 'takes' actually line up
Route one validated take into the Shotboard timeline before rendering
Crop to exact target dimensions without the guesswork
Three-segment frame math for LTX runs that outgrow two chunks
Plan your LTX video in two chunks before you spend a single sample
Pick which V2V backend runs, from one lazy switch
Turn the V2V bus into real LTX inputs — source frames, prompts, audio, all of it
Feed the pose-transfer backend straight from the V2V bus
Feed SCAIL its pose video and reference image from the V2V bus
Hand WanAnimate its face, pose, background, and reference in one shot
A full-screen control shell for Wan-Animate-2 long-form video, without the spaghetti graph
Motion transfer without the skeleton
Choose the output stage — final or preview — from the V2V pipeline
VAE Decode is OOMing on long video? This is the node that survives it
Your VAE decode is OOMing the system RAM — decode one frame at a time to disk
Grade a take without touching a single pixel (yet)
Turn a folder of frames into an mp4 without holding them all in RAM
Stitch up to five generated takes into one video, audio rules included
Viggle Needs a Driver and a Face — This Is Where They Come From
The little passthrough that buys you headroom at the exact moment you need it
A one-input node that rescues long video runs from the OOM
Plan your Wan-Animate-2 chunks without loading the model — the math that always goes stale
Chunked sampling that actually carries continuity
Turns a Wan-Animate-2 plan into the exact numbers the backend graph needs
Know how many chunks your WanAnimate video needs — before sampling
Chain 81-frame chunks into a long take and hide the seams
Send generated frames when active, source frames when not
The node that turns your shot board into something ComfyUI can chew on
Stop hand-tuning five continuity knobs on every segment
The node that hands each video chunk its first and last frame
Grab one frame out of a video batch without the index math
Your WAN SVI clip came out slow and floaty — this node is the motion fix
The node that fixes WAN SVI Pro's fake slow-motion
Keep the face, keep the motion, lose the drift
The motion node that locks your end frame instead of hoping
WanImageMotionPro Plus — motion boost plus a locked end frame, for real transitions
The old motion Pro you probably only need if a saved workflow demands it
The full-fat motion Pro, with presets that make the wall of knobs usable
The motion Pro with the scary inputs stripped off
One text box, a bank of prompts, and a loop counter picks which one wins
Load the shot's first, middle, or last frame straight from the board
A no-frills image loader that respects your 16-pixel rule
The math engine that turns '12 seconds of video' into a chunk plan
Different LoRAs on different generations of a loop
The loop-safe way to swap LoRAs between generations
64 LoRA slots with ranges, so different phases of your video get different looks
4 LoRAs in, one remapped WAN stack out
Four LoRAs, one node hop, no stack-then-apply tango
Scrub the locked end-frame slots off your latent before the next segment
Before you loop 10 WAN prompts, know how many frames and minutes that is
Tiny node that tells your prompt bank which phase you're in
The per-chunk on/off switch for prompt relay
Stitch your chunk renders into one long video, crossfade included
The loop accumulator that knows how to crossfade properly
The node that turns a shot list into 'this iteration's shot'
Peek inside the shotboard bundle without guessing
A tiny memory for long loops, so nothing forgets what already ran
Plan a whole Wan video in one node, then let the loop chew through it
Start fresh, or keep rolling from the last chunk?
Decide which generations lock to a last frame, and let SVI run the rest
The lookup table that tells each loop iteration which mode it's in
Rescue an old SVI→FLF workflow without rebuilding it — the bridge node
When SVI and FLF won't play nice, split the jump in two
Drop up to 50 stills into an LTX latent as hard keyframes
Keyframes plus conditioning guides in one pass
The five-slot sequencer for people who don't want 150 widgets
One node to load, resize, and batch a whole reference board
The node that got people back on Wan 2.2
The exact old behavior, frozen in amber
Same engine as WanImageMotionPro — this is just its full name
The scissors for overshoot frames
IAMCCS Nodes
A production-oriented collection of ComfyUI nodes for image generation, AI video, audio, continuity and editorial workflows.
IAMCCS Nodes turns complex model pipelines into readable production systems. Use it to plan a sequence in a Shotboard, define its technical behaviour in one settings surface, generate with the model branch you need, and carry media, prompts and timing through delivery without losing the context that makes a shot coherent.
Patreon · Website · Buy Me a Coffee · goyAIcanvas perpetual licence
Start with the system that matches the model you are using. The package contains many composable utility nodes, but the featured systems below are the clearest entry points for a new workflow.
Production systems
1. MiniMax H3 Shotboard
The H3 Shotboard is the planning surface for MiniMax H3 workflows. It keeps the authored sequence together: global direction, local shot prompts, media slots, timing, audio handoff and continuity information. The Shotboard is the source of truth for the sequence; connected renderer branches consume that plan instead of maintaining a separate, hidden version of it.
Use it for:
- first/last-frame and reference-led video shots;
- multi-shot and long-form H3 sequences;
- local prompt direction per interval, with a global creative direction above it;
- native AV delivery, continuity-aware paths and editorial handoff;
- repeatable seed policies for a whole generation or for individual chunks.
Key nodes: IAMCCS_ShotboardH3Settings, IAMCCS_ShotboardH3SettingsPro, MiniMax H3 planner, audio timeline and delivery nodes.
2. IAMCCS H3 Settings PRO
IAMCCS_ShotboardH3SettingsPro is the technical control room for an H3 Shotboard. It centralises the choices that should travel with the project: task and delivery mode, dimensions, frame rate, duration, seed policy, supported acceleration profile, continuity options and editor-facing controls.
The purpose is practical: a preset is a visible starting configuration, while its values remain inspectable and editable. Settings PRO publishes its resolved configuration through CineLinX so connected H3 branches stay aligned with the active Shotboard.
3. LTX Shotboard and long-video toolkit
The LTX family brings the same production approach to LTX workflows. The LTX 2.5 Shotboard accepts a timed image plan, per-segment direction and an optional animated bounding-box project, then compiles the plan for the downstream animator and LTX video path.
The surrounding LTX nodes cover the operational work needed by real projects: frame-rate and frame-count validation, first/last-frame control, latent continuation, overlap conditioning, disk-backed extension and LoRA stacks.
Key nodes: IAMCCS_CineShotboardPlannerV3B, IAMCCS_LTX2_Validator, IAMCCS_LTX2_FrameRateSync, IAMCCS_LTX2_ExtensionModule, IAMCCS_LTX2_JointRefreshLatent.
The LTX 2.5 BBox Shotboard expects compatible LTX Video and BBox Animator nodes to be installed in ComfyUI.
4. WAN Animate LoRA system
The original IAMCCS node family solves a frequent native WAN Animate problem: a LoRA may appear connected while most of its weights are not actually applied. The WAN LoRA system remaps and stacks compatible LoRAs, injects them directly into the model, and can vary them safely across a long generation loop.
Use the basic stack and apply pair for a compact graph, or add the Model In→Out, scheduled and runtime-bridge variants for phased animation work.
Key nodes: IAMCCS_WanLoRAStack, IAMCCS_ModelWithLoRA, IAMCCS_WanLoRAStackModelIO, IAMCCS_WanLoRASchedule, IAMCCS_WanLoRAHookSchedule, IAMCCS_WanLoRARuntimeBridge.
5. Motion, audio and finishing
IAMCCS Nodes also includes the practical building blocks around a generation:
- WAN motion:
IAMCCS_WanImageMotionandWanImageMotionProprovide controllable motion, optional FLF end-lock and conservative safety presets. - Audio and editorial: AudioBoard, dialogue tools, timeline mixing, master-audio export and Shotboard Video Editor nodes keep audio and picture on the same timeline.
- Low-VRAM delivery: frame-by-frame VAE decode to disk, tiled decode, progressive and post-upscale routes, and VRAM cleanup nodes reduce peak memory pressure.
- Workflow clarity: AutoLink turns dense direct wiring into organised Set/Get routes, while CineLinX carries structured project information between IAMCCS systems.
- Model utilities: GGUF acceleration, hardware recommendations, sampler controls and LoRA management make larger graphs easier to operate and diagnose.
A clear way through the package
flowchart LR
A[Shotboard<br/>prompts · media · timing] --> B[Settings PRO<br/>mode · technical controls]
B --> C{Model branch}
C --> D[MiniMax H3]
C --> E[LTX]
C --> F[WAN Animate]
D --> G[Audio · editorial · delivery]
E --> G
F --> G
The planning layer carries the authored intent. The connected model branch performs the generation, while the shared editorial and delivery tools keep the result usable as a production asset.
| Your goal | Start here | Add when needed | | --- | --- | --- | | Plan and generate a MiniMax H3 sequence | H3 Shotboard + H3 Settings PRO | Audio timeline, continuity, delivery and editor tools | | Create a timed LTX shot with image control | LTX 2.5 Shotboard | BBox direction, validators, extension and latent continuity | | Animate a WAN workflow with reliable LoRAs | WAN LoRA Stack + Apply LoRA to MODEL | Schedules, hook schedules and runtime bridge | | Increase controlled motion in a WAN shot | WanImageMotion / WanImageMotionPro | FLF end-lock, reference latents and safety preset | | Finish a long video on limited memory | VAE Decode to Disk + Video Combine From Dir | Tiled decode, VRAM flush and upscaling | | Keep a large graph readable | AutoLink | Bus groups and named Set/Get routes |
Node previews
The screenshots below are real nodes from this package. They are included here so the README acts as a visual map rather than a long unstructured inventory.
<table> <tr> <td width="50%" valign="top"> <a href="assets/lora%20stack.png"><img src="assets/lora%20stack.png" alt="LoRA Stack for WAN" /></a><br /> <strong>LoRA Stack (WAN-style remap)</strong><br /> Combines WAN, Flow and compatible LoRAs before native model injection. </td> <td width="50%" valign="top"> <a href="assets/lora_stack_model_I_O.png"><img src="assets/lora_stack_model_I_O.png" alt="Model In to Out WAN LoRA Stack" /></a><br /> <strong>LoRA Stack (Model In to Out) WAN</strong><br /> A direct model-to-model variant for concise WAN Animate graphs. </td> </tr> <tr> <td width="50%" valign="top"> <a href="assets/extension.png"><img src="assets/extension.png" alt="LTX 2 Extension Module" /></a><br /> <strong>LTX-2 Extension Module</strong><br /> Builds a controlled extension plan with overlap, source handling and seam-related options. </td> <td width="50%" valign="top"> <a href="assets/validator.png"><img src="assets/validator.png" alt="LTX 2 Validator" /></a><br /> <strong>LTX-2 Validator</strong><br /> Keeps resolution, duration and frame-count requirements visible before sampling. </td> </tr> <tr> <td width="50%" valign="top"> <a href="assets/wanimagemotionpro.png"><img src="assets/wanimagemotionpro.png" alt="WanImageMotionPro" /></a><br /> <strong>WanImageMotionPro</strong><br /> Motion control with optional FLF end-lock, reference latents and safety controls. </td> <td width="50%" valign="top"> <a href="assets/gguf.png"><img src="assets/gguf.png" alt="GGUF Accelerator" /></a><br /> <strong>GGUF Accelerator</strong><br /> Helps manage patch placement and VRAM reserve in GGUF-based pipelines. </td> </tr> <tr> <td width="50%" valign="top"> <a href="assets/autolink.png"><img src="assets/autolink.png" alt="AutoLink" /></a><br /> <strong>AutoLink</strong><br /> Converts direct links into organised Set/Get routes and can restore them when needed. </td> <td width="50%" valign="top"> <a href="assets/stage.png"><img src="assets/stage.png" alt="LTX LoRA staging" /></a><br /> <strong>LTX-2 staged LoRA workflow</strong><br /> Supports multi-stage LoRA application for more deliberate LTX setups. </td> </tr> </table>goyAIcanvas
goyAIcanvas is the companion local-first image workspace for IAMCCS users. It is built around ComfyUI and focuses on direct image creation and editing: text-to-image, image-to-image, drawing, inpainting, outpainting, references, layers, LoRAs, gallery history and image correction.
- goyAIcanvas EASY on GitHub is the public standalone entry point.
- goyAIcanvas Advanced on Gumroad is the perpetual-licence image generator and editor studio.
- goyAIcanvas updates and editions on Patreon describe the current production tiers and ongoing development.
The IAMCCS Nodes package also exposes the Goya canvas integration node used by compatible local workflows.
Installation
ComfyUI Manager
Install IAMCCS Nodes from ComfyUI Manager, then restart ComfyUI and refresh the browser once. The package should exist only once in custom_nodes; duplicate copies can cause old node definitions or frontend routes to load.
Manual installation
cd <your-ComfyUI-folder>\custom_nodes
git clone https://github.com/IAMCCS/IAMCCS-nodes.git
Restart ComfyUI after installing or updating. If the node UI looks stale, perform a hard browser refresh after the restart.
Before loading a workflow
- Install the model-specific dependencies required by that workflow.
- Put model, VAE, text-encoder, LoRA and audio files in the normal ComfyUI model paths.
- Start with the workflow's intended resolution, frame count and model family.
- Test a short single segment before enabling long-video, upscale or continuation routes.
IAMCCS Nodes does not ship model weights. Every model, LoRA, VAE, audio model and external node remains subject to its own licence and requirements.
Documentation and workflow guidance
- SuperNodes requirements
- H3 continuation quickstart — Italian
- H3 continuation guide for filmmakers — Italian
- H3 Pixel Safe continuation reference
- Complete change history
For workflow releases, detailed setup notes and tutorials, follow IAMCCS on Patreon or visit carminecristalloscalzi.com.
Support and releases
IAMCCS Nodes is actively developed. Patreon is the main place for release posts, workflows, technical notes and the wider IAMCCS AI-cinema ecosystem. If the project helps your work, you can also support it through Buy Me a Coffee.
<details> <summary><strong>Recent release history</strong></summary> <br />| Release | Date | Highlights | | --- | --- | --- | | 1.5.5 | 2026-09-19 | MiniMax H3 engine integration and project licensing documentation. | | 1.5.2 | 2026-08-24 | H3 audio-drive, audio-timeline and Shotboard workflow polish. | | 1.5.1 | 2026-07-21 | Multigen roll, master-audio EDL export and AudioBoard UX. | | 1.5.0 | 2026-07-12 | Shotboard multigen pipeline, Video Editor and AudioBoard. | | 1.4.x | 2026 | LTX audio extensions, low-RAM utilities, SuperNodes and cinematic helpers. | | 1.3.x | 2026 | WAN motion controls, AutoLink, LTX extension modules and LoRA workflow tools. |
See CHANGELOG.md for the complete chronological record.
</details>Licence
This repository is released under the GNU GPL v3.0. Preserve the included licence and attribution notices when redistributing or modifying the package.
Created by IAMCCS / Carmine Cristallo Scalzi · Patreon · Website · Gumroad