arkennemasis fal · Flux LoRA · $0.035/MP

The plain Flux Dev LoRA endpoint, wrapped as a ComfyUI node. $0.035 per megapixel. Same family as the Krea LoRA node but without Krea's aesthetic on top - this is Flux Dev doing its thing, which is worth remembering, because Dev has a slight plastic sheen at stock settings and a lot of the LoRAs people stack on it exist specifically to fix that.

Why you'd use the hosted version

Two honest reasons. You don't want 12GB of weights (plus a T5 encoder) on your disk and in your VRAM, and you want to run a LoRA you don't have locally. Both are the same reason in the end: the model lives on fal's hardware, so your card stays free for whatever else is in the graph.

The cost of that is the standard API cost. Your images get uploaded to fal's CDN before generation, your prompt travels with them, and you pay per megapixel rather than per session. For a fixed style you'll hit hundreds of times locally, local wins on economics. For a LoRA you want to try once, or a machine that can't hold Flux at all, this is the shortcut.

Inputs

• prompt - natural sentences. Flux was the model that made natural-language prompting the norm, and tag soup does it no favours.
• loras - a multiline JSON string: LoRA entries with their weights and a scale, merged together for the final image. Empty leaves them out entirely. These load on fal's side, so it's URLs - not a local file path, and not a dropdown of your models/loras folder.
• guidance_scale default 3.5, range 0–35. Lower than the Krea node's 4.5; 3.5 is the Flux Dev convention and it's right where the LoRA recipes usually assume you are.
• num_inference_steps default 28 (1–50). seed (-1 random), num_images 1–4 (the tooltip notes it's forced to 1 for streaming output), enable_safety_checker, output_format (jpeg/png), acceleration.
• image_size plus image_size_width / image_size_height for custom (16–14142, step 16).

Then the pack-wide four, identical on every fal node here: max_cost_usd (default $20, evaluated before upload, 0 = no cap), reuse_identical_run (on by default), extra_json (a JSON object merged into the request last, for any fal field the node has no box for), max_concurrent (default 1 - one paid fal call at a time across the run).

Outputs

images → preview or save. image_paths → where they landed in output/fal/fal-ai_flux-lora/. seed (the seed actually used - write it down when you get a keeper), has_nsfw_concepts, timings, prompt, and info with the request id, the cost estimate and fal's full answer.

Install

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

Manager route: search comfyui-arkennemasis, or paste the repo URL into Install via Git URL. Restart ComfyUI afterwards. If you install by hand, there's no pip step needed for this node - the fal provider uses Python's standard library, and the only declared requirement (httpx) belongs to the pack's separate Codex nodes.

The key goes in .env, in the folder that holds run_nvidia_gpu.bat:

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

There's no key field on the node, so nothing sensitive ends up saved inside a workflow JSON.

Known snags

A LoRA that "does nothing". On fal the LoRA has to be fetchable by fal. A Civitai download link, a Hugging Face raw file URL, or a file registered on fal's side - a path on your SSD will simply not resolve. The node validates the JSON before uploading, so you'll at least get a clean, free error for malformed syntax rather than a fake result.

Stacking two LoRAs at full scale. Flux Dev takes single-subject LoRAs well; pile three on and you're in the territory where the community's own note is that stacking is where quality goes sideways. Lower the scales and add one at a time.

Re-running for free and not noticing. reuse_identical_run returns the previous files when settings, LoRAs and inputs are byte-identical. That's a feature when ComfyUI crashed mid-run, and a nuisance when you wanted a different sample from the same recipe - flip it off or change the seed.

Cheaper than it looks, or more expensive. $0.035/MP is per megapixel per image. A 1536×1536 generation with num_images 4 is nine megapixels, or about 31 cents. The badge on the node does this maths live; believe it over your own mental arithmetic.