Upscale node LowVRAM (ONNX)

Remacri is a 4x ESRGAN-family model people keep coming back to: pixels, no invented pores, no rewritten faces, milliseconds instead of minutes. Remacri is the texture-friendly pick in a family where 4x-UltraSharp is the generalist, and the 2022 thread "Remacri has best results across the board" is still what people cite it for. Normally that model wants a .pth and a torch upscale node; this one runs it as an ONNX graph through ONNX Runtime, and the pack ships the weights.

So what is "LowVRAM" buying you? Less than you'd guess.

What it does, honestly

RemacriOnnxUpscaleNodeLowVram (display name "Upscale node LowVRAM (ONNX)") loads a .onnx upscaler, runs it on your image, then resizes the result down to a picklist resolution. It's the older of two nodes in the pack - the other, RemacriOnnxUpscaleNode, adds batch_size and a diagnostics toggle, and the README calls this one "Low VRAM version (legacy)".

The low-VRAM part is real but narrow. In the source, the node loops over your batch one image at a time, keeps a single ONNX Runtime session alive between runs, and walks a fallback chain (your chosen provider → CUDA → ROCm → CPU) instead of dying if a backend won't initialize. What it does not do is tile. There's no tiling code anywhere in the pack. So the memory ceiling is still set by your resolution: 4x means sixteen times the pixels, and the whole frame goes through the graph at once. On a tight card, the thing that saves you is more often the final downscale than the node.

Inputs you actually touch

Four required inputs. image is your IMAGE and the only wire you connect. model_file is a dropdown of every .onnx file found in ComfyUI's upscale_models folders - note .onnx specifically, so a .pth or .safetensors Remacri sitting in that folder is invisible here and the dropdown will just read "(no .onnx models found)".

provider is the one with real consequences: TensorrtExecutionProvider, CUDAExecutionProvider, ROCmExecutionProvider, CPUExecutionProvider. Pick CUDA unless you've installed NVIDIA TensorRT 10.x yourself. TensorRT is genuinely the fast path, but it compiles an engine per input resolution - the README measured five minutes for a 1280x720 build on a 5090, and the code writes both the timing cache and the engine to ./trt_timing_cache and ./trt_engine_cache relative to wherever ComfyUI was launched. Change your source size and you get to build again. It also wipes both caches when your torch, CUDA or onnxruntime version changes - correct, and still surprising.

final_resolution is where beginners get stung. The options are hd, fhd, 2k, 4k, 8k and no downscaling; in the source those are fixed 1280x720, 1920x1080, 2560x1440, 3840x2160 and 7680x4320 through a plain cv2.resize. Fixed, as in hard-coded 16:9. Point it at a square SDXL output and it will squash it. Unless your image is already widescreen, use no downscaling and do your own resize with an ImageScale node.

One output, upsampled, an IMAGE you wire into PreviewImage, SaveImage, or another scale node. It's flagged as an output node, so you can queue it alone to eyeball the result.

Installing it

cd ComfyUI/custom_nodes
git clone https://github.com/Austat/ComfyUI-RemacriScale
cd ComfyUI-RemacriScale
pip install onnxruntime-gpu

Restart ComfyUI. Deliberately not pip install -r requirements.txt: that file lists an unpinned torch next to onnxruntime-gpu, numpy, opencv-contrib-python and tqdm, and letting pip pull a fresh torch is how you break a working install. For TensorRT, install NVIDIA's TensorRT 10.x first.

You don't need to download a model for the default path - upscale_models/4x_foolhardy_Remacri.onnx (~71MB, the ONNX port of FoolhardyEVO's 4x-Remacri) is committed to the repo, so the clone arrives ready. Others go in ComfyUI/models/upscale_models/.

Where it breaks

The classic one isn't a bug in this node: if onnxruntime (the CPU-only package) is installed, it shadows onnxruntime-gpu, and you get the familiar Specified provider 'CUDAExecutionProvider' is not in available provider names warning. Here the fallback chain swallows that and quietly runs on CPU, so you don't get an error - you get a run that takes forever. Check the console for the [RemacriOnnxUpscale] Using provider: line before you blame your settings.

AMD users hit the same shape of problem: onnxruntime-gpu is an NVIDIA build, and the standard wheels don't include the ROCm provider. Selecting ROCmExecutionProvider without a ROCm build of ONNX Runtime means CPU. There's a standalone ONNX_GPU_Testit_001.py in the repo for testing your runtime outside ComfyUI.

Otherwise: if the dropdown is empty, your model isn't a .onnx; if the first TensorRT run sits there for minutes, that's the engine build, not a hang; and if the output looks subtly stretched, it's the 16:9 resize.

For clean sources where you want pixels and not detail, this is a sound little node - just don't read "LowVRAM" as "tiled".