IAMCCS-nodes

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

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

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

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

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)

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

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

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

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

The tiny node that keeps shot B picking up where shot A ended

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

The Gate That Stops Your H3 Editor From Exporting Every Pass

Turn H3 Chunks Into Editable Takes Without the Concat Headache

Fixing the frame count drift after an 8n+1 LTX round trip

Face detailer on H3, only when you actually enable it

Write exactly one final film, after the upscale is actually done

Turbo, acceleration, and a clean decode

UNet, CLIP, and both VAEs

The Gemma text encode that frees its own encoder afterward

Use H3's own text encoder to rewrite H3 prompts

Carry motion between FLF segments instead of cutting to black

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

Look up the planned first and last keyframes for a shot

The control hub that decides the upscale pass without loading it

The prompt lookup that exists to keep old workflows alive

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

The node that renders MiniMax H3 in segments, then stitches the master

One node decides how a whole MiniMax H3 shot gets made

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

Plan a 3-minute LTX-2 project in segments before you render a frame

Write the scene in sections, not one giant prompt

Fire a dozen Qwen edit prompts at one image without touching the graph

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

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

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