TIDE High-Resolution Extrapolation

You know the experience. Flux at 1024x1024 is basically a photographer with good taste. You bump it to 2048 for a wallpaper or a print, and suddenly the hands are a different species, the prompt's influence evaporates, and the composition reads like something half-finished. You assume it's your seed. It isn't. Most of that collapse is a mechanical failure in attention, and TIDE High-Resolution Extrapolation is one of the most interesting recent attempts to fix it at the source instead of patching it with a hires pass afterward.

The node is a ComfyUI implementation of the TIDE paper - Text-Informed Dynamic Extrapolation with Step-Aware Temperature Control for Diffusion Transformers (arXiv 2603.08928, 2026). It targets two specific failure modes that show up when a Flux-family DiT is asked to work far above its training resolution. First, attention dilution: at 2048x2048 the model has roughly four times the image tokens of 1024x1024, but the text tokens stay exactly the same, so your prompt's influence gets diluted away inside the joint text/image softmax. Second, RoPE extrapolation: positions beyond the training range behave poorly. TIDE's two mechanisms map onto those two problems: Text Anchoring adds a positive bias to the attention logits of text-token keys, and Dynamic Temperature Control sharpens attention early in denoising - when global structure is being decided - then relaxes as detail work takes over.

Here's the part worth knowing before you wire it up: this node is a model patch, not a workflow. It clones your MODEL, hooks into ComfyUI's attn1_patch, and passes the current denoising timestep into the patch so the temperature curve is genuinely step-aware. No extra sampling steps, no sampler or scheduler replacement, no API, no key, no model download. The text-anchor bias is log((width × height) / (base_width × base_height)) - with the defaults that's log(w/1024) + log(h/1024) - and it's a no-op at native-or-smaller token counts unless you flip apply_to_native_or_smaller. A small PyTorch SDPA fallback kicks in only when the additive mask is active, so you don't hit attention backends that choke on or densify masks.

The inputs that actually matter

• model - any Flux-family MODEL.
• width / height - set these to your actual generated dimensions. This is the single biggest gotcha; get them wrong and the whole bias is wrong.
• text_anchor_strength - multiplier on the beta bias. 1.0 matches the paper, 0.0 disables anchoring.
• temperature_strength - 1.0 matches the official curve, 0.0 disables temperature control.

The rest are ablation knobs. base_width/base_height default to 1024, which is right for Flux - leave them alone unless you know a model trains at something else. frequency_mode defaults to official_raw and matches the reference implementation; paper_normalized exists for people testing the paper's notation, which is probably not you.

Output is a single patched model, which goes straight into your sampler: model loader → this node → sampler. The README's recommended ablations are worth stealing: anchor-only (text_anchor_strength=1.0, temperature_strength=0.0), temperature-only (0.0/1.0), and fully off (0.0/0.0).

Installing it

It's a standard custom node. Via ComfyUI Manager, search for "ComfyUI-TIDE" (or "TIDE") and install; or:

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/ComfyUI-TIDE

Then restart ComfyUI. That's the whole install - requirements.txt is just torch, which you already have. No checkpoints to fetch, no weights, no nothing.

Where people get burned

First, don't test at 1024x1024 and expect a change - by design, both mechanisms gate on being above the base resolution unless you force them. Second, verify width/height match the latent exactly, or you're solving a different problem than the one you have. Third, be realistic about what you're running: this is a brand-new (2026) implementation of a brand-new paper by a one-person author, and it has essentially zero community mileage yet - no Reddit threads, no battle-tested workflows. Run the ablations, A/B it against your usual hires workflow, and don't trust it blindly. It fixes attention dilution, not VRAM - at 4K you still need the memory for the pixels themselves.

Think of it as a lever on the source of high-res breakdown rather than another band-aid after the fact. Whether it displaces your usual upscale pass is an empirical question - but it's a cheap one to test.