ComfyUI Beginner Guide: Install It, Read the Node UI, Place Models, and Generate Your First Image

You may already have heard that ComfyUI is the most flexible node-based interface for Stable Diffusion. The problem is that the first visit to the official site can still stop you at the door: Desktop, Portable, or Manual? Which folder should the model go in? Why does the UI open as a canvas full of boxes and wires? And after you finally install it, why does the first run hit Load Checkpoint showing null or CUDA out of memory?

This guide has one job: help you verify on day one that ComfyUI can start, detect a model, and generate the first image with the default workflow. It covers installation choices, the model folder layout, the core nodes in the UI, the first text-to-image run, and a troubleshooting checklist for common first-run failures. It does not cover advanced workflows, model comparisons, or hardware recommendations; those belong in later articles in this series.

How to choose an installation method

The ComfyUI website offers four installation paths: Desktop, Portable, Manual, and Cloud. The first three run locally. The last one runs in the cloud. The choice mostly comes down to two questions: do you have an NVIDIA GPU, and do you want to manage the Python environment yourself?

Installation method	Pros	Cons	Best for	Python environment	C drive usage	Download entry
Desktop	Simple installer with guided first launch	Fixed on the C drive, uses about 5GB; based on the stable release, so new features may arrive later	Beginners who want the fastest start	Automatic	About 5GB	Official download page
Portable	Unzip and run; can be placed on any drive; includes Python and dependencies	You need to choose the startup script manually; no installer wizard	Users who do not want to fill the C drive or already have multiple Python versions	Bundled and isolated	Depends on where you extract it	GitHub Release
Manual	Full control over versions and dependencies	You must configure Python, PyTorch, and CUDA yourself; more steps	Developers who already have a Python environment and want version control	Manual	Depends on the clone location	GitHub clone
Cloud	Ready to use without a local GPU	Charged by usage time or VRAM; access from China may be unstable	Users with insufficient local GPU resources or who do not want to install anything	Not needed	None	Official cloud option

Desktop bundles the dependencies into an installer and checks the environment on first launch. The trade-off is path control: the app is fixed on the C drive, and the model folder is usually under the user directory on the C drive. If your C drive is tight, or you want all models on another disk, Portable or Manual is usually a better fit.

Portable is a compressed package. After extraction, you can place the folder anywhere. Its startup scripts separate NVIDIA GPU mode (run_nvidia_gpu.bat) from CPU mode (run_cpu.bat), so you do not need to configure the Python version or the PyTorch CUDA backend yourself. It is a good choice when you want less environment work but still want control over the install location.

Manual installation is for developers who already have Python 3.10+ and know which PyTorch version they need. It has more steps than Desktop or Portable, but you can clone a specific branch and install specific dependency versions. I would not start here as a beginner; environment setup is already one of the easiest places to make a mistake.

The Cloud option is available from the official site. In practice, it rents cloud GPU resources to run ComfyUI. If your computer does not have an NVIDIA GPU, or you only want to try the interface quickly, the cloud version can be useful. Long-term use costs money, and access to overseas cloud services from China can be unstable.

Desktop installation steps

Desktop is the fastest path for a beginner who just wants to start. The installer handles the Python environment, dependency downloads, and path setup. You mainly click through the agreement and next steps.

Installation process

1. Open the ComfyUI website (docs.comfy.org) and find the Desktop download link in the Installation section. Choose the Windows version. macOS and Linux also have corresponding versions, but this guide uses Windows as the example.

2. Double-click the downloaded installer. The wizard will show the install path. By default, it is on the C drive and cannot be changed. If you need control over the installation location, do not choose Desktop; use Portable instead.

3. Finish the installation. On first launch, ComfyUI checks dependencies. If it reports missing components, the wizard downloads them automatically.

4. After startup, the browser opens http://127.0.0.1:8188. The UI should show either a blank node graph or the default workflow.

Model folder location

The Desktop model folder is not the same as the Portable model folder. By default, it lives under your user directory, not inside the install directory. On first launch, the model folder is empty, so the Load Checkpoint node shows null.

To find the folder, use the ComfyUI Desktop menu: Help -> Open folder -> Open models folder. This opens the models directory directly, so you do not need to hunt for the path manually.

Desktop can download models from inside the interface. If a base model is missing during startup, it may prompt you to click a download button. After that, the model is placed in the correct checkpoints folder. This automatic download only covers a few officially recommended base models. If you want third-party models from Civitai, LiblibAI, or similar sites, you still need to download them manually and put them in the checkpoints folder.

Checks after the first launch

After startup, confirm three things: the browser opened the UI and the address bar shows 127.0.0.1:8188; the right side of the UI has a Queue Prompt button; the left side or top area has a ComfyUI-Manager entry. Desktop usually includes Manager.

If the UI opens but Queue Prompt does nothing, or if a node is red, do not rush into generation. First check whether the model is in place. The next section covers the model path and refresh process.

Portable installation steps

Portable is better when you do not want to use the C drive, already have several Python versions, or want control over the install location. It is basically a package that includes Python and dependencies; after extraction, you run a startup script.

Download and extract

1. Open the ComfyUI GitHub repository (github.com/Comfy-Org/ComfyUI) and find the latest stable release in the Releases section. Download the Windows Portable package. It is usually a 7z or zip file with portable in the name.

2. Use 7-Zip or the system archive tool to extract it wherever you want. For example: D:\ComfyUI_portable. Keep the path reasonably short to avoid permission and path-length issues.

3. The extracted folder contains several important parts: ComfyUI (the core app and models folder), python_embeded (the bundled Python environment), and startup scripts such as run_nvidia_gpu.bat and run_cpu.bat.

Startup script selection

Portable provides several scripts for different GPU and runtime modes:

• run_nvidia_gpu.bat: Use this when you have an NVIDIA GPU and the driver is installed. It gives the best startup and generation performance.

• run_cpu.bat: Use this when you do not have an NVIDIA GPU, or when the NVIDIA driver is broken. It is much slower, but it can verify that the installation itself works.

• Other scripts such as run_nvidia_gpu_lowvram.bat are for low-VRAM cases. You do not need them for the very first launch unless you already know VRAM is the bottleneck.

Double-click the matching bat file. A command prompt window opens and prints the startup log, including the Python version, PyTorch CUDA backend, and model scan results. After a few seconds, the browser should open http://127.0.0.1:8188. If it does not, enter the address manually.

First startup log check

The command prompt log gives you a few useful signals:

• Starting server: the service has started.
• To see the GUI go to: http://127.0.0.1:8188: the browser address is correct.
• Total VRAM ...: ComfyUI detected your GPU memory.
• The models/checkpoints scan result: if a model exists, the filename appears; if not, only the path is shown.

If the log shows an error such as CUDA not available, check the GPU driver first. Portable already includes a PyTorch build with CUDA support, but the system still needs a working NVIDIA driver.

Manual installation (optional)

Manual installation is for developers who already have Python 3.10+ and know which PyTorch version they need. It has more steps than Desktop and Portable, and dependency configuration is easier to break. Beginners should not start here.

If you still want Manual, the core process is:

1. Run git clone https://github.com/Comfy-Org/ComfyUI.git in the target directory. If you need a specific branch or version, checkout the relevant tag after cloning.

2. Enter the cloned directory and find requirements.txt. Run pip install -r requirements.txt. This installs ComfyUI’s core dependencies, but it does not necessarily install the correct PyTorch CUDA backend. You need to handle that separately.

3. Install PyTorch. Choose the version based on your GPU. NVIDIA GPUs require a CUDA-enabled PyTorch build. Use the PyTorch official install guide for the exact command. If you install the CPU build by mistake, ComfyUI will report CUDA not available.

4. Start ComfyUI with python main.py. The default port is 8188, so open http://127.0.0.1:8188 in the browser.

Startup parameter notes

Manual supports several startup flags for VRAM usage and network settings:

• --lowvram: use this when VRAM is tight. It reduces VRAM usage but slows generation.
• --cpu: force CPU mode.
• --port 8188: change the listening port. The default is 8188.
• --listen 0.0.0.0: allow access from the local network. By default, only the local machine can access it.

If your GPU has less than 4GB of VRAM, adding --lowvram can reduce the chance of CUDA out of memory.

Version dependency risks

The main Manual risk is matching Python and PyTorch versions. The official recommendation is Python 3.10.x. Python 3.11 or 3.12 is not guaranteed to work. PyTorch also needs to match the CUDA version. If the system has CUDA 12.x but your PyTorch build targets CUDA 11.x, you may see CUDA-related failures.

When startup fails, read the command prompt log first. Common errors include ImportError: DLL load failed (PyTorch version mismatch), ModuleNotFoundError (missing dependency), and CUDA not available (CPU-only PyTorch or driver problem).

Where to place models

Model folders are one of the most common first-day blockers. ComfyUI does not ship with a base model. You need to download one and put it in the right folder. When Load Checkpoint shows null, the model is usually in the wrong place.

Model folder location

For Portable and Manual installations, the model folder is under the install directory:

<ComfyUI installation directory>/ComfyUI/models/

For example, if Portable is extracted to D:\ComfyUI_portable, the checkpoint folder is:

D:\ComfyUI_portable\ComfyUI\models\checkpoints\

Desktop uses a different model folder. It is usually under your user directory. You do not need to guess the path; use Help -> Open folder -> Open models folder, and ComfyUI opens the models directory for you.

What each subdirectory is for

The models directory contains several subfolders. Each model type has its own place:

Subdirectory	Purpose	Model file types
checkpoints	Base models such as SD 1.5 and SDXL	.safetensors, .ckpt
loras	LoRA fine-tuning models	.safetensors, .ckpt
vae	VAE decoders that affect color and detail	.safetensors, .pth
embeddings	Text embeddings for negative prompts or styles	.pt, .bin, .safetensors
controlnet	ControlNet control models	.safetensors, .pth
upscale_models	Upscaling models such as ESRGAN and RealESRGAN	.pth, .safetensors

For the first run, you only need a base model in checkpoints. The other model types are for more advanced workflows.

Model file formats

Base models usually use one of two formats: .safetensors or .ckpt. .safetensors is newer and safer, and ComfyUI officially recommends it when available. .ckpt is older, but some early models still use it. ComfyUI can recognize both, but if you have a choice, download .safetensors.

You can name the model file however you like, but including the model name and version makes later management easier. Examples: sd_v1-5.safetensors, sdxl_base_1.0.safetensors.

extra_model_paths.yaml

If you have multiple ComfyUI installations, or your models are spread across several drives, use extra_model_paths.yaml to add external paths. The file lives in the ComfyUI directory and uses YAML. You can specify multiple external model folders. Beginners do not need to edit it on the first run; the default paths are enough.

What the interface looks like

ComfyUI is built around the node graph. Each node is one operation, such as loading a model, entering prompts, sampling, or decoding. Connections pass data between nodes. Once you understand the node graph, the UI becomes much less mysterious.

Core interface elements

After opening the UI, you will see these areas:

• Node graph area: The center of the main UI. It shows all nodes and connections. You can drag nodes to move them, click a connection to delete it, and right-click a node to open its options.

• Queue Prompt button: Usually on the right side or top of the UI. It executes the workflow. After you click it, the node graph runs from left to right and generates an image.

• Clear button: Clears the current node graph and returns to an empty canvas.

• Save button: Saves the current workflow as a JSON file so it can be loaded again later.

• Load button: Loads a saved workflow JSON.

• Load Default button: Loads the default text-to-image workflow with the five core nodes.

• ComfyUI-Manager: A sidebar or menu entry for installing new nodes, updating installed nodes, and searching community workflows. Desktop and Portable usually include Manager. Manual installations need to install it separately.

The five core nodes in the default workflow

After you click Load Default, five nodes appear on the canvas. They are connected from left to right:

Node name	Function	Input/output
Load Checkpoint	Loads the base model and CLIP text encoder	Outputs: MODEL, CLIP, VAE
CLIP Text Encode (Prompt)	Encodes the positive prompt	Input: CLIP; output: CONDITIONING
CLIP Text Encode (Negative)	Encodes the negative prompt	Input: CLIP; output: CONDITIONING
KSampler	The latent-space sampler and the core image generation node	Inputs: MODEL, positive CONDITIONING, negative CONDITIONING, VAE; output: LATENT
VAE Decode	Decodes the latent image into a visible image	Inputs: VAE, LATENT; output: IMAGE
Save Image	Saves the image to the output directory and shows a preview	Input: IMAGE

The wires show data direction. For example, the CLIP output from Load Checkpoint connects to the CLIP input of both CLIP Text Encode nodes. The LATENT output from KSampler connects to the LATENT input of VAE Decode.

Right-click menu

Right-click a node to open the action menu. Common options include:

• Add Node: Add a new node near the current node.
• Remove: Delete the current node.
• Bypass: Skip the current node without executing it.
• Reroute: Add a reroute point to clean up connections.

Right-click a blank area and choose Add Node, then search for a node name to add a new node to the workflow.

Node input and output ports

Each node has input ports on the left and output ports on the right. Ports are shown as small dots, and their colors indicate data types:

• Purple: MODEL
• Yellow: CLIP
• Blue: VAE
• Green: CONDITIONING
• Red: LATENT
• White: IMAGE

When you connect nodes, the output port color must match the input port color. A MODEL output can connect to a MODEL input, but not to a CLIP input. If the types do not match, the connection cannot be created.

How to use the default workflow

The default workflow is ComfyUI’s minimal official text-to-image setup. It contains the five core nodes and is already wired in the correct order. You only need to select a model, enter prompts, and click Queue Prompt.

Load the default workflow

1. Start ComfyUI and open the UI in the browser (http://127.0.0.1:8188).

2. Find the Load Default button on the right side or top of the UI. After clicking it, the graph should show Load Checkpoint, two CLIP Text Encode nodes, KSampler, VAE Decode, and Save Image.

3. Check that all nodes are visible. If a node is red or a connection is missing, the workflow may not have loaded completely. Click Load Default again, or inspect the node connections manually.

Node connection order

The default workflow is wired like this:

• Load Checkpoint: Outputs MODEL, CLIP, and VAE. MODEL goes to the model input of KSampler. CLIP goes to the clip input of both CLIP Text Encode nodes. VAE goes to the vae input of VAE Decode. Some workflows also connect VAE to KSampler.

• CLIP Text Encode (positive): Receives CLIP and outputs CONDITIONING. It connects to the positive input of KSampler.

• CLIP Text Encode (negative): Receives CLIP and outputs CONDITIONING. It connects to the negative input of KSampler.

• KSampler: Receives MODEL, positive CONDITIONING, negative CONDITIONING, and optional VAE. It outputs LATENT to the latent input of VAE Decode.

• VAE Decode: Receives VAE and LATENT, outputs IMAGE, and connects to the images input of Save Image.

• Save Image: Receives IMAGE, saves it to the output directory, and shows a preview in the UI.

This is the core text-to-image pipeline: load the model -> encode prompts -> sample in latent space -> decode the image -> save the output.

Confirm workflow integrity

After loading the default workflow, check three things first:

1. Model selection in Load Checkpoint: The dropdown should list the model you placed in the checkpoints folder. If it shows null or is empty, the model is not in the right folder or ComfyUI has not refreshed.

2. All connections are complete: Every required input and output should have a wire. If an input port is empty, the node may not execute.

3. No red node errors: Red means a node has a configuration problem. Click the node and check whether any input or parameter is missing.

If all three look normal, move on to the first text-to-image run.

First text-to-image run

The first generated image is only a pipeline check. Do not chase image quality yet. The goal is to prove that the full workflow can finish.

Executable step list

1. Choose a model: In the Load Checkpoint node, open the dropdown and choose the model you placed in checkpoints. If it is an SD 1.5 model, usually with v1-5 or sd1.5 in the filename, test with the default settings first. If it is an SDXL model, VRAM requirements are higher and the first run may hit CUDA out of memory.

2. Enter the positive prompt: In the positive CLIP Text Encode node, usually labeled Prompt, enter an English description. Example: a cat sitting on a windowsill, soft light, simple background. Prompt length is flexible, but for the first test, keep it around 10-20 words so the result is easy to inspect.

3. Enter the negative prompt: In the negative CLIP Text Encode node, enter what you do not want in the image. Example: blurry, low quality, watermark, text. The negative prompt helps suppress common defects.

4. Set KSampler parameters: Click the KSampler node and check these settings:

   • seed: Random seed. It controls randomness. For the first run, keep the default value or enter any number.
   • steps: Sampling steps. The default is usually 20. Keep 20 for the first test; raising it is not necessary.
   • sampler_name: Sampler name, such as euler or ddim. Keep the default for now.
   • cfg: Prompt guidance strength. The default is often 7-8. Keep it unchanged for the first run.
   • denoise: Denoising strength. The default is 1.0. Keep it unchanged for the first run.

   These parameters deserve a separate explanation later in the series. For the first image, defaults are enough.

5. Click Queue Prompt: Use the Queue Prompt button on the right side or top of the UI. After clicking, the graph starts running. You should see green progress around nodes, and the overall progress appears on the right.

6. Wait for generation to finish: Generation time depends on model size, VRAM, and steps. An SD 1.5 model on a mid-range GPU with 8-12GB VRAM often takes 5-15 seconds. SDXL takes longer. If progress stops at one node, it may be CUDA out of memory or another error. Use the troubleshooting checklist below.

7. Check the output image: After generation, the Save Image node shows a preview. You can right-click the image to open it in a new window or save it. By default, generated images are saved in the output directory, next to the models directory.

Common first-generation results

The first output may not look good. That is normal. Common cases include:

• Low resolution: The default workflow resolution is controlled by the latent_image parameter for KSampler, and it may be 512x512. If you use an SDXL model, that resolution may be too low and the image can look blurry. This is usually fixed by adjusting empty_latent_image in KSampler or using an SDXL-specific workflow.

• Washed-out or gray colors: Some models need a matching VAE to decode colors correctly. If the output looks gray or overexposed, the VAE may not match. This belongs in the advanced section.

• Prompt has little effect: The first prompt may be too generic. Add concrete details, such as a fluffy orange cat sitting on a wooden windowsill.

Handling insufficient VRAM

If generation fails with CUDA out of memory, try these actions:

• Restart ComfyUI with the --lowvram flag. In Manual and Portable, add it to the startup command or script.
• Lower the sampling steps. For example, change KSampler steps from 20 to 15.
• Use a model with lower VRAM requirements. SD 1.5 usually needs less VRAM than SDXL.

VRAM demand depends heavily on the model and configuration, so this guide does not promise universal numbers. If your GPU has less than 4GB VRAM, try Cloud or CPU mode first.

What to do when image generation fails

The first run often fails. Here are the most common failure types and how to check them.

1. Load Checkpoint shows null or the dropdown is empty

Symptom: The Load Checkpoint dropdown is empty or shows null. After Queue Prompt, the node turns red and reports that the model cannot be found.

Troubleshooting steps:

• Check the model file location: confirm that the model is in checkpoints. For Desktop, use Help -> Open models folder to confirm the path.
• Check the model file format: confirm that the file ends in .safetensors or .ckpt.
• Refresh the model list: click the Refresh button in the sidebar if available, or restart ComfyUI.
• Check the startup log: the command prompt lists detected model files. If your model is missing from the log, the path is wrong.

2. CUDA out of memory

Symptom: Generation stops, and the command prompt or UI reports CUDA out of memory.

Troubleshooting steps:

• Restart with the --lowvram flag.
• Lower KSampler steps from 20 to 10-15.
• Use a model with lower VRAM requirements. SD 1.5 usually needs less VRAM than SDXL.
• Check whether another program is using VRAM, such as a browser with many tabs or another AI app running in the background.

VRAM demand varies by model and configuration. SD 1.5 often runs on mid-range 8-12GB GPUs. SDXL usually needs more.

3. Model format error or version incompatibility

Symptom: Load Checkpoint turns red, and the error mentions safetensors header or version mismatch.

Troubleshooting steps:

• Confirm that the model file is complete. Downloads can be interrupted and leave a corrupted file. Download it again.
• Confirm that the model version matches your ComfyUI version. Some newer models, such as SDXL models, require a newer ComfyUI build. An old Portable release may not support them.
• Check the model source. Prefer official or trusted sites. Some third-party models may use nonstandard formats.

4. Missing dependencies or Python environment issues

Symptom: The command prompt shows ImportError or ModuleNotFoundError during startup. After Queue Prompt, a node turns red and reports that a module cannot be found.

Troubleshooting steps:

• If you installed manually, confirm that pip install -r requirements.txt finished successfully.
• Check whether PyTorch has CUDA support: run python -c "import torch; print(torch.cuda.is_available())" in the Python environment. If it returns False, PyTorch does not have CUDA enabled.
• Reinstall dependencies. For Manual, rebuild the virtual environment. For Portable, extract a fresh copy.

Desktop and Portable include complete dependencies in normal cases. Manual installations are more likely to hit missing packages.

5. A node is red, but the error is unclear

Symptom: A node is red, but clicking it does not show a clear error.

Troubleshooting steps:

• Check node inputs: make sure every required input port is connected and the wire colors match.
• Check node parameters: click the node and inspect every parameter. For example, KSampler seed should not be empty.
• Delete and re-add the node: right-click the node -> Remove, then right-click a blank area -> Add Node -> search for the same node.
• Reload the workflow: click Clear, then click Load Default again.

6. Startup failed: the port is occupied or the service did not start

Symptom: The browser cannot connect to http://127.0.0.1:8188, or the command prompt reports Address already in use.

Troubleshooting steps:

• Check whether the command prompt window is still running. If the window is closed, the service has stopped.
• Check port usage. Another program may already be using port 8188. Start ComfyUI with --port 8189 to use a different port.
• Check the firewall. Some firewall tools block local services.

For errors outside this list, read the command prompt log first. Then search the exact error message in GitHub Issues or Discord.

What to learn next

After your first text-to-image run, you have verified the basics: ComfyUI starts, the model loads, and the default workflow runs. From here, there are three practical directions.

Official docs and node extensions

The ComfyUI official docs (docs.comfy.org) cover installation, core concepts, model management, and node lists. If you need to understand a node parameter or find the official way to use a feature, start there.

ComfyUI-Manager is the main tool for community node extensions. Desktop and Portable usually include it. Manual users need to install it separately. Manager can search and install new nodes, update installed nodes, import community workflows, and check node version compatibility.

If you want to try ControlNet, LoRA, AnimateDiff, or other advanced features, Manager is the usual entry point for installing the required nodes. Learn the default workflow first, then add nodes gradually.

Advanced workflow directions

Once the default text-to-image workflow is familiar, try these directions:

• Workflow reuse and management: Learn how to import workflow JSON shared by others, modify parameters, and save common setups. This maps to the later series article “ComfyUI Workflow Reuse Guide”.

• Fine control with ControlNet: Use ControlNet nodes to control pose, edges, depth, and color. This is useful when composition matters. This maps to the later series article “Complete ComfyUI ControlNet Guide”.

• LoRA model practice: Use LoRA to add a style or character trait on top of a base model. This is useful for a specific visual style or recurring character. This maps to the later series article “ComfyUI LoRA Model Practical Guide”.

All three directions need extra nodes and models. Try them gradually; installing too many nodes at once makes troubleshooting harder.

Model sources and recommendations

Your first test model may be a general SD 1.5 or SDXL base model. If you want more styles, these sources are common:

• Civitai: One of the largest Stable Diffusion model communities outside China. It includes base models, LoRA, VAE, ControlNet models, and more. Check the model version (SD 1.5 / SDXL) and training-data notes when searching.

• LiblibAI: A Chinese Stable Diffusion model platform with faster access from China and many models and LoRA files shared by local creators.

• Hugging Face: A model repository that includes base models released by Stability AI and many open-source models.

When downloading a model, check three things: whether the model version is compatible with your ComfyUI version, whether the intended use matches your workflow (text-to-image / image-to-image / ControlNet), and whether a .safetensors file is available.

Other articles in this series

This article is the beginner page for the “ComfyUI and Stable Diffusion Practical Guide” series. Later articles cover workflow management, ControlNet, LoRA, model recommendations, performance optimization, and more. If you already work with local model deployment, these related articles may help:

• If you want to deploy local LLMs, read Ollama Local LLM Beginner Guide.

• If you want to improve prompt writing, read Prompt Engineering for Commercial Use.

• If you want to tune local GPU usage, read Ollama GPU Acceleration Setup.

• If you want to connect ComfyUI to automation workflows, read AI Workflow Automation with n8n and Agents.