MiniMax H3 → LTX · Tiled AV Refinement

Tiled sampling is one of those ideas that sounds trivial and isn't. Split the image into tiles, sample each, blend the seams - what could go wrong. What goes wrong is the seams: visible grid lines, temporal flicker where the tile boundaries land, and audio that no longer knows what picture it belongs to.

MiniMax H3 → LTX · Tiled AV Refinement is the pack's answer for the delivery stage of an H3 → LTX pipeline: a drop-in replacement for the standard advanced sampler that bounds the working set by sampling bounded temporal and spatial tiles of the joint audio-video latent, with feathered blending and the audio passed through intact.

What it is

Input-wise it's deliberately boring, because it's meant to be swapped into an existing graph:

• noise, guider, sampler, sigmas, latent_image - exactly what SamplerCustomAdvanced takes
• cine_linx (optional) - the bus, where the tiling settings live

Outputs are output and denoised_output, both LATENT, mirroring the sampler it replaces. Wire them where you wired the originals.

The reason it takes the same five inputs is the reason you should care: this isn't a new sampling paradigm. It's the same sampler, called repeatedly on bounded regions, with the results composited. Which also means your sampler, sigmas and guider choices still matter. Tiling doesn't fix a bad schedule.

How it works

The node insists on the joint AV latent - a nested tensor with exactly two streams. If your latent is video-only, it raises, because the whole point is keeping picture and sound aligned through the refinement.

It reads tiling parameters out of the plan's LTX looper settings: temporal tile size, temporal overlap, spatial overlap, horizontal and vertical tile counts. Then it converts frame sizes to latent windows using LTX's 8-frame temporal stride for its video VAE, and clamps the window to something sane (a couple of latent frames up to nine). Temporal tile size of 80 in pixel terms becomes a 9-latent-frame window; an overlap of 24 becomes 3 latent frames.

The size calculation also caps each tile at 4096 tokens, shrinking height and width until it fits. That cap is the actual memory guarantee - it's what stops a "tile" from being a quarter of a 4K frame and blowing the budget you were trying to save.

Then it walks the grid: for each temporal window, for each spatial tile, it clones the region, slices the matching audio span for that time interval (accounting for the causal first frame), builds a per-tile noise object from the original noise so seeds stay consistent, copies the guider and stamps the frame rate into its conditions, and calls SamplerCustomAdvanced. Results are accumulated with separable 3D weights that ramp across the overlaps, and finally divided by the accumulated weights - so overlapping regions get a proper feathered crossfade rather than a hard average. That's the difference between a seamless tile and a visible lattice.

The audio is the part I'd point at. Each tile gets the audio slice for its time span, denoised with a zeroed audio mask, but what comes back into the output latent is the original audio, untouched. The refinement pass does not degrade your soundtrack while chasing detail in the picture. Given how much of LTX-2's reputation rests on native audio (and how brittle that audio is to edits), that's the right call.

One thing to check on your side: without cine_linx the node falls back to defaults, which means one spatial tile in each direction and only temporal windowing. Windowed-temporal-only is still a real VRAM saving, but if you were expecting spatial tiling you won't get it - the settings come from the bus.

Install

Ships in IAMCCS-nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/IAMCCS/IAMCCS-nodes.git

Restart and hard-refresh. Or ComfyUI Manager → search IAMCCS Nodes. Keep one copy.

No pip requirements in the pack itself. You need the full LTX AV stack available (video VAE, audio VAE, the LTXV AV latent nodes) plus whatever LTX model and distilled LoRA your refinement uses. ComfyUI 3.0.0+. This node is CPU-plus-GPU churn heavy - it deliberately moves tensors to CPU between pieces, so expect it to be slower than an untiled sampler that fits. That's the deal: it runs, but it isn't free.

Common issues

"Requires the existing joint LTX AV latent." You fed it a separated or video-only latent. Put LTXVConcatAVLatent upstream.

Grass or texture changes character in bands. Overlap too small. Push the temporal overlap up so adjacent windows share more context; the weighting is smooth but it can't invent agreement between regions that never saw each other.

Out of memory anyway. Check the token cap is being honoured - this happens when the plan's horizontal/vertical tile counts are set to 1 for a large frame. More tiles, smaller pieces.

Slow, and no visible seams. That's the correct outcome. This node is boring and slow on purpose; the version of the same upscale that's fast is the version that either fits in VRAM untiled or produces grid lines.

Audio and picture out of sync afterwards. Shouldn't happen given the audio passthrough, but if it does, look upstream - a mismatched fps between the plan and the guider conditions is the usual culprit, and this node stamps the plan's fps into every tile's conditions.

Where it fits

MiniMax H3 → LTX · Resume Saved Native → LTX refine stack → this → decode → export. It's the pebble in the shoe of the H3-to-LTX delivery path, and the reason that path is viable on 16-24GB cards rather than reserved for a 5090.