RKNN SuperRes (HTTP Upload)

This is the second half of the RKNN client pack, and it's the more honest node of the two. No "Generate" in the name pretending to do work. RKNN SuperRes Upload takes an IMAGE that's already in your ComfyUI graph, uploads it over HTTP to the same Rockchip server's /superres endpoint, and returns a larger IMAGE. The upscaling model runs on the board's NPU, so your GPU never touches it.

It only makes sense if you already run the pack's server - this node is the sibling of RKNN LCM Generate, and both talk to the same FastAPI service on an RK3588/RK356x board. Its job is to offload the boring work. If your box is sitting there as a cheap render farm, letting it also do upscaling keeps ComfyUI's own VRAM free for the stuff it's actually good at.

How it works

Two distinct paths, and the first one is easy to trip over: if magnitude is 0, the node doesn't call the server at all - it returns your input image unchanged with an info string of SR bypass (magnitude=0). That's by design, not a bug, but it means setting 0 when you meant "one tiny upscale" silently does nothing.

Above zero, it takes the first image in the input batch, encodes it to PNG, and multipart-POSTs it to {base}/superres with magnitude, out_format, and quality (the source hardcodes PNG at quality 92). The response is PNG bytes, decoded back into a normal IMAGE tensor. It then reads X-SR-Passes, X-SR-Scale-Per-Pass, and backend headers to build the info string.

Inputs and outputs

The full input list is small: api_bases, image, magnitude, timeout_s. The ones you actually set:

• api_bases - same as the Generate node: one URL, or several separated by ;/, for round-robin. The default http://node2:4200 is a placeholder; change it or nothing connects.
• magnitude (default 2, range 0–4) - the number of SR passes the server runs. Each pass scales the image; the actual scale factor per pass is decided server-side and reported back in the info string.
• timeout_s (default 120) - generous for one pass, but each pass multiplies the pixels and the NPU isn't fast. If you chain 4 passes on a large input, 120 seconds can genuinely run out. Raise it.

Outputs are image (the upscaled tensor - feed it to Save Image, or back into the graph for further processing) and info (STRING with passes, scale/pass, backend, and elapsed time).

Where it sits in the upscaling world

Keep your expectations calibrated. This is the "more pixels" job, not the "invent detail" job. In the upscaling taxonomy, it's a learned super-resolution model on the NPU - think ESRGAN-family: a fast, clean enlargement that adds no hallucinated detail. It is not a generative restorer like SeedVR2 or SUPIR, which would rebuild pores and eyelashes (and rewrite faces while they're at it). If your source is soft or damaged, this won't fix it; if it's already sharp and you just need it bigger, it's perfect - and it's doing that for free on hardware that would otherwise be idle.

Install

Same as its sibling: ComfyUI Manager → search rknn-lcm-client-comfyui, or

cd ComfyUI/custom_nodes
git clone https://github.com/Mario5Gray/rknn-lcm-client-comfyui
# restart ComfyUI

Dependencies are just requests, pillow, numpy. No model downloads here - the SR model is baked into the server on the board. Installing the node installs nothing but the phone line.

Common issues

• Bypass surprise. magnitude 0 passes the image through silently. If your "upscale" keeps returning the same image, check that number.
• Only the first image of a batch is uploaded. The code takes t[0] when converting to PNG. Feed it a batch and the rest are silently dropped.
• You don't control the output size. The server decides scale-per-pass; read the info string to see what actually happened.
• Connection errors mean the server isn't up or the URL is wrong - the node does no inference of its own to fall back on.