ꘅ Real-ESRGAN upscale

Where this sits in the upscaling zoo

Pixel upscalers - the non-generative ones - never went away, and in 2026 their share of upscaling discussion actually rose, because once generative upscaling became the default, everyone started hitting the cases where it's the wrong tool: you don't want new pores invented, you don't want a second diffusion pass, you just want more pixels out of a small image fast.

ꘅ Real-ESRGAN upscale is that cheap rung, wrapped in a Comfy node and running on Apple silicon through Core ML. Note which Real-ESRGAN, though: these are the compact exports - realesr-animevideov3 and realesr-general-x4v3 - not the RRDB RealESRGAN_x4plus everyone means when they say "Real-ESRGAN." Compact means 16-ish conv blocks and a bundle about 7.55 MB instead of 64 MB. It's the video-grade speed variant.

That tells you what it's for. Cleaning up and enlarging the 256/512px frames coming out of this pack's live generators, or tidying a source image before it goes into one. Warm timings in the author's October 2026 measurements: AnimeVideo 256² → 16.66 ms, 512² → 51.72 ms; General 256² → 15.88 ms, 512² → 65.27 ms. That's realtime-adjacent on a Mac. It will not save a badly generated 512px image the way a generative upscaler would - it adds no content, by design.

How it works

The .mlpackage gets compiled once into an .mlmodelc cached next to your Comfy models, keyed on a hash of the coremltools version plus every file's size and mtime in the package, so a re-download recompiles and an untouched bundle doesn't. Compute units are CPU_AND_GPU; FP16 compute, float32 RGB NCHW in and out.

Each input is reflect-padded into a fixed tile - 266 or 522 depending on the 256/512 export - and the model always predicts 4x. Anything smaller happens afterwards: source resizes back to original dimensions (pure cleanup), 2x halves the result, 4x keeps it. Both 256 and 512 exports live in the same public bundle and the node picks one automatically, so there's no resolution node to add.

Two passes are the archived "refinement" idea: predict, Lanczos-downsample back to source size, blend with the original at the feedback weight, predict again. feedback has nothing to do with temporal feedback. It's a same-image blend coefficient used only when passes is 2, and the tooltip says so explicitly - no previous-frame history. If you came here expecting a video-style accumulation loop, you'll be disappointed, and there's no such loop in the code either.

Inputs and outputs

image is an IMAGE, 2–512px per side, non-square fine, alpha composited onto white. model is animevideo or general. scale is source, 2x or 4x. passes is 1 or 2, and feedback runs 0–1 in 0.05 steps, defaulting to 0.75.

Outputs: image, and metrics - a JSON string with inference time, output size, backend, model path, family and node timing. Wire it to a viewer if you want to know whether a config is fast enough before committing to it in a live graph.

Start with one pass. Two costs a second prediction and the docs warn it may erase detail rather than add it, depending on your source.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/languel/genereticore
cd ComfyUI && python -m pip install -e 'custom_nodes/genereticore[image]'

Restart, or grab it via ComfyUI Manager by searching GeneretiCore. It appears as ꘅ Real-ESRGAN upscale under GeneretiCore / Native Core ML.

That [image] extra is the real dependency list for this node: pinned coremltools (8.3.0 below Python 3.13, 9.0 above), plus transformers, huggingface-hub, numpy, Pillow, opencv-python. Do that inside Comfy's own Python and don't let it drag in a different Torch build.

Then press ↓ on the node for the ~7.55 MB pinned bundle. Anonymous access, checksum verified, no Hugging Face account, and nothing downloads on workflow load. Models land in Comfy's genereti_coreml folder - an explicitly configured path wins, otherwise models/genereti if it exists, otherwise models/genereticore/images - under upscalers/animevideo/{256,512}.mlpackage and the same for general.

Sample 14 - Real-ESRGAN cleanup comparison is the fastest sanity check.

Where people get burned

Inputs over 512px. The node won't quietly tile for you; a 1024px source needs an explicit upstream resize. This is a small-model cleanup node, not a general upscaler.

Batches longer than four. Upscale at most four queued images per batch. It processes frames individually and stacks the result, so the limit is deliberate.

Nothing at all on Linux or Windows. GeneretiCore image inference requires macOS 14+ on Apple silicon. Same for macOS 13. On older ComfyUI builds there's a nastier version of this: the image, upscale and browser nodes are imported inside a try/except ImportError in the pack's entry point, and they're built on comfy_api.latest. If that API isn't there, the import fails and the nodes simply don't appear - no error in the console beyond the swallowed import. The eight core nodes still register, which makes it look like a partial install rather than an unsupported Comfy version.

First call is slow. The compile-and-cache step happens on your first prediction; 1.2 seconds for AnimeVideo 256² in the author's numbers. Everything after that is the warm figure. Don't benchmark the first frame.