arkennemasis fal · Flux Vision Upscaler · $0.10/MP of output

This isn't an ESRGAN-style pixel upscaler. It's a generative one: it looks at your image, decides what detail should be there at the larger size, and paints it. That's why it has a creativity dial and a steps count, and it's why the output can look stunning on a landscape and unsettling on a face.

$0.10 per megapixel of output is the price, which is the expensive end of anything in this pack, and the number that matters is the one you get after upscaling. The pack's estimate multiplies your input's megapixels by the factor squared - so 1 MP at 2× is four megapixels and forty cents, and 1 MP at 4× is sixteen megapixels and a dollar sixty. The pre-run check against max_cost_usd (default $20) is what stops you discovering that on your statement.

Compared with the local options, the trade is honest: Real-ESRGAN and friends are free, fast and refuse to hallucinate; Topaz is still the paid default everyone benchmarks against; this one buys you invented detail. Use it on textures, foliage, architecture, skies - anything where "more plausible detail" beats "the same detail, bigger". Think twice on portraits and text, where invention reads as damage.

Inputs

• image - the source. One image.
• upscale_factor - 1 to 4, default 2. Both the output size and the price.
• creativity - 0 to 1, default 0.3. The tooltip is refreshingly direct: it's the denoise strength of the sampling. Higher means the model deviates further from your original. This is the make-or-break setting. At 0 it's a faithful resynthesis; at 0.7 you're mostly generating a new picture in the same composition.
• guidance - 1 to 4, default 1. CFG, low on purpose.
• steps - 4 to 50, default 20.
• seed - pin it once you find a good pass, because a generative upscale is a rendering, not a deterministic resize.
• enable_safety_checker.
• Plus the shared max_cost_usd, reuse_identical_run, extra_json, max_concurrent.

What comes back

images and image_paths, plus something unusual for this pack: a caption output (a STRING describing the upscaled result). If you're building a training set, that's genuinely handy - upscale, keep the caption, done. You also get seed, timings and info (JSON with the request id, cost estimate, saved files and fal's answer). Files land in output/fal/fal-ai_flux-vision-upscaler/.

Install

ComfyUI Manager → comfyui-arkennemasis, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Hishamahmer/comfyui-arkennemasis

Restart, then put your key in the .env file next to run_nvidia_gpu.bat:

FAL_KEY=your-key-from-fal.ai/dashboard/keys

No model files to fetch and no extra Python packages - the fal nodes in this pack are standard-library HTTP, and there's no key field on the node so a shared workflow can't carry your key.

Working notes

Do the cheap thing first. If the upscale doesn't need invention - clean phone photo, plenty of real detail - a local ESRGAN pass costs nothing and you'll prefer it. Reach for this node when the source is soft, small, or AI-generated and you want plausible texture added.

Run 2× before 4×. A single 2× pass with creativity around 0.2–0.35 is usually better than one aggressive 4× pass that has to imagine four times as much, and it's a quarter the price. Because this is a generative pass, always compare against the input at 100% rather than trusting the thumbnail - invented detail is most convincing when you're not looking closely.

The usual pack caveats apply. reuse_identical_run (on by default) gives you the cached result when the inputs haven't changed, which matters here more than elsewhere: an accidental re-run of a 4× pass is real money. The safety checker returns a black image when it flags something, and disabling it requires account authorisation on fal. And if ComfyUI restarts while the job is running, the request is in output/fal/_requests.jsonl - the free Recover Result node grabs it by id for nothing.