Skip to content

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.safetensors you put into checkpoints in 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 contains v1-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 → save

A checkpoint contains three things. The classic workflow uses Load Checkpoint to load one file, but internally this file is a three-piece set:

ComponentWhat it does
MODEL (UNet)The diffusion model itself, responsible for predicting noise and progressively denoising to produce an image
CLIPThe text encoder, which translates your prompt into semantic vectors the model can understand
VAEEncoder/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)
ModelSD1.5 single checkpointZ-Image-Turbo three files
Loading nodesLoad Checkpoint, oneUNETLoader + CLIPLoader + VAELoader, three
Canvas nodeEmpty Latent Image (512×512)EmptySD3LatentImage (1024×1024)
Sampling parameters20 steps, cfg 8, euler / normal8 steps, cfg 1, res_multistep / simple
Unique node—ModelSamplingAuraFlow (shift adjustment)
Remaining nodesCLIP Text Encode ×2, KSampler, VAE Decode, Save Imageidentical

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:

FileWhich subdirectory to put it inDownload link
z_image_turbo_bf16.safetensorsmodels/diffusion_models/Hugging Face
qwen_3_4b.safetensorsmodels/text_encoders/Hugging Face
ae.safetensorsmodels/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 ─────────────────────────→ KSampler

Load 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:

NodePurposeKey parameters in the default workflow
UNETLoaderLoads only the diffusion model (the first of the three-part set, split apart)z_image_turbo_bf16.safetensors
CLIPLoaderLoads only the text encoderqwen_3_4b.safetensors, type lumina2
VAELoaderLoads only the VAEae.safetensors
ModelSamplingAuraFlowApplies a noise-schedule patch to the model; shift controls the noise distributionshift = 3
CLIP Text Encode ×2Same as the classic workflow: positive / negativenegative defaults to low quality, bad anatomy, extra digits...
EmptySD3LatentImageSame role as Empty Latent Image1024×1024, batch 1
KSamplerSame as the classic workflow, with more "Turbo" parameters8 steps, cfg 1, res_multistep / simple, denoise 1
VAEDecodeSame as the classic workflow—
SaveImageSame as the classic workflowprefix 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, 4k quality words like these can improve image quality

Three sets of example prompts from the official tutorial—copy them directly and try:

Anime style

text
正向: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 fingers

Realistic portrait

text
正向:(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

text
正向: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:

  1. Check once more: the loader has a model selected, prompts are filled in, and the size is fine
  2. Click the Run button above the canvas, or press the shortcut Ctrl + Enter
  3. Wait for execution: the Run bar shows the queued jobs (active jobs count); to abort, click Cancel next to it
  4. 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):

ParameterPurposeHow to understand it
modelWhich diffusion model to connectThe fundamental determinant of style and quality
positivePositive conditioningGuides generation toward the elements you want
negativeNegative conditioningSuppresses content you don't want
latent_imageThe latent space to be denoisedThe noise-initialized carrier (size is set here)
seedRandom seedControls randomness; same seed + same parameters = reproduces the same image
control_after_generateSeed strategy after generationrandomize changes each time, fixed stays fixed
stepsDenoising stepsMore steps mean richer detail, but slower
cfgPrompt guidance strengthHigher is more obedient; the official docs warn that too high causes overfitting
sampler_nameSampling algorithmThe mathematical method for the denoising path (euler, res_multistep...)
schedulerSchedulerControls the noise decay rhythm and step size allocation (normal, simple...)
denoiseDenoise strength0.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):

ParameterClassic SD1.5 workflowZ-Image-Turbo default workflowNotes
steps208A low step count in distilled models is a feature, not laziness
cfg81For Turbo-type models, cfg is simply 1
sampler / schedulereuler / normalres_multistep / simpleJust follow the workflow
denoise1.01.0Text-to-image starts from pure noise, so it's fixed at 1.0
seedrandomizefixedFix it to reproduce, randomize it to roll the dice
Size512×5121024×1024Don'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
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.