Your First Image: A Node-by-Node Deep Dive Into the Default Workflow
With ComfyUI installed and your models in place, the next goal of this lesson is: get your first ComfyUI text-to-image run working — and not just "click through it once and done," but to explain every node of that default workflow on your screen — what each block does, what the parameters mean, and how the data flows.
First, let's clear one thing up so you don't get confused: the example workflow used in the official beginner tutorial and the default workflow built into the current version of ComfyUI are not the same set.
- The classic workflow taught in the official beginner docs: SD1.5 six nodes (Load Checkpoint → CLIP Text Encode → Empty Latent Image → KSampler → VAE Decode → Save Image; the official tutorial covers them as six node categories, with the positive and negative CLIP Text Encode counted as one), handled by a single checkpoint file — the
v1-5-pruned-emaonly-fp16.safetensorsyou put intocheckpointsin the last lesson is for it - The default workflow built into the current version (since v0.41.0): a ten-node workflow based on Z-Image-Turbo, with the model split into three files loaded separately, outputting 1024×1024 images
This page walks through both sets node by node. Their skeleton is identical: load the model → encode the prompts → create a blank canvas → denoise and sample → decode into an image → save. Learn one set, and you'll be able to read any ComfyUI text-to-image workflow.
What You'll Be Able to Do After This Lesson
- Independently complete your first ComfyUI text-to-image run: load the workflow → fill in the models → write prompts → click Run → save the image
- Name the responsibility of every node in the classic six-node workflow: Load Checkpoint, CLIP Text Encode, Empty Latent Image, KSampler, VAE Decode, Save Image
- Understand the Z-Image-Turbo default workflow built into the current version and know how its nodes differ from the classic workflow
- Write positive/negative prompts and use the
(关键词:1.2)weight syntax to emphasize a word - Tune KSampler's steps, cfg, denoise, and seed, and know what happens when you change each parameter
Where You Are Now
- You open ComfyUI and see a screen full of blocks and wires, with no idea where to start, afraid that one wrong click will break something
- Red warnings float on the nodes saying models are missing, and you don't know which file to download or which folder to put it in
- You follow online tutorials to find nodes, but the workflow in your interface doesn't match the tutorial screenshots, and the more you look, the more confused you get
When to Use This Approach
When you need to:
- Produce your first AI-generated image and confirm the whole environment works
- Understand the node-based image-generation pipeline instead of only knowing how to "wire things up per the tutorial"
- Lay the groundwork for later learning of model workflows like Z-Image-Turbo, Qwen-Image, and FLUX
And you don't want to:
- Feel completely lost the moment you switch models or workflows
- Want to reinstall everything the moment you see a red error
🎒 Preparation Before You Start
- Have ComfyUI installed and able to launch: for the Windows portable package see Installation: Windows Portable Package; for the desktop app / macOS / Linux see Alternative Installations
- Have finished the previous lesson Where to Put Models:
models/checkpoints/already containsv1-5-pruned-emaonly-fp16.safetensors(the official beginner model, about 4GB) - Don't be too tight on VRAM: the official docs say SD1.5 is about 4GB in size and runs smoothly on a consumer GPU with 6GB of VRAM; the Z-Image-Turbo route recommends 16GB of VRAM
- Your network can reach Hugging Face: automatic downloads of missing models pull files from Hugging Face, and networks in China may need a proxy (slow downloads don't mean you did something wrong)
💡 The Interface Is in Chinese
ComfyUI supports a Chinese interface: open Settings and select Chinese under Comfy → Locale. Button names on this page follow the English interface; the Chinese names mostly match up.
Core Idea
Text-to-image is "commissioning a painting." The official docs use a very plain analogy: you tell a painter (the image-generation model) your requirements (positive prompt = what you want, negative prompt = what you don't want), and the painter creates accordingly. Technically, a diffusion model performs reverse diffusion: starting from pure Gaussian noise, it denoises step by step until the image that matches the prompt finally "develops."
Denoising happens in latent space, not pixel space. Latent space is a compressed representation of the image — think of an architect's blueprint: changing the design on the blueprint is far cheaper than altering the finished building. So the pipeline is "noise latent → KSampler denoises step by step → VAE decodes → pixel image." The model works entirely on the "blueprint" and only turns it into the image you can see at the very last step.
Workflow = pipeline. Every node on the canvas is a processing step, and the connecting lines are the data flow. The skeleton of a text-to-image workflow has six steps:
Load model → encode prompt → create empty canvas → denoise and sample → decode into an image → saveA checkpoint contains three things. The classic workflow uses Load Checkpoint to load one file, but internally this file is a three-piece set:
| Component | What it does |
|---|---|
| MODEL (UNet) | The diffusion model itself, responsible for predicting noise and progressively denoising to produce an image |
| CLIP | The text encoder, which translates your prompt into semantic vectors the model can understand |
| VAE | Encoder/decoder, converting back and forth between pixel space and latent space |
Newer models (Z-Image-Turbo, FLUX, Wan2.2...) are mostly no longer packaged as a single checkpoint; instead, the three pieces are split into separate files loaded by their own loaders — this is why the two workflows have different node counts.
Comparison of the two workflows (both are explained node by node on this page):
| Classic teaching workflow (official getting-started docs) | Built-in default workflow (since v0.41.0) | |
|---|---|---|
| Model | SD1.5 single checkpoint | Z-Image-Turbo three files |
| Loading nodes | Load Checkpoint, one | UNETLoader + CLIPLoader + VAELoader, three |
| Canvas node | Empty Latent Image (512×512) | EmptySD3LatentImage (1024×1024) |
| Sampling parameters | 20 steps, cfg 8, euler / normal | 8 steps, cfg 1, res_multistep / simple |
| Unique node | — | ModelSamplingAuraFlow (shift adjustment) |
| Remaining nodes | CLIP Text Encode ×2, KSampler, VAE Decode, Save Image | identical |
Starting with v0.41.0, the server adds a default workflow route (/default_workflow), and the built-in default workflow updates with each version — if the nodes you see at startup differ from this page, it's most likely a version difference and won't affect your learning.
Follow along
Step 1: Start ComfyUI and load a text-to-image workflow
Why: everything in ComfyUI text-to-image happens in a workflow on the canvas, so first make sure there is a complete text-to-image workflow on the canvas.
How: Start ComfyUI (double-click run_nvidia_gpu.bat for the portable package, double-click the icon for the desktop version), then open 127.0.0.1:8188 in your browser. The official docs state: ComfyUI** usually loads the default text-to-image workflow automatically at startup** — for a fresh install of the current version, what gets loaded is the Z-Image-Turbo workflow from the table above.
If you want to follow the official getting-started tutorial's classic SD1.5 six-node workflow (Step 3 on this page uses it as the main thread, explained node by node), choose any of the three loading methods:
Method A: Drag in an example image (recommended)
Every generated image in ComfyUI carries workflow metadata, and dragging the image onto the canvas restores the workflow. The official tutorial provides a ready-made example image: text-to-image-workflow.png. After downloading it, drag it directly into the ComfyUI window.
Method B: Open the workflow JSON
The official docs provide the JSON file for the classic workflow: text-to-image.json. After downloading it, open it via the menu Workflows → Open.
Method C: Load from the template library
Browse the official template library in the sidebar Workflows panel to load all kinds of workflows with one click; missing models can even be downloaded automatically — see Template Library for specific usage.
You should see: a row of nodes connected by lines appear on the canvas, running from the model-loading node on the left all the way to Save Image on the right.
- There is a complete text-to-image workflow on the canvas (the six-node classic version or the ten-node default version)
Step 2: Fill in the models — download what's missing and put it in the right place
Why: the ComfyUI installation package does not include models. When a model file referenced by the workflow doesn't exist, the corresponding node shows a red missing warning, and clicking Run will simply produce an error.
How: Look at the warnings on the nodes. The official getting-started docs describe the process as: see the missing-model warning → click the warning to see which file is missing and the download link → fill it in.
Route A: Classic workflow (SD1.5, one file)
In the previous lesson you already put v1-5-pruned-emaonly-fp16.safetensors into models/checkpoints/. Press r on the canvas to refresh node definitions, then select it in the Load Checkpoint dropdown list. If you haven't downloaded it yet, go to the Hugging Face official archive page to download it manually.
Route B: Default workflow (Z-Image-Turbo, three files)
The default workflow references three files; the download links and storage locations given by the official tutorial:
| File | Which subdirectory to put it in | Download link |
|---|---|---|
z_image_turbo_bf16.safetensors | models/diffusion_models/ | Hugging Face |
qwen_3_4b.safetensors | models/text_encoders/ | Hugging Face |
ae.safetensors | models/vae/ | Hugging Face |
Once placed, press r to refresh, then select the corresponding file in each of the three loader nodes' dropdown lists. If you're unsure which file goes in which slot, review the comparison table in Where to Put Models.
How automatic download is triggered
Click the Download button in the missing-model warning; the two installation methods behave differently (per the official docs):
- Comfy Desktop: automatically downloads and stores the file into the corresponding subdirectory of
ComfyUI/models/; progress is visible in the sidebar models panel - ComfyUI Portable: triggers a browser download; once finished, you move the file into the corresponding subdirectory yourself
⚠️ Download stuck?
Automatic downloads pull files from Hugging Face, and the official docs remind you to make sure your network can connect to Hugging Face stably. If there's no progress for a long time, copy the download link and download manually, or configure a proxy and retry.
You should see: all red missing warnings are gone, and every loader node's dropdown list lets you select a file name (not empty, and not showing null).
- No red missing warnings in the workflow, and all loader nodes have the correct model files selected
Step 3: Walk through the ComfyUI text-to-image workflow node by node
Why: This is the core of this lesson. Only when you understand each node's responsibility and parameters have you truly learned "how ComfyUI generates images," rather than being a human copy machine.
First, look at the classic SD1.5 six-node workflow (data flows from left to right):
Load Checkpoint ──┬── MODEL ──────────────────→ KSampler ──→ VAE Decode ──→ Save Image
├── CLIP ──→ CLIP Text Encode(正向)──→ KSampler
│ └→ CLIP Text Encode(负向)──→ KSampler
└── VAE ──────────────────────────→ VAE Decode
Empty Latent Image ─────────────────────────→ KSamplerLoad Checkpoint: one file holding three things
Loads the image-generation model. A checkpoint internally contains a trio of MODEL (UNet, responsible for denoising), CLIP (text encoder), and VAE (latent↔pixel conversion), so it has three output ports, each connected to different downstream nodes. The dropdown lists all files in models/checkpoints/—this is where the directory rules from the last lesson come into play: files placed in the wrong subdirectory won't appear in this list.
CLIP Text Encode (×2): translating your prompts for the model
Models can't read human language. Using the CLIP component output by Load Checkpoint, this node encodes the prompt you write into semantic vectors (officially called "conditioning," CONDITIONING). There are two in the workflow:
- The one connected to the KSampler positive input port: the positive prompt, what you want
- The one connected to the KSampler negative input port: the negative prompt, what you don't want
Empty Latent Image: setting up a blank canvas
Generates a pure-noise latent space, output to the KSampler as the denoising starting point. It determines the final image size—in the official example workflow it's 512×512 with batch size 1, right in SD1.5's comfort zone (it was trained at 512×512 resolution). To output a larger image, change it here.
KSampler: the denoising core, the heart of the whole workflow
The entire reverse diffusion happens here: it creates the initial noise using seed as the random source, iteratively denoises for the number of steps specified by steps, referencing both the positive/negative conditioning sets at each step, and finally outputs a "clean" latent space. For how to tune the parameters, there's a full parameter table in Step 5.
VAE Decode: latent space → pixels
Decodes the latent-space image output by the KSampler into a pixel image you can actually see. The VAE used is the one output by Load Checkpoint. Without this step, the screen would just show a bunch of numbers.
Save Image: preview and save
Displays the decoded image and saves it into the ComfyUI/output/ folder. filename_prefix is the filename prefix, defaulting to ComfyUI. Right-clicking the image lets you save it elsewhere.
Now look at the Z-Image-Turbo default workflow built into the current version, node by node:
| Node | Purpose | Key parameters in the default workflow |
|---|---|---|
| UNETLoader | Loads only the diffusion model (the first of the three-part set, split apart) | z_image_turbo_bf16.safetensors |
| CLIPLoader | Loads only the text encoder | qwen_3_4b.safetensors, type lumina2 |
| VAELoader | Loads only the VAE | ae.safetensors |
| ModelSamplingAuraFlow | Applies a noise-schedule patch to the model; shift controls the noise distribution | shift = 3 |
| CLIP Text Encode ×2 | Same as the classic workflow: positive / negative | negative defaults to low quality, bad anatomy, extra digits... |
| EmptySD3LatentImage | Same role as Empty Latent Image | 1024×1024, batch 1 |
| KSampler | Same as the classic workflow, with more "Turbo" parameters | 8 steps, cfg 1, res_multistep / simple, denoise 1 |
| VAEDecode | Same as the classic workflow | — |
| SaveImage | Same as the classic workflow | prefix ComfyUI |
Once you understand the six-node classic version, this table is just "a different loading approach + one extra schedule patch," with everything else unchanged. Z-Image-Turbo is a distilled model; the official tutorial says it can produce images in 8 steps, fits consumer-grade devices with 16GB of VRAM, and is also good at rendering both Chinese and English text—to explore it in depth, see Z-Image-Turbo text-to-image.
You should see: looking at the canvas from left to right, you can state what each node does and what data flows through the connections.
- I can state the responsibility of every node on my own canvas (six-node or ten-node version)
Step 4: Write positive and negative prompts—tell the model what to draw
Why: Prompts are your only channel of communication with the model. Where you write them and how you write them directly determine what image you get.
Action: Find the two CLIP Text Encode nodes, use the connections to confirm which one goes to the KSampler's positive (positive) and which to negative (negative), then fill in the words.
The official tutorial gives five prompt principles for SD1.5:
- Use English whenever possible (SD1.5 understands English best)
- Separate phrases with an English comma
, - Use short phrases, not long sentences
- Be specific in descriptions ("a long red silk dress" is better than "pretty clothes")
- To emphasize a word, use the weight syntax
(golden hour:1.2)—the keyword goes inside the parentheses and the weight after the colon; the official docs explicitly say this makes it more likely to appear in the image;masterpiece, best quality, 4kquality words like these can improve image quality
Three sets of example prompts from the official tutorial—copy them directly and try:
Anime style
正向:anime style, 1girl with long pink hair, cherry blossom background, studio ghibli aesthetic, soft lighting, intricate details, masterpiece, best quality, 4k
负向:low quality, blurry, deformed hands, extra fingersRealistic portrait
正向:(ultra realistic portrait:1.3), (elegant woman in crimson silk dress:1.2), full body, soft cinematic lighting, (golden hour:1.2), (fujifilm XT4:1.1), shallow depth of field, (skin texture details:1.3), (film grain:1.1), gentle wind flow, warm color grading, (perfect facial symmetry:1.3)
负向:(deformed, cartoon, anime, doll, plastic skin, overexposed, blurry, extra fingers)Illustration style
正向:fantasy elf, detailed character, glowing magic, vibrant colors, long flowing hair, elegant armor, ethereal beauty, mystical forest, magical aura, high detail, soft lighting, fantasy portrait, Artgerm style
负向:blurry, low detail, cartoonish, unrealistic anatomy, out of focus, cluttered, flat lighting💡 Where do you write Chinese prompts?
In the SD1.5 era, write in English. If you're using the Z-Image-Turbo default workflow, the official docs say it supports both Chinese and English prompts and can even render Chinese and English text in images accurately—just write your Chinese requirements directly.
You should see: The text boxes of the two CLIP Text Encode nodes are filled with the positive and negative prompts respectively.
- Positive and negative prompts are filled in, and confirmed not to be swapped (check which KSampler port the connections point to)
Step 5: Click Run to generate your first image
Why: Everything before was preparation; this step is the actual "generation"—ComfyUI queues the entire pipeline for execution.
Action:
- Check once more: the loader has a model selected, prompts are filled in, and the size is fine
- Click the Run button above the canvas, or press the shortcut
Ctrl + Enter - Wait for execution: the Run bar shows the queued jobs (active jobs count); to abort, click Cancel next to it
- Once the image is generated, check the result in the Save Image node; right-click the image to save it locally (the file is also saved to
ComfyUI/output/)
You should see: the Run bar's job count starts moving, and after execution finishes, your first image appears in the Save Image node.
💡 Not satisfied? Run it again
The official tutorial's exact words: if you're not satisfied, run it a few more times. The sample workflow's seed control is randomize, so every KSampler execution picks a new random seed, producing different images each time.
Before clicking Run, it's worth spending two minutes getting to know each KSampler parameter (the official tutorial's full parameter table, common to both workflows):
| Parameter | Purpose | How to understand it |
|---|---|---|
| model | Which diffusion model to connect | The fundamental determinant of style and quality |
| positive | Positive conditioning | Guides generation toward the elements you want |
| negative | Negative conditioning | Suppresses content you don't want |
| latent_image | The latent space to be denoised | The noise-initialized carrier (size is set here) |
| seed | Random seed | Controls randomness; same seed + same parameters = reproduces the same image |
| control_after_generate | Seed strategy after generation | randomize changes each time, fixed stays fixed |
| steps | Denoising steps | More steps mean richer detail, but slower |
| cfg | Prompt guidance strength | Higher is more obedient; the official docs warn that too high causes overfitting |
| sampler_name | Sampling algorithm | The mathematical method for the denoising path (euler, res_multistep...) |
| scheduler | Scheduler | Controls the noise decay rhythm and step size allocation (normal, simple...) |
| denoise | Denoise strength | 0.0 preserves the original input, 1.0 fully denoises from pure noise |
For your first run, don't change anything—generate an image with the default parameters first. Afterwards you can experiment on your own: change the prompt and run again, adjust steps from 20 to 30 to compare detail, or fix the seed and change only the prompt to see cause and effect. The Z-Image-Turbo workflow's 8 steps + cfg 1 is the recommended configuration for distilled models—don't modify it by copying SD1.5's 20 steps + cfg 8.
- My first image appeared in the Save Image node and was saved locally
Checkpoint ✅
- I completed my first ComfyUI text-to-image run: load workflow → add model → write prompt → Run → save
- I can explain each node's role on the canvas, including what the MODEL / CLIP / VAE trio in Load Checkpoint each do
- I know the positive prompt connects to KSampler's positive and the negative to negative, and I can add weights with
(关键词:1.2) - I know what steps / cfg / denoise / seed each control, and can predict the effect before changing parameters
- I know the difference between the current version's built-in default workflow (Z-Image-Turbo) and the official tutorial's classic workflow (SD1.5)
Pitfall warnings
❌ Load Checkpoint shows null or the dropdown is empty
Official troubleshooting order: confirm the model is in the correct subdirectory (checkpoints go in models/checkpoints/) → press r on the canvas to refresh → restart ComfyUI. If it still fails, the problem is with the file itself; see Model loading failures. If you're unsure about directory rules, go back to Where to put models.
❌ A bunch of red warnings on nodes, no image generated
Red = missing model or invalid node parameters; images won't generate properly until they're fixed. Follow the process in step 2 to click the warnings and see which files are missing; once supplied, the warnings disappear automatically. If the missing model won't download in China, configure a proxy or download it manually and place it in the corresponding subdirectory.
❌ My interface looks nothing like the tutorial screenshots
Most likely you're not wrong: the official beginner tutorial's screenshots show the classic SD1.5 workflow, while the default workflow built into ComfyUI since v0.41.0 switched to Z-Image-Turbo, with different node counts and names. Check the two node tables in step 3 on this page to confirm which one you loaded; to load a specific workflow, use one of the three methods: drag an image, open a JSON, or use the template library.
❌ Blurry images, broken hands, frantically clicking Run and hoping
SD1.5's officially known weaknesses: hands and complex lighting tend to break, and generating directly at 1024×1024 degrades quality (it was trained at 512×512). Rather than clicking Run repeatedly, fix the seed, adjust the prompt (add deformed hands, extra fingers to the negative), and if necessary use an upscale workflow for post-processing—see Product image high-res upscaling for upscale techniques.
Advanced tips (optional)
🔧 The Run bar has more than one Run button: the floating Run bar at the top also has batch count (how many runs are enqueued at once, default 1), queue mode (Run only enqueues on click; Run (On Change) automatically re-runs whenever the workflow changes; Run (Instant) re-runs immediately after the current job finishes), and Cancel (cancels the current job). Hold Shift and click Run to insert the job at the front of the queue.
🔧 Images are workflow save files: ComfyUI-generated images embed workflow metadata; drag any image you generated back onto the canvas to restore the workflow and parameters from that time. To export proactively, use the menu Workflows → Export to save it as a JSON file.
🔧 Generate multiple images at once for comparison: increase batch count, or raise the batch parameter of Empty Latent Image, so one Run produces multiple images to pick the best from.
🔧 Shortcuts go beyond Ctrl+Enter: r refreshes node definitions, Ctrl+O opens a workflow; see Shortcuts & interface quick reference for the full key map.
Lesson summary
✅ ComfyUI text-to-image skeleton: load model → encode prompt → create empty canvas → KSampler denoise → VAE decode → save. All text-to-image workflows are variants of this skeleton.
✅ One checkpoint is a three-part set: MODEL (UNet) handles denoising, CLIP handles understanding prompts, and VAE handles converting between latent space and pixels; new models split the three parts and load them separately.
✅ You now recognize both workflows: the classic SD1.5 six-node workflow from the official tutorial (20 steps / cfg 8 / 512×512), and the built-in Z-Image-Turbo default workflow introduced in v0.41.0 (8 steps / cfg 1 / 1024×1024, with the three files installed separately).
✅ You can write prompts now: the positive prompt connects to positive, the negative prompt to negative; English phrases are separated by commas; use (关键词:1.2) weight syntax to emphasize keywords.
✅ How ComfyUI generates images: press Run or Ctrl + Enter to enqueue; the result appears in the Save Image node—right-click to save, and files land in ComfyUI/output/.
Key parameter recap (keeping the defaults is recommended for your first run):
| Parameter | Classic SD1.5 workflow | Z-Image-Turbo default workflow | Notes |
|---|---|---|---|
| steps | 20 | 8 | A low step count in distilled models is a feature, not laziness |
| cfg | 8 | 1 | For Turbo-type models, cfg is simply 1 |
| sampler / scheduler | euler / normal | res_multistep / simple | Just follow the workflow |
| denoise | 1.0 | 1.0 | Text-to-image starts from pure noise, so it's fixed at 1.0 |
| seed | randomize | fixed | Fix it to reproduce, randomize it to roll the dice |
| Size | 512×512 | 1024×1024 | Don't crank SD1.5 straight up to 1024 |
Next lesson preview
Your first image generation was just a warm-up. The real fun in ComfyUI is "pick the right model before you start": different models excel at completely different tasks. In the next lesson, Models × Tasks Overview will take you on a tour of the entire model library.
You will learn:
- What Z-Image-Turbo, Qwen-Image, FLUX, Wan2.2, and LTX each excel at, and how much VRAM they need
- Which model's workflow to choose for the same task (text-to-image / image editing / video generation)
- How to load the corresponding workflow from the official template library in one click
- Which route to take for practical scenarios like e-commerce images and videos