Thera Process

This is the node that does the actual work. LoadTheraModel just picks the weights; TheraProcess takes your image and a thera_pipe, and hands back a bigger image. The headline feature is right in the input list: scale is a float, not a preset. Ask for 3.7x. Ask for 8x. Ask for 2x. It doesn't care, because unlike an ESRGAN model that's trained for one fixed integer factor, Thera is built on continuous coordinate sampling.

That makes it a "more pixels" upscaler with a genuinely different shape. In the upscaling ladder it belongs to the non-generative rung - it adds resolution, not hallucinated detail, so it's the honest choice for photo restoration and print work where you want what's actually there, resampled cleanly. SeedVR2 invents texture; Thera re-renders pixels. Different jobs, and if you grabbed the wrong one you'll know within a frame.

How it works

Thera is two halves. The encoder - EDSR or RDN, depending on which model you loaded - squeezes your image into a feature map. The decoder is the clever part: a neural heat field, a coordinate network that samples that feature map at arbitrary continuous positions using a heat-kernel-style activation. Because the sampling positions are continuous rather than locked to a learned integer scale, you get aliasing-free output at any target size.

The node does a few things around that core. It upscales your image with bicubic first, then adds that back to the model's output (residual learning - the network refines rather than rebuilds). It processes the image tile by tile across the output grid, with patch_size controlling the tile size. And it runs the whole thing through JAX, which is why the first execution is slow: JIT compilation. Warm it up once and subsequent runs are quick.

The inputs that matter

Only a few of these do real work:

• scale - the upscale factor, default 4.0, any float with 0.1 steps. This is the whole reason to use Thera.
• patch_size - 256 or 512. 256 (the default) is kinder to VRAM and the safer pick for huge outputs; 512 halves the tiling overhead but eats more memory.
• do_ensemble - off by default. When on, it runs the image rotated four ways and averages the results, a classic test-time trick that buys a little quality at 4x the compute.
• images - a normal IMAGE batch. The node processes every frame in the batch, so feeding it a video frame set works, frame by frame.

Output is a single image (type IMAGE), ready for Save Image, Preview Image, or the next node in your chain. One honest quirk: Thera rounds its output to 8-bit levels before handing it back. For display that's fine - for chaining another heavy processing pass, you might prefer to keep that in mind.

Installing it

Same pack as LoadTheraModel, same steps - ComfyUI Manager (search "Thera") or:

cd ComfyUI/custom_nodes
git clone https://github.com/yuvraj108c/ComfyUI-Thera
cd ComfyUI-Thera
pip install -r requirements.txt

Then restart. The requirements pull in jax[cuda], jaxlib, flax, and jaxtyping - a whole separate JAX CUDA toolchain on top of your PyTorch install, and the most likely thing to break on a machine with a mismatched driver. When it does, it fails at load time, not here, so get that sorted before you reach this node.

Where people get burned

• First run is glacial. JAX is compiling. Run it once, let it finish, and the second run is a different animal.
• OOM on big upscales. do_ensemble on, patch_size 512, and an 8x scale on a big source is a lot of simultaneous work. Drop to patch 256, turn off ensemble, or upscale in stages.
• It's slow per-image with large batches. Every frame is processed and memory-held at full output resolution. Batch size matters.

The take: if you need arbitrary-scale, non-generative upscaling, this is the only serious game in town - the closest thing to a one-pass "any size" honest upscaler ComfyUI has. Just budget for the JAX install and one slow first run.