**Note: avoid using this for now, i'm focused on other stuffs.

MiniMax H3 renders a video + audio pair in one diffusion pass, and on a 8 GB-class GPU a usable-resolution clip longer than ~5–8 seconds reliably runs out of memory — even at 1 megapixel, 15 s will OOM every time. The official tooling assumes the card can swallow the whole clip, which leaves people with small VRAM stuck manually chopping their scene into pieces, rendering them one at a time, clearing the cache between runs, and hand-stitching the seams.

Chaotic MinimaxH3 Director automates all of that. You author the entire scene on a visual timeline as if VRAM were unlimited. The Director:

1. chops the timeline into VRAM-safe chunks (at shot boundaries, or at sentence/beat splits inside long shots — never mid-word),
2. renders them strictly one at a time with a full model unload + cache clear between every chunk,
3. anchors each seam to the previous chunk's final frame (pixel-exact I2VA keyframe + reference picture),
4. stitches the result into one continuous video + audio clip with seam duplicates removed.

It is a conductor, not an engine: every model patch in your graph — turbo LoRA, MultiLoRA, EasyCache, spectrum, sage attention, scheduled attention, preview override, block swap, sigma shift, chunk feed-forward, W4A8 loaders — stays exactly as you wired it. The Director wraps the existing loader/sampler stack and treats it as opaque.

cd ComfyUI/custom_nodes
git clone https://github.com/Luisacaotica/ChaoticMinimaxH3Director_WIP.git

Restart ComfyUI. The nodes appear in the Chaotic/H3 Director menu and the timeline editor loads in the browser.

No extra Python dependencies. The engine reuses av, torchaudio, numpy and torch already shipped with your ComfyUI install.

The stock MiniMaxH3ReferenceToVideo node (or Deno variant) does not need to be in the graph anymore — the Director replicates its conditioning path internally, then adds chunking, seam anchoring and stitching on top.

MiniMax H3 is omni-modal: it generates video and audio in one latent stream. Set the video latent to 32×32 and nearly all the model's capacity goes into the audio — a full radio play with distinct, reference-consistent voices and a continuous ambient bed, generated locally, no video needed. The recipe below is reverse-engineered in the community write-up (see Credits); the ChaoticH3RadioPlayPlanner node applies it for you.

The recipe (what the planner outputs):

1. Audio-only latents — 32×32, so the video stream is trivial and the audio gets the compute.
2. ≤15 s segments — H3's native output window is ~4–15 s; past that quality collapses. Frames snap to the 17k+5 grid: max(5, round(seconds * fps)) + (5 - (max(5, round(seconds * fps)) % 17)) % 17 (15 s @ 24 fps → 362 frames).
3. Word budget — natural conversation is ~2–2.5 spoken words/s; a dialogue-dense 15 s clip holds ~30–38 words. Over budget → rushed, clipped lines; under budget → invented mumbling. Count words before you count segments.
4. Explicit endings — never tell the model when to stop; tell it what it ends on: "Finally, … This is the final sound. No speech occurs after this." The planner auto-appends this per segment (and keeps yours if you wrote one).
5. Voice casting — one neutral in-character sample per character, generated in isolation; bind declaratively in subject_definitions: (<Video 1> is the voice timbre reference for Priya (S1) …), keep the same (Sx) IDs across segments, and state their dialogue is not carried into the target.
6. The ambience fix — wire voice samples into the reference-video soundtrack slots (refvideoaudios 0/1/2 → <Video 1/2/3>), keep ref_audio empty. Voices in ref_audio produce dry studio speech with no bed; in the soundtrack slots they mix over a prompt-written bed.
7. Identical soundscape — the overall_soundscape: paragraph is byte-identical in every segment so the joins are invisible.
8. Assembly — trim 50–200 ms off every segment head (boundary ghost) and crossfade ~150 ms on the joins. res_multistep + beta, ~30 steps, fp32 audio VAE.

Script format (paste into the script input):

# Cast
S1: Priya, a warm, teasing woman in her late twenties.
S2: Marcus, a deep-voiced, gravelly older man.
S3: Ethan, a younger man with a dry, deadpan delivery.

# Scene
Three friends camped by a small fire in a pine forest at night.

# Ambience
Continuous campfire crackle, light wind through pine trees, occasional insects…

# Music
N/A

Priya (S1) says, [teasing, bright]: "You were the one who said, let's experience the wilderness." [giggles]
Marcus (S2) replies, [gravelly, amused]: "And I stand by it."
[An owl screeches close by, startling all three.]
…
Finally, the fire crackles low and the wind gentles. This is the final sound. No speech occurs after this.

Sections are optional (# Cast, # Scene/# Setting, # Ambience/# Soundscape, # Music, # Dialogue/# Script); [bracket] lines are stage directions / sound effects ("[Two seconds of only fire and wind.]" becomes a 2 s beat), and bracketed cues after dialogue ([giggles]) become vocalizations. Undeclared speakers are auto-registered with a note.

Outputs: recipe_json (per-segment frames/words/beats + the wiring, sampler and post-recipe), segment_prompts (the full six-part prompt per segment, ready to paste), segment_count, and issues (word-budget overruns, under-filled segments, missing ambience, cast > slots, beats past the native window).

Open workflows/ChaoticDirector_H3.json — a 3-shot, ~10.5 s scene that demonstrates automatic chunking at 5 s chunks with auto-bridged seams. Every loader and patch node from the reference graph is preserved; the Director replaces the sampler/conditioning/decode/cache-clear machinery.

model       <- the FINAL patched model (after turbo LoRA / MultiLoRA / EasyCache /
               spectrum / sage attention / scheduled attn / preview override /
               block swap / sigma shift / chunk feed-forward) — the node that
               used to feed BasicGuider
clip        <- your CLIP (e.g. CLIPLoaderGGUF → UniBlockSwapTE)
vae         <- the video VAE
audio_vae   <- the audio VAE
sampler     <- (optional) your MiniMaxH3TurboSampler — if omitted the Director
               builds a KSampler from sampler_name/scheduler/steps
sigmas      <- (optional) SIGMAS from your BasicScheduler — if omitted the
               Director builds its own schedule from the wired model
seed        <- any seed node
width/height<- your resolution selector

images      -> CreateVideo.images        audio -> CreateVideo.audio

Outputs are IMAGE + AUDIO in the exact stock shape, so CreateVideo / SaveVideo / VHS consume them unchanged.

Open a Chaotic H3 Mockup Editor node (under Chaotic/H3 Director) to sketch the staging:

0. Match the target format — click an Aspect preset in the toolbar (16:9 / 9:16 / 1:1): it reshapes the stage and sets the render width/height widgets to that format, so a phone-vertical video (9:16) or square post composes exactly as it will render. Edit the width/height widgets freely for a custom aspect — the stage follows. The aspect is saved with the scene and with the project file.
1. Import background/character/prop PNGs (with transparency), videos, or add text layers.
2. Pose them on the stage — layer order is front-to-back; drag a layer to move it (auto-keys), or set the playhead, press Key, and adjust X/Y/Scale/Rotation/Opacity in the inspector.
3. Between keyframes the motion is interpolated; a layer is only visible between its first and last keyframe — that's how you make cuts and entrances. Select a key and set its Ease in the inspector: linear, in (slow start), out (slow end), inout (smoothstep), or hold (pose holds, then jumps at the next key — a hard cut on that layer). Keys are color-coded on the strip and the selected layer's interpolation curve is drawn between them, so you can see the easing you're authoring.
4. Opacity is reference strength — a 40% character literally shows the background through it, exactly like a weak <Picture> reference.
5. Add an audio track to scrub while you animate.
6. Render the mockup to frames, then wire its IMAGE output into the Director's optional mockup input.

The Director then feeds every chunk its slice of the mockup as a fully_preserved <Video N> storyboard reference — H3 reproduces the layout, positions, layering, and motion as the blueprint for the final clip. It will look like a bad mockup — that's the point.

REC (mouse recording) — hit REC in the toolbar, select the channels you want to capture (Position / Size / Rotation), and just move the layer on the stage with the mouse. A take of keyframes is laid down at the capture rate — record each channel separately, Cappuccino-style, for fast iteration. REC turns itself off when you release the mouse.

Open a Chaotic H3 Video Edit node — this one is only about editing existing footage:

1. Feed it a video (or load one in the widget) and scrub with the ruler — the exact frame is previewed so you can make precision cuts.
2. Paint a brush or square mask on the frame. Keyframe the mask over time (it cross-fades between keys, so a box can grow/shrink/travel). Or paint once and hit Track Mask: the tracker locks onto the painted region and follows the subject forward and backward, writing the mask keyframes automatically — tweak Every (frame step), Search % (window size), Score ≥ (correlation floor) and Refresh (template update rate), then scrub to review; where the subject is lost the tracking stops and tells you, so you can drop a manual key and re-track. Pick inpaint (edit the masked area) or outpaint (edit everything outside it).
3. Choose the output: plate — the masked region on a black or green void (clean a plate, or a local hires-fix for a bad face/hand — only the region is regenerated, everything else stays untouched); crop — only the masked region, at full or selected resolution, aspect-locked.
4. The node's mask output feeds the ComfyUI inpaint conditioning (set_cond_area → the area you chose); run any H3 inpaint pass on the plate.
5. Chaotic H3 Composite Patch pastes the AI-patched clip back onto the source video at the exact box — masked by the alpha MASK so the seam is whatever H3 painted.

Green-screen mode — flip the node to chroma: it key-matches the backdrop color (similarity / smooth / spill sliders) and outputs an RGBA IMAGE + alpha MASK with a checkerboard preview — transparency visible right on the timeline. Not just green: hit Green / Blue / Magenta preset, pick any color from the swatch, or press Detect to grab the most prominent border color of the current frame. Flip Auto on and the node re-detects the dominant backdrop from frame 0 at render time — pick the color once, preview what you'll get, and let the render match it. Feed the keyed character into a Mockup Editor RGBA video layer, keyframe a background behind them, and match lighting — no inpaint needed, the context does the work.

Reframe mode — flip the node to reframe: the widget shows the target window over your clip (dimmed outside = the outpaint region) with a live readout (reframe 1280×720). Pick an Aspect preset or type a custom W×H, choose Feather for a soft boundary, and place the source window with Align H (L/C/R) + Align V (T/M/B) — or switch to the ✥ Move window tool for full transform control: drag the window body to position it anywhere (release to snap; it stays clamped inside), grab the ↻ rotate handle above the window to spin it (−180…180°, Shift snaps to 45°), or the ▢ scale handle on the corner to resize (0.1×–4×, Shift snaps to 10%) — the panel's Size/Rotate fields stay in sync and the brush strokes, fill-rects, and copy-to-reference grabs all map through the window transform, so painting follows the rotated/scaled content (strokes in the dim void are ignored). The Fit toggle below the aspect presets switches between Contain (default: at 100% size the window fills the tight axis, max resolution, but can only travel along the other axis) and Smaller (base fit × 0.8 — at 100% size the window keeps margin on both axes, so the move tool can drag it to any 2D position: floating a 16:9 window anywhere on a 9:16 canvas, a picture-in-picture on a same-aspect background, or any free composition — the 20% factor is shared with Python's SMALLER_FACTOR and cross-checked in tests). An oversized window pins its center inside the canvas while its edges overflow, and the preview is pixel-identical to the plate (the geometry is cross-checked against the Python reframe_plate in tests). The node then outputs a target-resolution plate (images) with the source fitted inside and the outside masked (mask = 1 where to outpaint) — feed it into your H3 outpaint pass and composite back with ChaoticH3CompositePatch (full-frame box 0,0,tw,th). Edge-crossing people/objects: brush strokes in reframe mode become preserve regions — anything you paint stays intact while everything else outside the window is outpainted, so a passer-by at the edge is completed rather than erased (and with rotation/scale the strokes are warped through the same transform, so they stay glued to the content). Prefer hands-free: press 🛰 Auto-preserve in the reframe panel — it motion-detects blobs entering the letterbox band, locks an NCC template onto each object, tracks it forward and backward through the clip (reusing the same tracker as Track Mask, with template refresh), and writes the preserve mask keys automatically — brush strokes are merged (union) with the tracked blobs, never overwritten. Tune the scan stride (0.1–2 s, default 0.5) and max objects (1–6) to match how fast things cross the frame.

Keep a moving subject framed — 🎯 Track subject: instead of a static window, paint the subject once at the playhead frame with the Brush (preserve) tool, then press 🎯 Track subject. It locks an NCC template onto the painted region and tracks it forward and backward through the clip (the same tracker as Track Mask, with template refresh) — and for every tracked position it writes a position keyframe (reframe.track: [{t, ax, ay}]) that centers the window on the subject, rotation-aware (the framing math inverts the window transform, so it stays correct when the window is rotated or scaled). The preview scrubs through these keys and the plate is rendered per frame, so the outpainted result keeps the subject framed exactly as you saw it. The keyframe count shows in the panel; once a track exists, dragging the window (or hitting Align H/V) adds/overrides a key at the playhead — a manual keyframe editor on top of the auto-track — and ✕ Clear track returns the window to static alignment. Tracks serialize with the project like every other edit.

Copy to reference — in the Video Edit node, draw a rectangle (Rect tool) and press ⧉ Copy to ref: the crop is captured from the frame at the playhead, added to the thumbnails strip, and decoded into the ref_images IMAGE output — wire it into H3's reference inputs for precise edits/removals (the meta JSON reports ref_count). Every crop is also uploaded to ComfyUI's input folder, so ⤴ Export crops (in the refs strip) shares them through input/chaotic_h3_crops.json — the Director's 📥 Crops toolbar button then imports each crop as an untimed, draggable <Picture N> library card (drag it into any prompt or onto the timeline), and the Mockup Editor's 📥 Crops adds them as image layers on the stage. In the Director, the preview strip has its own ⧉ Copy to ref that captures the frame under the playhead and drops it into the reference library as an untimed <Picture N> card.

Framerate — the fps widget on every node is the fixed latent frame rate (default 24, user-settable 1–120): the Director, Mockup and Video Edit all render their latents at exactly that rate. The Video Edit widget measures your source clip's real framerate on load and shows fps: node 24 | file ~29.97 ⚠ mismatch when they disagree — press Use file fps to align them, because mask key times are authored in seconds and drift when the render rate differs from the file. The node also logs a warning at render time if video_fps disagrees with the widget. Keep the rate fixed, keep it matching your sources.

tools/build_workflow.py rewires any single-pass H3 workflow into the Director graph — every loader/patch node kept byte-for-byte, discovery is link-driven (no hard-coded node ids):

python tools/build_workflow.py path/to/MiniMax_H3_MYWFEXAMPLE.json
python tools/verify_workflow.py      # strict structural validation

Pre-chunked manual workflows (e.g. MinimaxLuisa_Chunked.json) are exactly the thing this pack automates — the Director replaces them, so they are not a valid source.

The Director node embeds a full DOM timeline widget (a custom ComfyUI widget — not sockets):

• Import media by drag & drop onto a track or via file dialog. Thumbnails are auto-generated (video: first frame; audio: waveform strip; picture: the image).
• Trim any reference with its in/out handles directly on the timeline.
• Strength sliders per reference map onto H3's retention_analysis bands — the label shown is what the Director will actually emit.
• Subject shortcuts — type S1/S2 (or @name) in a shot's text; it is live-validated against the references active at that timeline position.
• Chunk boundaries are drawn on the timeline so you see exactly where an automatic cut will fall — drag a boundary to pin it, or snap it to a shot break.
• Project scaffolding panel: format toggle (official / narrative), LoRA trigger token, style clarification line, and the full field set for the chosen format. Switching format updates the field set instantly — no re-click needed.
• Per-shot format override — strict shot/timestamp control on action sequences, looser narrative phrasing on dialogue, in the same timeline (the format is shown as a badge right on the shot block).
• Scrub preview — drag on the ruler to move the playhead; the video or picture under it appears in the preview strip, with its own play/seek controls locked to the reference's trim range.
• Reference library — drop files into the library panel (or flip any ref to Library placement) to keep them out of the timeline but available to every shot.
• Render window — set IN/OUT markers on the ruler (or at the playhead via the toolbar buttons); everything outside the window is shaded, and only that range renders.
• Save / Load — export/import the full project as a .json file (the reference LTX-style workflow: works standalo