arkennemasis fal · Flux General RF Inversion · per compute second

RF Inversion is the most technical thing in this pack, and the least likely to be what you actually wanted.

Here's the idea in one paragraph. Flow models like Flux generate by walking from noise to an image along a trajectory. Inversion runs that walk backwards on a photograph - it finds the noise trajectory that would have produced your picture - and then you re-run the forward walk with a new prompt. Because you're editing inside the model's own latent journey rather than pasting a denoise on top, you can change the semantic content while the structure stays anchored to the original. It's the difference between "restyle this photo" and "this photo, but now it's autumn, and it's still the same photo".

How the controls map to that

This endpoint exposes the inversion controller directly, and the two guidance values do different jobs:

• controller_guidance_forward (default 0.6, gamma) - used in the creation of the structured noise.
• controller_guidance_reverse (default 0.75, eta) - used during denoising, and the tooltip gives you the direction: values closer to 1 push the result closer to the input.
• reverse_guidance_start (0) and reverse_guidance_end (8) - the timestep window where that reverse guidance applies. Same idea as releasing a ControlNet once composition is settled: you can hold the subject through the early steps and let the model work freely later.
• reverse_guidance_schedule (default constant) - how that guidance is applied across the window.

If you've ever used a ControlNet start/end step and understood it as "when does the condition stop mattering", you already have the mental model for these four fields. The forward/reverse pair is the one to nudge first: crank reverse toward 1 and the picture barely moves; drop it and the edit becomes a new image wearing the original's bones.

The rest of the node

prompt is the edit instruction, image is the photograph being edited, and both are required. Then the general endpoint's whole drawer: negative_prompt through NAG (nag_scale 3 - don't exceed it - plus nag_tau 2.5, nag_alpha 0.25, nag_end 0.25), the JSON extension fields (loras, control_loras, controlnets, controlnet_unions, easycontrols - URLs fal can reach, empty leaves them out), use_cfg_zero, reference_image with its strength/start/end window, six optional fill_image_* sockets, and the sampling set: image_size (square_hd default, custom for exact dimensions), num_inference_steps 28, seed -1, guidance_scale 3.5, scheduler euler, base_shift 0.5, max_shift 1.15, use_beta_schedule false, output_format png. num_images is capped at 1.

Note what's not here: strength. You're not denoising a percentage of anything - the whole method is the inversion. If you want a dial that says "how much of the original survives", use the general image-to-image node instead.

Outputs

images, image_paths (saved in output/fal/fal-ai_flux-general_rf-inversion/), plus timings, has_nsfw_concepts, prompt, seed, and info with the request id, cost estimate, saved files and fal's full answer.

Install

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

Restart ComfyUI, or install through ComfyUI-Manager → Install via Git URL. The pack's requirements.txt declares httpx, and only the Codex nodes need it - the fal provider speaks plain HTTP with the standard library and downloads nothing.

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

goes in the .env next to run_nvidia_gpu.bat (portable build) or the ComfyUI folder. No key widget on any fal node here, deliberately, so a key can't end up in a workflow you share.

The price problem, which is the honest reason to think twice

This endpoint is billed per compute second and fal publishes no per-run figure - the node's title says "per compute second" for that reason. The consequence is concrete: max_cost_usd cannot protect you here. The default $20 cap works by comparing an estimate against the cap before uploading, and this node has no estimate to compare. Same for the differential-diffusion endpoint in this pack.

So treat it as a node you run deliberately, one call at a time (max_concurrent defaults to 1, and that's the right setting), not something to fan out across forty branches. reuse_identical_run (default on) is your best cost control: same image bytes plus same settings returns the file you already paid for.

Should you actually use this?

Honestly: probably not first. Instruction editing (Kontext, Flux 2 Edit) covers "change the jacket, swap the background" more simply and you can see what you're doing. RF Inversion's reason to exist is edits where the structure must survive while the semantics change - the same photo, fundamentally re-described - and where a plain img2img restyle would drift the layout.

If you want that, this is the version of it that's actually implemented as an inversion rather than a denoise, and there is no local ComfyUI equivalent most people have installed. If you just want "this photo but better light", go home early and use image-to-image.