arkennemasis fal · Flux General Differential Diffusion · per compute second

Differential diffusion is the answer to a problem every mask-based editor has: masks are binary and edits aren't. You get a hard boundary, or you get blur, and neither is what you wanted when the change should graduate from "definitely" in the middle to "nothing at all" at the edges.

Differential diffusion replaces the mask with a change map - a greyscale image where black means leave this alone, white means regenerate it, and every grey in between means "somewhere in the middle". Instead of a region switch flipping per pixel, you get a continuous field. It's been a steady if modest topic in the community for two years, active through mid-2026, and it's one of the genuinely distinctive things you can do on a hosted endpoint.

This is fal's Flux General endpoint with the differential-diffusion pipeline selected, so it also carries every extension the general node has: LoRA, ControlNet, IP-Adapter, EasyControl.

The two inputs that define it

image - required. The photo you're editing.

change_map_image - required. This is the greyscale map. Paint it yourself in any image editor: white where the change is strongest, black where nothing may move, grey where you want a partial transition. A gradient around a face, a soft ring around an object being replaced, a blurred blob where a new element goes.

strength defaults to 0.85 and reads like every other denoise dial here: 1.0 completely remakes the image, 0.0 preserves it. Think of it as the ceiling of the change map - the map says where, strength says how far in total.

Building a usable change map is the actual work, and there's a reason this technique stayed niche: the map is another artefact to author and version. But when you need a soft blend rather than a composited edge, nothing else does it.

The rest of the node

Everything from the general endpoint is present, so this is the place to be precise about what you leave empty:

• prompt and negative_prompt - the negative only genuinely bites through NAG, exposed here as nag_scale (3), nag_tau (2.5), nag_alpha (0.25) and nag_end (0.25). Don't exceed nag_scale 3.
• loras, control_loras, controlnets, controlnet_unions, ip_adapters, easycontrols - JSON fields, all optional, all expecting URLs fal can fetch. Local files in your models/loras folder are not reachable. Empty is the right value until you need one.
• image_size (square_hd default, custom for exact dimensions), num_inference_steps 28, seed -1, guidance_scale 3.5, use_real_cfg (false - and it increases both time and price when enabled), use_cfg_zero (false), scheduler euler, base_shift 0.5, max_shift 1.15, use_beta_schedule false, output_format png.
• Six optional fill_image_* sockets and reference_image with reference_strength / reference_start / reference_end for reference-only conditioning.

Outputs

images and image_paths (under output/fal/fal-ai_flux-general_differential-diffusion/), plus timings, has_nsfw_concepts, prompt, seed, and info.

Install

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

Restart ComfyUI, or use ComfyUI-Manager → Install via Git URL. The pack declares httpx for its Codex nodes; the fal provider itself needs nothing past the standard library, and no model files are downloaded.

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

in the .env next to run_nvidia_gpu.bat (portable build) or your ComfyUI folder. There's no key widget, deliberately.

The one thing to understand about the price

This endpoint is billed per compute second with no per-run figure, so its title reads "per compute second" rather than a dollar rate. That has a concrete consequence: max_cost_usd has nothing to compare against. The default $20 cap can't stop this node, because the node genuinely doesn't know what a run will cost until fal bills it. The same is true on a few other compute-billed endpoints in this pack.

Practical read: don't fire this off in a 40-branch fan-out and walk away. One call at a time is what max_concurrent (default 1) gives you, and that's the right setting here.

reuse_identical_run (default on) is your sharpest cost control: the fingerprint covers the settings and the bytes of both the image and the change map, so re-queuing the same job after a crash returns the saved file instead of paying again.

Mask or change map?

Worth saying plainly, because it's the decision the node forces. A mask plus compositing locally is still the only way to guarantee that unmasked pixels come back bit-identical - and that's the one thing an instruction edit or a full-frame re-render can't offer. Differential diffusion is not that. It's a per-pixel strength field on a hosted generation, so the untouched-looking areas are generated too, just barely moved.

If your requirement is "nothing outside the mask may change, provably", do it locally with a mask and a composite. If your requirement is "this change should fade out across the jawline instead of tearing", this is the node.