If you've used Stable Diffusion through a simple form, where you type a prompt, pick a size and hit generate, ComfyUI will feel like a different world. Instead of hiding the pipeline behind a button, it shows you the whole thing as a graph of connected nodes. That's more to learn up front, but it pays off the moment you want to do something the form doesn't offer. This guide is written for that first week. Get it installed, understand what each node does, and build muscle memory on the default text-to-image graph before you go anywhere near the fancy stuff.
What ComfyUI is and why node-based
ComfyUI is a free, open-source interface for running diffusion models such as Stable Diffusion 1.5, SDXL, SD3 and FLUX, built around a visual node graph. Every step of image generation is a separate box. One node loads the model, another turns your text into something the model understands, another does the actual sampling, and another decodes the result into a picture. You wire them together with cables, and the data flows left to right along those cables.
Why bother with all that instead of a form? Because a form can only expose the options its author decided to show you. A node graph exposes the pipeline itself. Say you want two prompts blended together, or a second sampling pass at higher resolution, or the same seed fed into three different models side by side. In a form that's impossible, or buried in a plugin. In ComfyUI you just add a node and drag a cable. It's efficient, too. ComfyUI only re-runs the parts of the graph that actually changed, so tweaking a prompt doesn't force it to reload the entire model. Once a workflow works, you can save it as a file and reload it, or drop it into someone else's ComfyUI and get the identical setup, because the workflow is embedded in the PNG images it produces.
Installing ComfyUI (Windows and Mac)
There are two common ways to install, and which you pick depends on your patience and your operating system.
Windows portable build (easiest). The ComfyUI team publishes a standalone portable package on the project's GitHub releases page. Download the .7z archive, extract it anywhere, and run run_nvidia_gpu.bat if you have an NVIDIA card (or run_cpu.bat to test without a GPU). Nothing is installed system-wide. Everything lives in that one folder, including its own Python. This is the fastest path for most Windows users with an NVIDIA GPU.
Desktop app. There is also an official ComfyUI desktop application (Windows and macOS) that bundles the install into a normal one-click installer. If you just want it running with no command line at all, this is the gentlest option.
Mac (Apple Silicon) and manual install. On an M-series Mac, or if you want full control, do the manual install. Clone the repository with git clone, create a Python virtual environment, install the requirements with pip, and launch with python main.py. Apple Silicon runs through the MPS backend, so it works but is slower than a comparable NVIDIA card. The manual route is also what you'll want on Linux or when you plan to update ComfyUI often, since updating is just a git pull.
You still need a model. ComfyUI ships without any checkpoints. It's just the engine. Download a checkpoint file (an SDXL or SD 1.5 .safetensors model from a source like Civitai or Hugging Face) and drop it into ComfyUI/models/checkpoints/. Restart, and it'll appear in the Load Checkpoint node. Whatever you do, prefer .safetensors over old .ckpt files, since that format can't execute hidden code.
Your first text-to-image workflow
When ComfyUI opens for the first time it already has the default text-to-image graph loaded. Don't clear it. Read it. It's the canonical chain every beginner should be able to draw from memory, and it goes like this:
Load Checkpoint → CLIP Text Encode (×2) → KSampler → VAE Decode → Save Image.
1. Load Checkpoint. This node loads your model file and outputs three things: the MODEL (the diffusion network), the CLIP (the text encoder), and the VAE (the image encoder/decoder). Those three outputs feed the rest of the graph.
2. CLIP Text Encode (Prompt). There are two of these — one for your positive prompt (what you want) and one for the negative prompt (what you don't). Each takes the CLIP output from the checkpoint and turns your words into a conditioning tensor the sampler can steer toward or away from.
3. KSampler. This is the heart of the graph. It takes the MODEL, the positive and negative conditioning, and an empty latent image, then runs the actual denoising loop. Its key settings are the seed (change it for a different image, keep it to reproduce one), steps (how many denoising iterations, typically 20–30), cfg (how hard it obeys the prompt, usually 5–8), and the sampler and scheduler. The empty latent, an Empty Latent Image node, is where you set your output resolution.
4. VAE Decode. The KSampler works in compressed "latent" space, not real pixels. VAE Decode takes that latent output plus the VAE from your checkpoint and converts it into an actual image.
5. Save Image. The final node writes the decoded image to your ComfyUI/output/ folder, and it embeds the entire workflow inside the PNG, so you can drag that file back onto the canvas later to recreate exactly how it was made.
Hit "Queue Prompt" (or Ctrl+Enter). ComfyUI lights up each node as data passes through it, and your first image lands in the Save Image preview. That's the whole loop. Everything more advanced is just this chain with extra nodes spliced in.
Core nodes you must know
Beyond the default graph, a handful of nodes come up constantly. Learn these and you can read almost any beginner workflow:
Empty Latent Image sets your resolution and batch size. Start at 512×512 for SD 1.5 or 1024×1024 for SDXL. Load Image and VAE Encode are how you feed an existing picture in for image-to-image. Upscale nodes (either latent upscale or a model-based upscaler) enlarge your result. LoraLoader injects a LoRA to shift style or add a character; it sits between the checkpoint and the sampler, modifying both MODEL and CLIP. ControlNet nodes let you guide composition with a pose, depth map or edge map. And Preview Image is like Save Image but doesn't write to disk, which is handy while you iterate. You don't need all of these on day one, but you'll meet them fast.
ComfyUI vs Automatic1111: when to use which
Both are free, both run Stable Diffusion locally, and the argument between them is real. But it's not about which is "better," it's about what you're doing.
Automatic1111 (and its Forge fork) is a traditional web form of tabs, sliders and dropdowns. You can generate your first image in under a minute and never see a node. It has a massive extension ecosystem and enormous community documentation. For a beginner who just wants images, or for quick one-off generations, it's the faster on-ramp.
ComfyUI asks you to build the pipeline, which is more to learn, but rewards you with flexibility, speed and reproducibility. It's generally lighter on VRAM, it only recomputes what changed, and complex multi-stage workflows that would need a chain of extensions in Automatic1111 are just a few extra nodes here. It also tends to support the newest models first.
The honest recommendation: if you're brand new and unsure you'll stick with this, start on Automatic1111. The moment you find yourself fighting the form, wanting a second pass, a custom order of operations, or a workflow you can hand to a teammate exactly as-is, switch to ComfyUI. Plenty of people keep both installed.
Common beginner mistakes
1. Wrong resolution for the model. Generating at 1024×1024 on an SD 1.5 checkpoint produces duplicated heads and mangled anatomy. SD 1.5 wants ~512px, SDXL wants ~1024px. Match the latent size to the model.
2. Forgetting the VAE. Washed-out, grey, or oddly desaturated images almost always mean the VAE isn't wired correctly, or the checkpoint needs an external VAE loaded via a Load VAE node.
3. Cranking CFG too high. A cfg of 15+ doesn't mean "follow my prompt harder," it means fried, over-saturated, crunchy images. Stay around 5–8 for most models.
4. Downloading random .ckpt files. Prefer .safetensors, the safe format that can't run hidden code. And keep custom nodes in check. Installing dozens from the ComfyUI Manager is the fastest way to break your install.
5. Not saving the workflow. Beginners lose a setup they spent an hour on. Remember that the workflow is embedded in every PNG you save, and you can also export it as a .json. Drag the image back onto the canvas to restore everything.
PAM AI Studio: let's build your ComfyUI pipeline
Knowing which workflow to build, which model to load, and where a node-based pipeline actually earns its keep versus a real camera on a real set — that judgment is the whole game, and it's what we do every week. We've been running Stable Diffusion and ComfyUI through our production and post pipeline for over two years.
In a 30-minute discovery call, we'll map where AI image generation creates real leverage for your brand or agency, and where it doesn't. No hype, no black box.
Let's build it together.
We've been producing commercial film and photography since 2018, and for the last three years we've been integrating AI into our workflow. We mentor your team as we produce: transparent process, documented decisions, no black box. We set up your brand's AI production together, built for sustainable growth.
Email: [email protected]
Phone: +90 530 267 49 29
Studio: Yayıncılar Sok. 10/3, Seyrantepe · Istanbul