LTX Attention Profiler

A ComfyUI custom node suite for profiling, visualizing and steering attention heads in LTX-Video 2.3 (distill & dev).

Built for research on attention-based video generation control — spatial/temporal head specialization, attention map transfer, keypoint tracking and cross-modal (audio↔video) dynamics.

⚠️ Work in progress. This toolkit is under active development. Node inputs/outputs, store formats, and naming can change at any time — including breaking changes without backward compatibility. Existing workflows and saved .pt files may stop working after an update.

---

Features

• Profiling — capture self-attention and cross-attention maps for any subset of blocks, heads and denoising steps
• Metrics — per-head entropy, temporal locality, spatial locality, sink mass — computed chunked on GPU, stored on CPU
• Visualization — key maps, query maps, metrics heatmaps, timestep evolution curves, full grid overview
• Intervention — head freeze (lock an attention map at a pivot step), Q/K/V transfer between two generations
• IO — dump/load stores to .pt for offline analysis and cross-run comparison (dev vs distill, prompt A vs prompt B)

---

Installation

cd ComfyUI/custom_nodes
git clone https://github.com/g-raw/ComfyUI-LTX-Attention-Toolkit.git

No extra dependencies beyond what ComfyUI already provides (torch, numpy).

---

Project structure

nodes_ltx_attention_profiler/
├── __init__.py              ← ComfyUI entry point
│
├── core/
│   ├── stores.py            ← StoreRegistry (named, non-singleton) + AttentionStore/QKVStore proxies
│   ├── hooks.py             ← Universal hook on optimized_attention
│   └── model_patch.py       ← _forward wrap/unwrap + block hooks
│
├── ops/
│   ├── freeze.py            ← Head freeze intervention
│   └── qkv_transfer.py      ← Q/K/V substitution transfer
│
├── nodes/
│   ├── capture.py           ← CaptureSetup (metrics + key/query/full maps + optional raw QKV)
│   ├── transfer.py          ← HeadFreeze, QKVTransfer
│   ├── visualize.py         ← QueryMap, KeyMap, MetricsViz, GridViz
│   ├── evolution.py         ← TimestepEvolution
│   ├── io.py                ← StoreDump/StoreLoad (Attn + QKV, one file)
│   ├── inspect.py           ← Store inspect nodes
│   └── utils.py             ← LatentDims, CompareRuns, HeadCandidates
│
└── utils/
    ├── graphics.py          ← Colormaps, grid rendering, Bresenham
    └── helpers.py           ← Call counter, parse helpers, logging

---

Nodes reference

Capture

LTX Attn — Setup Capture

Patches an LTX-2.3 model to capture attention metrics, reduced key/query maps, optionally full attention maps, and optionally raw Q/K/V — one capture path, one node, real metrics in every mode.

| Input | Type | Description | |---|---|---| | model | MODEL | LTX model to patch | | capture_sa | BOOL | Capture self-attention (applies to both the metrics and the QKV capture below) | | capture_ca | BOOL | Capture cross-attention (video→text), same scope | | target_blocks | STRING | "all" or "0,8,16,24,32,40,47" — drives the metrics/key/query/full maps only | | target_heads | STRING | "all" or "8,12,16" — RAM filter for the metrics/key/query maps | | capture_steps | STRING | "all" or "0,1,2,3" — shared by metrics and QKV capture | | store_mode | ENUM | reduced / full_fp16 / hybrid | | full_blocks | STRING | Blocks stored at full res (every head) when hybrid. A block also listed in full_targets uses that block's per-head selection instead; full_blocks still applies normally to any block full_targets doesn't cover — the two combine | | full_targets | STRING | Optional, hybrid only — for the blocks listed here, restrict full-map storage to specific (block, head) pairs instead of every head. Same format as qkv_targets/Head Freeze's targets below | | map_downsample | INT | Spatial downsample factor for full maps | | (QKV capture — separate from the attention-map settings above) | | | | capture_qkv | BOOL | Also capture raw Q/K/V per head into a separate QKV store, for QKV Transfer | | qkv_targets | STRING | Only used when capture_qkv is on. Independent of target_blocks/target_heads above — its own (block, head) list, since raw Q/K/V is far more expensive than the metrics/key/query maps. Same format as full_targets/Head Freeze's targets: paste Head Candidates' candidates_csv, or type block:head \| block:h1,h2,... \| block:all \| .... A whole-string "all" (or "all:all") captures every block and head | | store_name | STRING | Empty = new auto-named handle every run. Given a name, re-running reuses that same handle (get-or-create) instead of spawning name_2, name_3, … Applies to both the attn and the QKV store — they can't collide, they live in separate registries | | reset_store | BOOL | With a named store_name: clear that handle (both stores) before capturing. With it blank, the handle is always fresh already, so this has no effect |

reduced always includes the real entropy/temporal/spatial/sink/ frame_dist_mean/frame_dist_std/spatial_dist_mean/spatial_dist_std metrics (plus _norm variants of the last four, see below) and key_map/query_map (geometry auto-detected from the live latent — no manual frame/height/width inputs needed). full_fp16/hybrid additionally store the full [H, Sq, Sk] map for the relevant blocks — except for any block listed in full_targets, where only the listed heads' maps are stored for that block (a sparse {head_idx: [Sq, Sk]} dict instead of the full [H, Sq, Sk] tensor), to avoid paying for every head when you already know exactly which ones you'll feed into Head Freeze. full_blocks still applies normally to every other block. Head Freeze and QKV Transfer read a single head either way and don't care which form it is; Query Map/Key Map/Zone Analysis need every head and will raise (or silently skip that block/step) on a sparse map — put that block in full_blocks instead if you need those.

capture_qkv is not redundant with full_fp16/hybrid — see "Attention map vs. raw Q/K/V" in Architecture notes below for why.

Memory estimates (1280×720, 16 frames, 32 heads, 4 steps) :

| Mode | RAM | |---|---| | reduced (all 48 blocks) | ~332 MB | | full_fp16 (5 blocks) | ~16 GB | | hybrid (5 full + 43 reduced) | ~16.3 GB |

Outputs a patched MODEL and a single handle STRING — the same name is used for both the attn store and (if capture_qkv is on) the QKV store, since they live in independent registry namespaces and can't collide. Plug the model between loader and KSampler, and type handle into any visualization/intervention node's store_handle/qkv_handle widget in a later run (see "Hook architecture" below for why this is a separate-run handle rather than a wired socket).

---

Visualization

LTX Attn — Key Map

"Which tokens are being looked at?"

Reduces the query dimension → reshapes keys into [F, H_lat, W_lat]. SA only (keys are video tokens with spatial geometry).

| Input | Type | Description | |---|---|---| | block_idx | INT | Block to visualize | | step_idx | INT | -1 = last captured step | | head_indices | STRING | "all" or "8,12,16" | | query_token_idx | INT | -1 = average over all queries | | aggregate_frames | ENUM | mean / max / first | | cell_size | INT | Pixel height of each head cell |

---

LTX Attn — Query Map

"Which tokens are actively looking?"

Reduces the key dimension → reshapes queries into [F, H_lat, W_lat]. Works for both SA and CA.

For CA: shows which video regions are attending to text tokens. Set key_token_idx to isolate a specific text token.

---

LTX Attn — Metrics Heatmap

2D heatmap: X = blocks, Y = heads, color = metric value. Always normalized per-image (min→max of whatever the metric's actual range is in this store — most of these metrics aren't natively in [0, 1], so without normalizing the whole heatmap just clips to a single color) — a numeric colorbar is stamped along the bottom showing that literal [min, max] range, so the direction is never divorced from the magnitude.

| Metric | Meaning | |---|---| | entropy | High = diffuse attention (global head). Low = focused. | | temporal | High = attends across frames (motion/coherence head). | | spatial | High = attends within same frame (texture/structure head). | | sink | High = attention mass on first/last token (sink head). | | frame_dist_mean | Attention-mass-weighted average \|frame_k - frame_q\|, in frames (SA only). High = looks at temporally distant frames. | | frame_dist_std | Spread of that frame-distance distribution, in frames (SA only). High = mixes near and far frames; low = attends at a consistent temporal offset. | | frame_dist_mean_norm / frame_dist_std_norm | Same, divided by num_frames - 1 so they stay in [0, 1] and comparable across runs with a different number of frames. | | spatial_dist_mean | Attention-mass-weighted average Euclidean distance, in patch units (same-frame pairs only), between query and key patch positions (SA only). High = looks at spatially distant tokens within the frame. | | spatial_dist_std | Spread of that spatial-distance distribution, in patch units (SA only). High = mixes near and far patches; low = attends at a consistent spatial offset. | | spatial_dist_mean_norm / spatial_dist_std_norm | Same, divided by the patch-grid diagonal sqrt(latent_h² + latent_w²) so they stay in [0, 1] and comparable across runs at a different spatial resolution. |

step_idx = -1 averages across all captured steps. All eight frame_dist_*/spatial_dist_* fields are 0 for cross-attention (frames/patch positions don't apply to text tokens) and whenever the SA map doesn't match the num_frames × patches_per_frame geometry. Prefer the _norm variants whenever comparing across runs that don't share the exact same num_frames/latent_height/latent_width — the raw values alone aren't apples-to-apples in that case.

---

LTX Attn — Grid Viz

Full overview grid read from a capture STORE_HANDLE. X = blocks, Y = heads, each cell = key_map, query_map, or their diff. Every 8th row/column gets a separator line, same as Metrics Heatmap/ Compare Runs, to make it easier to count blocks/heads at a glance.

frame_mode options:

| Value | Result | |---|---| | avg | Average over all frames → 1 grid | | all | Frames stacked vertically in each cell → 1 grid | | sequence | One grid per frame → IMAGE batch | | 0 or 3,7 | Specific frame index(es) |

normalize options: global / per_cell / per_block / per_head

---

LTX Attn — Timestep Evolution

Line chart: metric value vs denoising step for selected heads. One colored curve per head.

Useful to identify:

• Flat curves → structurally fixed role
• Monotone decreasing → specializes progressively
• Crossing curves → heads swap roles mid-denoising
• Late rise → semantic tracking activated once signal emerges

---

Intervention

LTX Attn — Head Freeze

Locks the attention map of one or more heads starting from a pivot step — a single node instance can target several (block, head) pairs at once (no need to chain one node per head).

Requires a prior capture run with store_mode=full_fp16 (or hybrid for that block).

| Input | Type | Description | |---|---|---| | targets | STRING | One or more (block, head) pairs. Paste Head Candidates' candidates_csv directly (one block,head per line), or type manually as block:head \| block:head \| ... — use block:all to freeze every captured head of a block in one entry. Blank = disable (see below) | | freeze_from_step | INT | Step at which freeze activates | | freeze_step_source | INT | Which captured step's map to use | | blend_weight | FLOAT | 1.0 = pure frozen, 0.5 = 50/50 blend — shared across every target, no per-head override yet | | store_handle | STRING | Optional — target a specific named store. Blank = whichever store is currently active |

freeze_from_step/freeze_step_source/blend_weight apply to every target the same way. If you need different values per head, chain multiple Head Freeze nodes instead — targets only saves the chaining when the shared settings are fine.

To disable, clear targets — don't use ComfyUI's node bypass/mute. This node patches the diffusion model's _forward directly, and that underlying model object is shared across every model.clone() in the session (not recreated per run). A normal execution unwraps that patch before reapplying it, but ComfyUI's bypass/mute skips the node's function entirely, so a stale patch from an earlier run is never cleaned up and stays in effect even though the node "looks" disabled. An empty targets field still runs the node's code, so it reliably unwraps and passes the model through untouched.

---

LTX Attn — QKV Transfer

Injects Q/K/V from a source generation into a target generation.

targets uses the same format as Head Freeze's targets (both parsed by parse_block_head_pairs), plus a whole-string all:

# Head Candidates CSV (one 'block,head' pair per line)
24,8
24,12
32,16

# Manual — one block, several heads
targets = "24:8,12,16"

# Manual — several blocks, mixed
targets = "24:8,12 | 32:all | 40:0,4,8"

# Every block/head captured in the QKV store
targets = "all"

block:all (or a whole-string all) resolves against whatever heads were actually captured for that block/source_step in the QKV store.

Transfer modes (combinable):

| Flag | Effect | |---|---| | use_k + use_v | Classic style transfer (mode D) | | use_k only | Key-only steering | | use_map | Inject raw softmax map, bypass Q/K/V | | use_q + use_k + use_v | Full QKV replacement |

sim_filter: only transfer tokens where Q_target ≈ Q_source (cosine similarity threshold) — useful for content-preserving transfer.

handle (STRING, optional): target a specific named QKV store — the same handle string output by Setup Capture. Blank = whichever QKV store is currently active.

To disable, don't select any transfer flag (or blank targets) — don't use ComfyUI's node bypass/mute. Same reasoning as Head Freeze: this node patches the shared diffusion_model directly, and bypass/mute skips this node's cleanup entirely, so a stale patch from an earlier run stays in effect. Turning off every use_* flag, or blanking targets, still runs the node's code and reliably unwraps instead.

---

LTX Attn — QKV Multiplier

Scales attention sharpness and/or output magnitude per targeted head — a live multiply, no prior capture needed. Amplify a head (> 1.0) or try to kill it (0.0), or several at once.

| Input | Type | Description | |---|---|---| | targets | STRING | Same format as Head Freeze/QKV Transfer: paste Head Candidates' candidates_csv directly, or block:head \| block:h1,h2,... \| block:all \| .... A whole-string all (or all:all) targets every block (0-47) and head (0-31). Blank = disable (see below) | | apply_sa / apply_ca | BOOLEAN | Which attention type(s) to affect | | qk_mult / vo_mult | FLOAT | Per-head multipliers, shared across every target (-10.0–10.0, default 1.0 = no-op) | | from_step / to_step | INT | Denoising step range (per targeted block) the multiply is active for. Defaults to the full range (0–999) |

qk_mult vs. vo_mult — these are not interchangeable: qk_mult rescales the softmax logits before the attention weights are computed — it changes how sharp or flat the head's attention distribution is. Setting it to 0 doesn't ablate the head, it just makes it attend uniformly over every key (still contributes via V, just unfocused). vo_mult scales the head's actual contribution to the output — 0 genuinely zeroes the head out. Use vo_mult to kill/amplify a head's influence; use qk_mult to experiment with attention sharpness instead.

(There's no separate q_mult/k_mult or v_mult/o_mult pair: scaling Q and K independently only ever matters through their product on the logits — Q and K are each a uniform per-head scalar, so q_mult × k_mult is all that shows up in the math, hence one qk_mult knob. Same reasoning collapses V/O into vo_mult: V is scaled before the (linear) attn_weights @ V matmul, O after, so only the product affects the result.)

To disable, clear targets — don't use ComfyUI's node bypass/mute. Same reasoning as Head Freeze/QKV Transfer: this node patches the shared diffusion_model directly, and bypass/mute skips this node's cleanup entirely, leaving a stale patch from an earlier run in effect. Blanking targets still runs the node's code and reliably unwraps instead.

---

IO & Debug

| Node | Description | |---|---| | LTX Attn — Store Dump | Save the AttentionStore and/or QKVStore to one .pt | | LTX Attn — Store Load | Load AttentionStore and/or QKVStore sections from a .pt | | LTX Attn — Compare Runs | Diff heatmap + ranked (block, head) table for one metric between two runs | | LTX Attn — Head Candidates | Combine several metrics' zscore diff into one composite score, shortlist candidate + control (block, head) groups | | LTX Attn — Store Inspect | Print AttentionStore contents (incl. key/query map presence) | | LTX Attn — QKV Store Inspect | Print QKVStore contents | | LTX Attn — Latent Dims | Extract T/H/W from a LATENT | | LTX Attn — Reset Patches | Clear every registered intervention/capture layer on a model and restore the pristine forward — see "Chaining multiple intervention/capture nodes" below |

Store Dump/Store Load take a single handle STRING input — the same name is used to resolve both the attn store and the QKV store, mirroring Setup Capture's unified handle output. On dump, an empty handle falls back to whichever stores are currently active; an explicit handle raises clearly if no attn store exists under that name (a typo isn't silently swallowed), but a missing QKV store under that name is silently skipped (capture_qkv may simply have been off for that run) — the dump still succeeds as long as at least one of the two resolves. On load, each section present in the file goes into that name ("default" if blank, get-or-create); Store Load returns the resolved handle as an output so you can wire it straight into downstream nodes instead of retyping it. This matters once multiple stores coexist — parallel branches, multiple captures in one session.

LTX Attn — Compare Runs details

Compares one metric — including the _norm variants of the distance metrics, which is what you want here if the two runs don't share the exact same num_frames/resolution — between two captures, block-by-block and head-by-head, for self- or cross-attention. Reads both stores live from the registry by handle — to compare a dumped .pt, load it into a handle first with Store Load.

| Input | Type | Description | |---|---|---| | store_handle_a / store_handle_b | STRING | The two stores to compare | | attn_type | ENUM | sa / ca | | metric | ENUM | entropy / temporal / spatial / sink / frame_dist_mean / frame_dist_std / frame_dist_mean_norm / frame_dist_std_norm / spatial_dist_mean / spatial_dist_std / spatial_dist_mean_norm / spatial_dist_std_norm | | step_idx | INT | -1 averages across all captured steps | | top_k | INT | How many (block, head) pairs to list, ranked by \|diff_mode score\| | | norm_percentile | FLOAT | Clip the heatmap color scale at this percentile of the diff_mode score (default 0.98) so a few outlier cells don't wash the rest out to white — 1.0 uses the true max | | colormap | ENUM | diverging (default, 0 = black) / coolwarm (0 = near-white) / viridis / inferno | | diff_mode | ENUM | absolute / relative_pct / zscore — see below |

Sign convention: raw diff = A - B — positive (red) means A's value is higher, negative (blue) means B's is higher. stats_text prints which handle is A and which is B so this is never ambiguous from the image alone. The output IMAGE has a numeric colorbar stamped along the bottom (-clip_val / 0 / +clip_val, in diff_mode's units) so the actual magnitude is readable, not just the direction.

Why diff_mode matters: the four metrics don't share a scale — sink is a bounded probability-like quantity while temporal/spatial are unnormalized raw scores that can range much wider. A raw A - B of similar magnitude can mean "huge proportional change" on one metric and "noise" on another, so don't compare raw diffs across metrics directly.

| Mode | Formula | Use for | |---|---|---| | absolute (default) | A - B, in the metric's own units | Looking at one metric in isolation | | relative_pct | (A - B) / max(\|A\|, \|B\|) * 100 | "% change" — comparable in spirit across metrics | | zscore | (A - B) / std(A and B combined) | Diff in units of that metric's own spread — the most apples-to-apples way to ask whether one metric moved proportionally more than another |

stats_text also reports min/max (alongside mean/std) for A and B separately before any diffing, so you can see each metric's intrinsic value range up front.

Blocks are aligned by their actual index (not column position), so the two runs don't need identical target_blocks. Outputs a diff heatmap IMAGE plus a stats_text STRING with summary stats and the full top-top_k ranked table — run it once per metric, then compare which (block, head) pairs recur across metrics to spot structurally divergent heads vs. metric-specific noise.

LTX Attn — Head Candidates details

Automates that last step: instead of running Compare Runs once per metric and manually cross-referencing which (block, head) pairs recur, this combines several metrics' zscore diffs into one composite score per head — mean(|zscore(A - B)|) across the metrics you list — and outputs a ranked shortlist plus a control group, as plain text (not a heatmap) so you can copy block,head pairs straight into Head Freeze.

| Input | Type | Description | |---|---|---| | store_handle_a / store_handle_b | STRING | The two stores to compare | | attn_type | ENUM | sa / ca | | metrics | STRING | Comma-separated metric names, e.g. temporal,frame_dist_mean_norm,frame_dist_std_norm | | step_idx | INT | -1 averages across all captured steps | | top_k | INT | Candidate shortlist size | | control_mode | ENUM | lowest_score (heads least implicated by these metrics) / random | | control_k | INT | Control group size (0 to skip it) | | seed | INT | Only used when control_mode = random |

Use _norm distance metrics here rather than the raw ones if the two runs don't share the same num_frames/resolution — same rationale as Compare Runs. The report STRING lists both groups ranked by composite score, each entry showing every individual metric's zscore (not just the composite) so you can tell whether a head is consistently implicated across all of them or only carried by one. candidates_csv and control_csv are just block,head pairs, one per line, for pasting into other nodes/scripts. The control group excludes anything already in the candidate shortlist.

---

Typical workflows

Workflow 1 — Profiling run

[Load LTX Model]
      │
[LTX Attn — Setup Capture]
  capture_sa=True
  store_mode=reduced
  target_blocks="all"
      │
[KSampler]
      │
      ├── [LTX Attn — Metrics Heatmap]  metric=entropy
      ├── [LTX Attn — Metrics Heatmap]  metric=temporal
      └── [LTX Attn — Timestep Evolution]  block_idx=24

Workflow 2 — Head freeze experiment

# Step 1: capture reference maps
[Load LTX] → [Setup Capture, store_mode=full_fp16, target_blocks="24"]
           → [KSampler] → [Store Dump → "ref.pt"]

# Step 2: apply freeze
[Load LTX] → [Store Load ← "ref.pt"]
           → [Head Freeze, targets="24:8", from_step=3]
           → [KSampler] → [Save Video]

Workflow 3 — QKV transfer between prompts

# Step 1: capture source
[Load LTX] → [Setup Capture, capture_qkv=True, qkv_targets="24:8,12,16 | 32:8,12,16"]
           → [KSampler, prompt="chrome robot on rails"]
           → [Store Dump, handle=<from Setup Capture> → "source.pt"]

# Step 2: transfer to target
[Load LTX] → [Store Load ← "source.pt"]  (wire its handle output)
           → [QKV Transfer, targets="24:8,12,16", use_k=True, use_v=True, blend=0.7]
           → [KSampler, prompt="golden robot on rails"]
           → [Save Video]

---

Architecture notes

Token layout

LTX-2.3 uses SymmetricPatchifier(patch_size=1): 1 token = 1 latent pixel = ~32×32 pixels in image space.

For a 1280×720 video with 16 latent frames:

Sequence length = 16 × (720/32) × (1280/32) = 16 × 22 × 40 = 14080 tokens
                               ↑ or 11×20 depending on workflow upscale step

Attention map interpretation

W : [H=32, Sq, Sk]   (self-attention)
         ↑  ↑   ↑
         heads  sequence length

Key map   = W.mean(dim=1) → [Sk]  "what is being looked at"
Query map = W.mean(dim=2) → [Sq]  "who is actively looking"

Attention map vs. raw Q/K/V

Setup Capture's store_mode=full_fp16/hybrid (the attention map W = softmax(QK^T)) and its capture_qkv toggle (raw Q/K/V, before the softmax) capture genuinely different things — one doesn't substitute for the other:

• Attention map — lets you replay the exact historical pattern later: Head Freeze and QKV Transfer's use_map mode both just reuse the stored W against the current run's V (ops/freeze.py/ops/qkv_transfer.py:98).
• Raw Q/K/V — lets QKV Transfer's use_q/use_k/use_v modes recombine components from two different generations and recompute a brand new softmax(Q_eff·K_eff^T)·V_eff (ops/qkv_transfer.py:126-130) — something no stored map alone can do, since softmax is lossy: you can't reconstruct Q/K from a saved W.

Hook architecture

A single universal hook is installed on both optimized_attention and optimized_attention_masked. Priority order per call:

1. Profiling → AttentionStore (metrics + key/query/full maps)
2. QKV Capture → QKVStore
3. QKV Transfer → Q/K/V substitution
4. QKV Multiplier → per-head Q/K/V/O scaling
5. Head Freeze → map injection
6. Normal pass-through

Chaining multiple intervention/capture nodes

Every intervention/capture node (Setup Capture, Head Freeze, QKV Transfer, QKV Multiplier) registers its own contribution into a shared, named layer registry on the underlying diffusion_model (keyed by ComfyUI's stable per-node unique_id) instead of hand-rolling its own _forward wrap. This means you can chain several of these nodes in the same graph — e.g. two QKV Multiplier nodes targeting different blocks, or Head Freeze + QKV Multiplier together — and each one's effect stacks rather than silently overwriting the others. Re-running the same node in place (a normal requeue) replaces only its own entry, so nothing accumulates across repeated runs.

Caveat: if you delete or rewire a node out of the graph entirely, its last-registered layer has no way to know it should remove itself — nothing calls its cleanup on a node_id that stops executing. Run LTX Attn — Reset Patches once (any point downstream of the model) to clear every registered layer and fully restore the pristine model if you've been iterating on your graph and suspect a stale layer is still applying.

Why visualization/intervention nodes use a typed store_handle string

Captured data is written into the registry as a side effect of the KSampler run, after the Setup node itself has already returned. Nodes that read it back (Query Map, Key Map, Metrics Heatmap, Grid Viz, Head Freeze, Compare Runs-adjacent IO nodes, …) take the handle as a plain STRING widget rather than a wired socket on purpose: ComfyUI schedules nodes by wire dependency, so a typed socket straight off the Setup node's output would let these nodes run before the KSampler ever populates the store, always producing empty results. Typing the handle into a STRING widget instead means these are a separate, later queue run against the already-populated registry instance — leave it blank to fall back to whichever store is currently active.

---

Limitations & known issues

• LTX-2.3 only (48 transformer blocks, 32 heads, patch_size=1)
• Full map storage at native resolution (3520×3520 per head) requires ~25 MB/head — use map_downsample or hybrid mode
• Audio stream is not profiled (video stream only)

---

References

• LTX-Video 2.3
• Sparse VideoGen (arXiv:2504.10317) — attention head classification methodology
• ComfyUI

---

License

GPL 3.0