Generate Images Locally With ComfyUI

Most image-generation apps hide the work behind a prompt box and a few sliders. ComfyUI does the opposite: it shows you the whole chain as a graph of nodes you wire together. Load a model, encode the prompt, sample, decode, save, each step is a box on a canvas. That is exactly why it looks intimidating, and exactly why it is the most flexible open-source image tool there is.

The good news for a first run: you do not have to build anything. ComfyUI ships with a default workflow already wired up. Your job for the first hour is “edit the prompt, click a button, get an image.” Everything we produce in the studio runs through ComfyUI, and daily use really is that simple once it is set up. Here is how to get there.

What you will end up with

• ComfyUI installed and running in your browser at http://localhost:8188.
• A model in the right folder so the default workflow has something to run.
• Your first generated image, made entirely on your own machine.

No subscription, no credits, no images leaving your disk.

Before you start

You need a Mac, Windows, or Linux machine with 16GB of system RAM. A GPU is strongly recommended: Apple Silicon, NVIDIA, or AMD all work. For the better models like Flux you want 8GB or more of VRAM, or 16GB-plus of unified memory on a Mac. You can run on CPU, but it is slow enough that you will not enjoy it.

This is a power-user tool, the most involved setup we cover. The payoff is that nothing else gives you this much control. If you only want to type a prompt and get an image with zero learning curve, Fooocus uses the same underlying engines with a far simpler interface, and it is what we hand to beginners.

On Mac and Linux you will need Python 3 and git. On Windows there is a portable build that skips all of that, covered below.

Step 1: Install ComfyUI

On Windows, take the easy path: the portable build.

1. Go to https://github.com/comfyanonymous/ComfyUI/releases.
2. Download ComfyUI_windows_portable.7z and extract it.
3. Run run_nvidia_gpu.bat if you have an NVIDIA card, or run_cpu.bat if you do not.

On macOS and Linux, install from the repo into a virtual environment:

# clone
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI

# create a venv (recommended)
python3 -m venv venv
source venv/bin/activate

# install requirements
pip install -r requirements.txt

On Apple Silicon, that requirements install uses MPS for GPU acceleration automatically, nothing extra to configure. On Linux or Windows with an NVIDIA card, install the CUDA build of PyTorch first, then the rest:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt

Step 2: Download a model

ComfyUI does not ship with a model, and it will warn you if it cannot find one. The default workflow expects a checkpoint in models/checkpoints/. A standard SD 1.5 model is a fine starting point because it is small and runs on almost anything:

curl -L -o models/checkpoints/v1-5-pruned-emaonly.safetensors \
  https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors

The folder structure matters more than you would expect. Checkpoints, VAEs, LoRAs, and embeddings each go in their own subfolder under models/. Put a file in the wrong place and it simply will not appear in the UI, with no error to explain why.

Step 3: Launch and open the canvas

Start the server:

python main.py

Then open http://localhost:8188 in your browser. The default workflow loads automatically, a basic generation pipeline already wired together. You are looking at a graph of connected nodes. Do not try to understand all of it yet.

Prove it works

You can generate your first image without building anything:

1. Find the Load Checkpoint node and confirm your model name appears in it. If it does not, the model file is in the wrong folder, go back to step 2.
2. Find the CLIP Text Encode (Positive Prompt) node and edit the text to whatever you want to generate.
3. Click Queue Prompt in the top right.
4. Watch the progress move through the nodes.
5. The finished image appears in the Save Image node.

That is the whole loop, and it is the loop you will use every day: edit the prompt, queue, look at the result. The first time it works, remember what just happened. The image was generated on this disk, no cloud, no credits spent.

To get a feel for the node graph, change one parameter, the seed, the step count, or the sampler, and queue again. Comparing two runs that differ by one setting is the fastest way to understand what each node does.

Trade-offs and gotchas

ComfyUI rewards the time you put in, but a few things bite newcomers.

• The node graph is a real learning curve. Nodes go everywhere, and it feels like a lot at first. The reassurance worth holding onto: for most use, “drag in a workflow, edit the prompt, run” is the entire job.
• Model folders are unforgiving. A file in the wrong subfolder under models/ just will not show up. When something is missing from the UI, check the folder first.
• The first Flux generation is slow. The Flux model is large (12GB or more for the FP8 version) and takes time to load. Once it is in memory, later generations are fast.
• On Apple Silicon, VRAM is unified memory. You can run Flux on a 32GB-plus Mac, but it eats into everything else while it is loaded.
• Custom nodes can break on update. ComfyUI ships frequently, and community node packs sometimes lag behind. If a workflow matters, pin it to a known-good state rather than updating blindly.
• Workflows are not always portable between machines. Different model file names, paths, or node versions can break a shared workflow. Document yours carefully if you plan to move it.

Our verdict, in short: ComfyUI is the cornerstone of our image production. Every featured image we make runs through it. We reach for Fooocus when teaching beginners or showing a client something fast, but for actual production it is ComfyUI every time, because we need specific models, we rely on custom workflows, and the community ships new model support as ComfyUI nodes first. The node graph pays back fast for any studio making more than a handful of images a week.

Where to go next

Two upgrades matter most once the basics work. First, install ComfyUI Manager (https://github.com/ltdrdata/ComfyUI-Manager), which makes finding and installing nodes and models far less painful. Second, once you are comfortable, move up to a stronger model like Flux for sharper results, with the larger download and VRAM cost that comes with it.

The fastest way to learn the node graph is to load someone else’s workflow rather than building from zero. Drag a workflow JSON file onto the canvas and the entire pipeline loads at once. The official examples and the Civitai community are full of them.

You now have a complete image-generation pipeline running on your own machine, where every step is visible and adjustable, and not a single image leaves your disk. Curious about these things. You should be too.