The weights of FLUX.1 [dev] take up nearly 24 GB in a single safetensors file, and yet a workstation with a 24 GB GPU can handle them. That number explains why self-hosted image generation has shifted from an experiment to a professional tool. ComfyUI, the open-source node interface that orchestrates Flux, Stable Diffusion, and the rest of the ecosystem, keeps the pipeline visible: every node, every seed, every sampler step.
What is ComfyUI and why has it gained ground?
Most image generation tools hide the process behind a text box and a few sliders. ComfyUI, released in early 2023 and currently maintained by Comfy Org, does the opposite: every operation is a node that you connect with wires on a canvas. Model loader at the top, text encoder next to it, sampler below. The entire graph is documented and reusable at the same time.
Workflows are saved as JSON and shared as files. ComfyUI embeds the workflow in the metadata of every PNG it generates: you drag someone else’s image onto the canvas, and the graph is reconstructed exactly as it was used to create it. Reproducing another person’s method is reduced to a simple drag-and-drop.
The package includes starter templates for common models and custom node management via ComfyUI-Manager. It works on NVIDIA (CUDA), AMD (ROCm on Linux), and Apple Silicon (MPS), across Windows, Linux, and macOS. Compared to classic front-ends like Automatic1111, which organize generation into forms, the graph-based approach has prevailed among those who chain models, LoRAs, and control; when a lab publishes a new model, it typically comes with a ComfyUI template as standard.
Keep port 8188 in mind: that is where the ComfyUI server listens by default, and later we will use it to turn a workflow into an endpoint.
The Models: From Stable Diffusion to Flux
Stable Diffusion weights opened the floodgates in August 2022 with version 1.4, and 1.5 consolidated a fine-tuning ecosystem that remains active. SDXL normalized 1024×1024 generation in July 2023. In October 2024, Stable Diffusion 3.5 Large arrived with 8B parameters, Stability AI’s bet on scale.
The quality leap came with FLUX.1 in August 2024. Black Forest Labs, the company founded by members of the original Stable Diffusion team, released a 12B parameter model that instantly solved issues with hands, rendered typography, and complex prompt following. FLUX.1 was released in three variants: [pro], API only; [dev], with public weights under a non-commercial license; and [schnell], distilled for four-step generation and released under Apache 2.0.
Performance separates the two open variants: [schnell] prototypes on the fly with its few steps, while [dev] usually requires about twenty per image. The legal nuance is as important as the size: if the generation is part of a paid product, [dev] is restricted while [schnell] is not. In 2025, Black Forest Labs expanded the family with FLUX.1 Kontext, which edits images following written instructions, and FLUX.2, released at the end of the year, significantly larger than its predecessor in parameter scale.
The rest of the ecosystem lives around the core model: LoRAs for styles and characters, ControlNet for fixing poses and compositions, upscalers for the final finish, and repositories like Civitai, where the community publishes checkpoints and fine-tunes. The first three are inserted as nodes without touching the rest of the graph. Not every checkpoint is worth the download: check licenses, weights, and real examples before putting it into production.
The canvas isn’t limited to images: Stable Video Diffusion, LTX-Video, HunyuanVideo, or Wan 2.1 work in ComfyUI using the same node mechanics, so the server you set up for photography later serves for video. Now is a good time to decide which family to start with: SDXL if you want to learn cheaply, FLUX.1 [dev] if you are looking for the quality ceiling of the open ecosystem.
VRAM and GPU: How much memory do you actually need?
As a rough guide: Stable Diffusion 1.5 lives on cards between 4 and 6 GB, SDXL runs comfortably with 8 to 12 GB, and FLUX.1 [dev] in bf16 requires a 24 GB GPU or efficient offloading. The RTX 3090 (2020) and 4090 (2022) offer exactly those 24 GB, and the 2025 5090 exceeds them with 32 GB. The bottleneck is not raw speed but memory: if the model doesn’t fit, the system moves weights between VRAM and RAM, and performance plummets.
The usual remedy is quantization. Community nodes like ComfyUI-GGUF load compressed versions of Flux: the Q8 variant keeps weights around 12 GB and Q4 goes even lower, with a degradation that is hard to detect in most uses. With quantization, a 16 GB card, such as the 4060 Ti 16 GB or the 4070 Ti Super, works with Flux without struggle.
These VRAM, cost, and quantization calculations are the same ones we already performed for local frontier models, where it is detailed why it is sometimes better to downgrade the model than to fill the GPU with exceptions. And if that 24 GB GPU must double as an LLM machine, the same card covers both fronts: we have already written a review of which LLM models deserve your GPU right now, and that reasoning applies here as well.
On AMD, ComfyUI works via ROCm on Linux, with slightly more friction than CUDA; on Mac, Apple Silicon’s unified memory allows loading full Flux with offloading, in exchange for being slower than an equivalent NVIDIA. Before buying, decide your working precision: with GGUF, 16 GB is plenty; for bf16 without offloading, aim for 24. In the second-hand market, the RTX 3090 remains the reference for this niche.
A typical workflow, node by node
The text-to-image flow with Flux has a recognizable anatomy: a loader for the UNet, double text encoders (T5-XXL and CLIP-L) that translate your prompt into the embeddings the model understands, a VAE loader, an empty latent with the chosen resolution, the KSampler that traverses the reverse noise steps, and finally, the decoder and the save node. Each piece is replaceable without rebuilding the graph: you change the sampler, chain a LoRA between the model and the sampler, insert ControlNet to fix a pose, or add an upscale node for the finish.
The encoders deserve their own paragraph. In Flux, CLIP-L provides the classic composition signals and T5-XXL handles the weight of long natural language; this is why workflows duplicate the text nodes and, on cards with tight VRAM, it is advisable to also load a quantized version of T5.
Text-to-image is only half the catalog. Img2img reuses the same graph, replaces the empty latent with a loaded image, and regulates how much of the original structure is respected via the denoise level. ControlNet nodes offer variants for edges, depth, or pose skeletons, and upscaling can work at the latent level or with dedicated models. Everything remains within the same JSON.
A concrete exercise: open the official Flux template, replace the loaders with your variant (GGUF or fp8 if VRAM is tight), and save the JSON in a repository with a commit stating what you altered. A versioned workflow is executable documentation, not a screenshot.
Your server, your data: Privacy, costs, and automation
With everything running locally, sensitive assets do not travel: client sketches, characters in development, or material covered by an NDA stay on the server. The marginal cost per image tends toward zero, so generating a hundred variants of a pose doesn’t move the needle on a counter. One honest caveat: ComfyUI now includes API nodes that call external providers; if privacy is the reason for the setup, work only with local weights.
Automation is the silent half of the project. Enable developer mode in the interface settings, export the workflow in API format from the canvas itself, and save that JSON; then launch it against the /prompt endpoint with your prompts as variables. Progress and finished images arrive via the WebSocket on port 8188. With a Python script or a cron job, the canvas becomes an internal service that the rest of the team consumes without ever opening ComfyUI.
For network exposure, the standard advice applies: keep port 8188 within the local network or a VPN, and if you need to open it, place a reverse proxy with authentication and TLS in front. nginx or Caddy can solve this quickly; ComfyUI is not designed to be exposed directly to the internet.
This is the point where "without depending on anyone" stops being a slogan: no surprise model changes, no per-image prices that renew themselves. The workflow lives in the repository, not in the designer’s head.
Where to start
The short path, in five steps:
- Install ComfyUI Desktop on Windows or macOS; on Linux, cloning the repository with its Python environment remains the most stable route.
- Load an SDXL template and generate your first image: the goal is to understand the graph, not to make art.
- If your GPU doesn’t reach 24 GB, switch to FLUX.1 [dev] in GGUF and compare results with and without quantization.
- Replace the fixed prompt with variables and trigger the workflow from a script against
/prompt. - Version the JSONs in git and document each change in the commit.
The next logical checkpoint for such a setup comes when the GPU falls short, and at that point, the entire graph moves to a larger machine without retouching a single connection: the JSON continues to work exactly the same. This portability, more than any specific benchmark, is what turns every workflow into an investment rather than an expense: the same recipe works today in your tower and tomorrow on the rack server.