ꘅ ONNX upscale

What this node is

ꘅ ONNX upscale is the odd one out in the whole upscaling category: the inference doesn't happen on your Comfy server. It happens in the browser tab that's displaying the preview. An ONNX build of compact Real-ESRGAN runs inside a Web Worker via ONNX Runtime Web, and the model files are served by your own local Comfy instance under an allowlisted route.

That sounds like a gimmick until you notice what it buys you. Every other node in this pack is welded to Apple silicon. This one runs on the viewing device. Point a browser at Comfy from a Windows laptop and the upscaling workload lands on that laptop's GPU, not the Mac serving the workflow. For interactive work - where you want a cleaned-up frame while you're still drawing or performing - that's a genuinely different architecture from the usual "queue a job and wait" model.

The catch is in the node description and it's not subtle: this is is_experimental=True, and its execute() raises unconditionally.

raise RuntimeError('ONNX upscale runs in an active browser on Live delivery. For queued IMAGE processing use Real-ESRGAN upscale (native).')

So: queue a workflow containing this node and you get that error, verbatim, every time. If you want pixels out of a normal Run, use ꘅ Real-ESRGAN upscale instead. This node is for live, in-browser processing only.

The inputs that matter

Four required inputs, no optionals:

• image - an IMAGE. Documented range is 2–256px per side; the frame gets repeat-reflected into a fixed 266×266 tensor internally.
• model - animevideo or general. AnimeVideo is the lighter export (16 compact conv blocks), General the heavier one (32). Same two families as the native node.
• backend - webgpu or wasm. WebGPU if your browser has it; wasm is the CPU fallback. There's no silent fallback if WebGPU fails - you picked it, so you own it.
• scale - source, 2x or 4x.

One output, image, IMAGE.

How the scaling works matters here. The ONNX graph always predicts 4x (1064×1064 out of the padded tensor), then crops back and canvas-resamples for source or 2x. That resample is browser canvas filtering, not the Lanczos the native node uses - the author says so plainly in the docs. Don't expect pixel parity with the Core ML path.

Getting it running

Install the pack first:

cd ComfyUI/custom_nodes
git clone https://github.com/languel/genereticore

Or search GeneretiCore in ComfyUI Manager. Restart Comfy afterwards - the samples drop into Workflows → GeneretiCore on startup.

Then, specifically for the browser node:

1. Open the 15 - Browser ONNX upscaling sample, or wire LoadImage → ONNX upscale.
2. Press ↓ on the node. That fetches roughly 34.7 MB of pinned assets (the ONNX model plus the pinned ONNX Runtime Web 1.24.3 bytes) into Comfy's models/genereticore/browser. SHA-256 checked, no Hugging Face account needed.
3. Press ↑ to load and warm the worker. The first prediction includes compile time and is much slower than the rest.
4. Press ▶ to start. Ⅱ pauses, × unloads and kills the worker.

You also need the companion Genereti frontend for the live image stream and previews. Without it, nothing feeds this node.

Where it bites

The input size limit is the one that catches people. Feed it a 1024px LoadImage and you're outside the documented 2–256px range. Resize upstream - the sample deliberately works at 256×256, which is also where the measured numbers come from.

Those numbers, from the author's own October 2026 run on an M5 Max: AnimeVideo/WebGPU ~154 ms per frame (~6.5 FPS), General/WebGPU 271–308 ms (~3.2–3.7 FPS), AnimeVideo on WASM CPU 1.64 seconds (~0.6 FPS). So WebGPU anime is the only configuration that feels live; WASM is a correctness check, not a workflow. The author is explicit that native Core ML is substantially faster on the same machine. Browser portability isn't a speed story.

Also listed as not-yet-supported: 512px browser exports, tiling, automatic device/memory recovery after a lost GPU context, and any cross-browser parity claim. If your tab loses the WebGPU device mid-session, reload it.

And the privacy line is worth repeating because it's unusually good: frames stay inside the worker. They go to neither Hugging Face nor the Python inference endpoints. The model is local, the input is local, and the only network hop is Comfy serving its own assets over loopback.