ComfyUI Course - Learn ComfyUI From Scratch | Full 5 Hour Course (Ep01)

Learning Comfy UI is like opening a

technical book at the last page.

Everything is there, but nothing makes

sense yet. This course starts from page

one. Before we go any further, I want to

be very clear about how this course

works. This is not a shortcuts course.

It is not about copying workflows

without understanding them. Each chapter

builds on the previous one. We start

simple, repeat the important ideas and

only add complexity when it actually

makes sense. You do not need any coding

knowledge. You do not need to be

technical. If you can think visually,

you can learn Comfy UI. If you want to

understand how AI image generation

really works locally and how to use

Comfy UI without feeling lost, this

course is for you. My name is Pixaroma

and on this channel I focus on creating

and teaching comfy UI workflows in a

simple and practical way. I am a graphic

designer not a programmer and that is

actually a good thing. Developers are

great at writing code but they often

explain things in a very technical way.

This course is designed from a visual

thinker's perspective. My goal is to

explain Comfy UI logically and visually

without needing any coding knowledge.

Even if comfy UI looks confusing right

now, that is completely normal. We will

start from the absolute basics and build

up step by step. But before we talk

about Comfy UI itself, we first need to

understand what AI image generation

actually is. Today, AI is not just one

thing. There are many different AI

models that can run locally on your own

computer, such as stable diffusion,

Flux, Quen, and many others. It is also

important to understand that Comfy UI is

not limited to image generation. Comfy

UI is a general interface for running

many different types of AI models

locally. While it is most popular for

image generation, it can also be used

for audio, music, video, animation, 3D,

and more. As long as a model can be

connected through nodes, Comfy UI can be

used as the interface to control it.

These models by themselves are like an

engine. They are very powerful, but you

cannot really use them directly. To work

with them, we need an interface. An

interface is what allows us to send

prompts, images, and settings to the

model and then receive results back.

There are many free interfaces that let

us interact with these models. Some

popular ones are Forge UI, Swarm UI,

Invoke, Focus, and of course, Comfy UI.

They often use similar models but they

work in very different ways. In this

course, we are going to focus on Comfy

UI. Comfy UI is different because it is

node-based. Instead of hiding everything

behind buttons and menus, it shows you

exactly what is happening step by step.

You can see how prompts, models,

samplers, and images are connected

together like building a system. Think

of it like this. The AI model is the

brain. The interface is how you talk to

that brain. Comfy UI is like building

your own control panel exactly the way

you want. Do not worry if this still

feels complex. Understanding comes from

seeing things connect, not from

memorizing nodes. In this course, I will

explain what each node does, why it

exists, and how everything connects

together. Before we install anything, we

need to talk about how you will actually

run Comfy UI. There is more than one way

to use Comfy UI and the right choice

depends on your system and your

expectations. Let's go to the official

Comfy UI website to see the available

options. The official website is

Comfy.org.

If we go to the products section, you

can see that there are two main options,

Comfy UI Cloud and Local Comfy UI. Comfy

UI Cloud runs online on their servers

and it is a paid service. This option

can be useful if your computer is too

old or not powerful enough to run AI

models locally. Local Comfy UI is free

and runs directly on your own computer,

assuming you have a reasonably capable

system. This is the option we will focus

on in this course. So, let's click on

local comfy UI. Here you can see three

main installation options. Download for

Windows, for Mac OS, and install from

GitHub. All of these options install

Comfy UI, but there are important

differences between them. In this

course, I will focus on Windows

operating system using the portable

version of Comfy UI. All the workflows,

tools, and installers I show are tested

on Windows using an Nvidia graphics

card. On AMD graphics cards and on Mac

OS, performance is usually slower, and

some features or custom nodes may not

work exactly the same way. So, if you

are using Windows with an Nvidia card,

it will be much easier to follow this

course step by step as I show it.

Because there are many different AI

models, hardware requirements can vary a

lot. Some models are small and can run

on a graphics card with 6 to 8 GB of

VRAM. Other models are much larger and

may require more than 24 GB of VRAM. For

this first episode, I tested the

workflows on two different systems. One

system uses an RTX 2060 with 6 GB of

VRAM and 64 GB of system RAM. The second

system uses an RTX 4090 with 24 GB of

VRAM and 128 GB of system RAM. For the

workflows in this episode, a graphics

card with 6 to 8 GB of VRAM should be

enough to follow along. In later

episode, we will explore newer and

larger models that may require more

powerful hardware. Now, let's talk about

which version of Comfy UI you should

install. As I mentioned earlier, I am

using the portable version of Comfy UI.

If we click on install from GitHub, we

are taken to the official Comfy UI

GitHub page. Here you can find detailed

installation instructions, but they

require more manual steps and setup.

Over the past year, I have been using a

portable version of Comfy UI that

includes additional tools to make the

installation process much easier. This

installer installs the original Comfy

UI, but it also adds helpful tools so

you can get up and running much faster.

This installer is called Comfy UI Easy

Install. You can find it on this GitHub

page. You can find the creator on our

Discord community under username IVO.

Thank Ivo for this installer. This

entire course is built around this

version of Comfy UI. You can still use

Comfy UI Desktop or Comfy UI Cloud, but

some things may look different or behave

differently compared to what you see in

this course. If you want the exact same

setup that I use and the easiest way to

follow along, I recommend using the same

version. Let me show you how to install

Comfy UI. So, we are on the easy install

GitHub page. This is the complete link.

If we scroll down, you can read more

about this installer. Even if you might

not understand what each of these things

means yet, it will make sense later as

you learn more about it. I will talk

later about the Pixaroma Discord server

where you can get more help and answers

to your questions. So, this installer

will install Git, which is a tool that

tracks changes to files in Comfy UI. It

helps developers safely update the main

app and custom nodes, fix bugs without

breaking everything, and lets you update

or roll back to an earlier working

version if a new update causes problems.

Then it will install the Comfy UI

portable version. A portable version

means the program is fully

self-contained in one folder, does not

need a normal system install, and can be

run, moved, backed up, or deleted

without affecting the rest of your

computer. in Comfy UI portable. This

means Python, libraries, models, and

settings all live inside the Comfy UI

folder. So, you can copy it to another

driver or PC, update it safely, and

avoid breaking your system Python or

Windows setup. Python embedded means

Comfy UI comes with its own built-in

copy of Python already included inside

the Comfy UI folder instead of using the

Python installed on your system. Then it

will install all the nodes that are

useful and that I tested over the last

year. It might not make sense for you

yet if you are a beginner, but do not

worry. Take it as general knowledge for

now and it will make sense later. Then

it will add an add-ons folder with more

advanced stuff we can use later to speed

up our generation, plus some extra tools

that can be useful and then more

technical stuff explained for each one.

But all you need to know for now is

where to download it from and how to run

the installer. It is important not to

run it as administrator. That means you

just doubleclick to run it, not

right-click and run as administrator,

but you will see that in a minute. Also,

avoid system folders and make sure your

NVIDIA drivers are up to date since some

things work only with more recent NVIDIA

drivers. Okay, let us go back to where

it says Windows installation and let us

download the latest release from here.

Then depending on how your browser is

configured, it will either download it

to the downloads folder or ask you where

to download it and you can decide where

to put it. As you will see over time, it

needs a lot of space if you download big

models. So I suggest downloading and

installing your Comfy UI on a hard disk

that has a lot of free space and

preferably on a solid state drive

because it will load the models faster.

I will go to my D drive and I will

create a new folder called Comfy UI, but

this does not really matter. The name

can be anything easy to remember.

Sometimes I put Comfy UI followed by the

month so I know when I downloaded and

installed it. So I will save this zip

archive in that Comfy UI folder.

Now let us go to the place where we

saved the file. Since this is a zip

archive, we need to unzip it. You

rightclick on it and depending on what

you prefer, you can use the Windows

integrated option and select extract

all. I like to delete the folder name at

the end so I do not end up with a folder

inside another folder. When I click

extract, it will extract these two

files. Let me delete it really quick and

show you. If you have WinRAR like me,

you just choose extract here and it does

the same thing. Once we extracted

everything, you can delete the easy

install zip file. Now we are left with

two files. A BAT file that is the

installer and a zip file that contains

extra resources that it will use. When

you run it, you might get a security

warning. That usually happens with BAT

or executable files because they install

files on your system. This one is safe.

I installed and tested it and I

personally know EVO, the creator of this

installer. You can rightclick and scan

it with your antivirus and you will see

it is clean. So let us double click on

the BAT file then press run and it will

start installing. If you already have

git installed it will update it. If not

you will get a window like this and you

have to press yes to continue the

installation. After that it will

continue the installation of Comfy UI

and everything it needs to run. You can

take a break for 3 to 5 minutes

depending on your internet speed and

your computer. So how do you know when

it is ready? You will see a message that

says installation complete along with

the time it took. On my PC, it took 247

seconds. After that, you can press any

key to exit. So, let us recap really

quick. From the GitHub page, you

download the zip archive of the easy

installer. You create a folder named

Comfy UI and place the downloaded zip

archive in that folder. You extract the

contents of the archive. You run the

Comfy UI easy install BAT file and if it

asks to run GitHub you press yes. In a

few minutes the installation is complete

and you get this screen. Now after the

installation we can see that inside our

Comfy UI folder a new folder appeared

called Comfy UI easy install. This is

portable which means you can copy this

entire folder and move it to a different

drive or folder and it will still run

Comfy UI. Basically, after you install

any Comfy UI portable version, you

should end up with a similar folder

structure to this. Since Comfy UI is

based on the Python programming

language, you will see many Python files

and BAT files inside these folders,

which are used to run those Python

files. The easy installer will also

create some shortcuts on your desktop.

If you use other versions of Comfy UI,

they might not do this, and you would

need to create the shortcuts manually.

That is one of the reasons I prefer the

easy installer. It makes everything

easier for us. Basically, we just

extracted an archive and ran a BAT file

and we now have Comfy UI. If we right

click on this shortcut and go to

properties, we can see the target of the

shortcut. If we open the file location,

you can see that it is connected to this

BAT file that starts Comfy UI. In other

versions of Comfy UI, the name might be

different like run NVIDIA GPU or

something similar. Are you ready for

your first Comfy UI launch? To start

Comfy UI, you either use this BAT file

called Start Comy UI or from the desktop

you use this shortcut called Comfy UI

easy installer. E and Z stand for easy

and I stands for installer. So double

click on it and when it starts it looks

like this. The first time it will be a

little slower, but after that it will

start much faster. If you are curious by

nature, you can find all kinds of

information about your Comfy UI and your

system when it runs. For example, you

can see what operating system I am

using, what Python version is running,

and where that Python is located, what

the path to the Comfy UI folder is,

where the user directory is, how much

VRAM you have, how much system RAM you

have, and the PyTorch and CUDA versions

that are running. When it starts, this

command window will be minimized to your

taskbar, and Comfy UI will open in your

default browser. The first time it

opens, it will show you some templates

made by Comfy UI that you can load. If

you have run a workflow before, it will

open that workflow by default. So the

workflow you see open is the last one

you used. A workflow is a set of

connected nodes that tells Comfy UI what

to do step by step. Let us close this

for now. You can open these templates or

workflows from here later. Comfy UI is

made of a few main areas. You do not

need to memorize them. I am naming them

so we can talk about the same things

later. If we go to the top, you can see

it says unsaved workflow. Basically, it

is like a document that is empty at the

moment since we did not add any nodes

yet. You can have multiple documents

open similar to what we have in

Photoshop and other programs. We can

click on this plus icon to create a new

blank workflow. All these tabs on top

are open workflows and we can close,

save and edit each one. Now this grid

like empty space is called the canvas.

Instead of drawing on it, we will

arrange blocks or nodes like using Lego

pieces and connect things together to

create a working workflow. You can use

your mouse wheel to zoom in and out on

the canvas. Then we have this top bar.

Depending on what extensions you have

installed, it might look different and

have more options. Things like the

manager or the run button, which lets us

run workflows, are usually here. On the

bottom right, we have view controls. For

example, we have a select tool that lets

us select nodes and a hand tool that

lets us navigate the canvas. You can fit

a workflow in view, but right now the

canvas is empty. We also have different

zoom controls that you can use if you do

not want to use the mouse wheel or if

you do not have one. For me, the mouse

wheel is the fastest and the one I

prefer. Then we have the show mini map

option. This shows a small map that we

can use to navigate when we have very

large workflows. There is also hide

links, but since we do not have any

nodes or links yet, we will see that

later. An important one is the main menu

which you open by clicking on the letter

C, the Comfy UI logo. We also have more

options on the left sidebar for nodes,

models, and workflows, which we will

explore soon. Back to the main menu. If

we click on the C, we get this menu. New

creates a new workflow, but it is faster

to use the plus sign from the top bar.

For file, it allows us to open, save,

and export the workflows we create. For

edit, you can undo actions like moving

nodes or changing something in the

workflow, clear the workflow and unload

models. For view, we can enable and

disable different panels. And we also

have zoom in and zoom out controls. Just

like in Photoshop, we can do the same

things in multiple ways. It is the same

with comfy UI. For theme, you can change

how it looks, but at the beginning, I

suggest leaving it on default so it is

easier to follow tutorials. Nodes 2 is

in beta at the moment of this recording

and still has some bugs, so I suggest

leaving it off until it is more stable.

You can browse templates and open

settings, which we can explore later.

For now, the default settings work fine.

Templates and settings can also be

accessed from here. So again, there are

multiple ways to access the same things.

In some newer versions, some people

might use a newer manager and it might

appear somewhere else instead of here.

For now, I am using the old manager

which appears here. Under help, you can

also find help options, but you will see

later in this video how to ask questions

and get help. We also have a console

sometimes called the bottom panel where

you can see exactly what has happened

since we opened comfy UI. If we look at

the taskbar and open the command window

from there, it shows the same

information. One view is at the bottom

and the other is in the taskbar. To

close Comfy UI, I recommend opening the

command window from the taskbar and

closing it. You will then see a

reconnecting message in the browser

because it cannot find Comfy UI running

anymore. After that, you can close the

browser window. You can also close the

browser window first and then close the

command window. It is time to test our

first ready-made workflow. Later, I will

explain in detail what nodes are and

what they do. So let us start Comfy UI,

wait for it to finish loading and get

the interface. To open a workflow, you

have different options. You can drag a

workflow directly onto the canvas, or

you can go to the menu, then file, and

choose open. All workflows for Comfy UI

have the extension.json.

JSON means JavaScript object notation.

It is a simple text format used to store

and share data in a way that both humans

and computers can easily read. In Comfy

UI, JSON is important because workflows

are saved asJSON files. These files

store all your nodes, connections,

settings, and prompts so you can reload,

share, or edit a workflow later. I will

include these workflows for free on

Discord for those who use a different

Comfy UI version. For example, I can

open this first workflow and you can see

that it opens with all the nodes and

links ready to be used. You can use your

mouse wheel to zoom in and out to see

the entire workflow. You can click

outside the nodes somewhere on the

canvas and drag to move around. You can

also use this hand tool, which I

personally never use. With the hand

tool, you can pan around the canvas.

With the normal mouse cursor, you can

select nodes and move them around. We

will talk more about that later. Now we

have the workflow open in this tab and

you can see its name at the top. With

the X button, you can close the workflow

and go back to a new empty one. If we go

to the sidebar and click on workflows, I

can open this folder called getting

started which I prepared for you for

this episode. Only the easy installer

comes with these workflows. So, if you

are using a different version, you can

get the workflows from Discord. You can

also make the sidebar wider if you want

to see the full text. I added a few

workflows here to test in this episode.

This one is just a help file with notes

and useful information that we will use

later in the video. Let us close it and

open the one with number one in front

called Juggernaut Reborn. If I click on

workflows again, the sidebar collapses.

Now let us move around using the mouse.

Left click and drag to see it better.

Each of these blocks is called a node.

All nodes are connected to each other

using links. Those small cables that go

from one node to another. Usually a

workflow is built from left to right.

When you run a workflow, it processes

from left to right. If something does

not work or the workflow is broken,

Comfy UI tells you where the problem is.

Think of it like a car dashboard. If a

door is open or a light bulb is not

working, you get a warning icon. It is

the same here. Errors look like this. It

says prompt execution failed and it also

tells you something like value not in

the list. These are some of the simplest

errors to fix. It is like the car

telling you a light bulb is missing. In

Comfy UI, it means a specific value,

object, or file could not be found. In

our case, it could not find the

checkpoint name, which is the model

name, the brain as we called it. Comfy

UI workflows include all the nodes and

settings, basically the interface, but

they do not include the models

themselves. Those brain or engine files

are not included. Since workflows are

just JSON text files, they cannot

include images or large files like

models. In this node called load

checkpoint, the checkpoint is just a

model file. The brain we talked about.

Even if I click here, I cannot select

anything because it is not in the list.

That means the model is not downloaded

yet or it is downloaded but placed in

the wrong folder. Since I did not

download any models yet, it is clear I

do not have it. That is why when I share

a workflow with you, I include a note

that tells you exactly what you need to

download for the workflow to work. Not

everyone on the internet does this, but

most good workflow creators do. The way

I organize it is like this. I tell you

where the model needs to be downloaded

and which node loads it. It says load

checkpoint, which is the node name. Then

it tells you the model name you need to

download. There is a button that says

here and then it tells you exactly which

folder to place it in and which folder

to create if it does not exist. That is

enough theory. Let us download the

model. You already saw where it needs to

be placed, but how do you find that

folder? You need to find your Comfy UI

folder. This depends on where you

installed it, on which drive, and in

which folder. You navigate until you

find the Comfy UI folder. In our case,

it is inside the Comfy UI easy install

folder. If we go inside, we see many

folders that Comfy UI needs to run. We

have an output folder where generated

images are saved. We have an input

folder where input images are stored. We

also have a models folder where all

downloaded models go. Inside the models

folder, you can see many subfolders for

different types of models. Over time,

you will learn what each one is for.

That is why I included the note so you

know exactly where to put the model

without guessing. For this workflow, the

model goes into the checkpoints folder.

We could just save it directly there and

it would work. But from my previous

tutorials, I learned that over time, you

will download many models and it becomes

hard to keep track of them. That is why

I like to organize models in subfolders.

In this case, I know this model is based

on stable diffusion 1.5. So, I will

create an SD15 folder and place the

model inside it. Now, we wait for the

model to download. Some models are a few

gigabytes in size. After that, we go

back to Comfy UI. You can see I placed

the model exactly where the instructions

said, so Comfy UI can recognize it. If

Comfy UI was closed, reopening it would

automatically detect the model. But

since Comfy UI is already open, it will

not see the new model yet. We need to

refresh it. To do that, press the R key.

You will see that the node definitions

update. Now, when I click here, I can

see the model name and select it. Right

now, there is only one model, but later

you will have a drop-own list with many

options. Now, the model is selected and

it is time to run the workflow again. By

the way, you can move the run button

anywhere you want on the canvas using

the small dots on its side. If you

prefer it docked, you can dock it back

to the top bar. Let us run it again and

see if it works. Everything turns green.

Each node runs from left to right and no

red nodes appear. That means the

workflow ran successfully and we

generated our first image. The model we

use in this chapter is quite old and

small. Later we will use smarter and

more advanced models. For practice, this

one is good enough because it is fast

and can run on smaller computers that do

not have a lot of VRAM. Each time I

press run, I get a new image because we

have a random seed here. Do not worry

about this yet. I will explain it later.

So now we can generate an image with

comfy UI and all of this comes from a

simple text called a prompt. Basically

we used a few nodes with specific

settings and a model trained for this

type of image generation. We can change

the prompt for example photo of a cat

closeup. Now when I run the workflow I

should get a cat. The more VRAM you have

the faster it will generate. We can see

the generated images here, but they are

also saved locally. If we look at the

output folder, we have a shortcut to it

on the desktop. Inside that folder, we

can see all the images we generated so

far. Let us go back to Comfy UI and

close this workflow. I do not want to

save it because I liked the prompts and

settings it had before. So, I choose no.

Now, we are left with an empty workflow.

or you can click on the plus sign to

create a new blank workflow. Before we

move to the next chapter, I recommend

taking a short break. Research shows

that short pauses help your brain

process and retain new information. Grab

a coffee, get some water, or take a

quick bathroom break, then come back and

continue. This chapter is about

understanding the building blocks of

Comfy UI and how they connect to form a

workflow. We are in Comfy UI and we have

this blank canvas and workflow. To add a

node, you doubleclick on the canvas and

it will open a search box that lets you

search for a node. For example, if I

type the word load, it shows me load

image, load checkpoint and all kinds of

nodes that let us load something. If we

click on the load image node, it will be

added to the workflow. The position

where it is added depends on where you

doubleclick on the canvas. You can also

move it after. You just leftclick on a

node, hold the left mouse button, drag

it to where you want it, and then

release the button. To deselect a node,

you just click anywhere on the empty

canvas. For me, that is the fastest way

to add a node. But there are other

methods. For example, I can write click

on the canvas in an empty area and get

this menu. From here, I can go to add

node. Then I see different categories.

If I click on the image category, I can

find the load image node. It is right

here. And if I click on it, it gets

added to the canvas. After that, you can

move it and arrange it wherever you

want. Another method is to use the node

library in the left sidebar. Here we

have all these categories. If I click on

the image category, I can see the load

image node. This is a good option if you

do not know exactly which node you are

looking for. You can also search for a

node here to filter the list, then add

the node or drag it onto the canvas. Out

of all these methods, my favorite is

still the double click on the canvas.

Once a node is selected, you also have

the option to delete it using this icon.

You can also use the delete key or the

backspace key to delete a node after you

select it. The load image node is how we

bring an existing image into Comfy UI so

other nodes can work with it. Each node

has a title at the top that tells you

what it does. Below that, it has

controls, inputs, and outputs that

connect it to the rest of the workflow.

Let us double click on the canvas again

and add another node. This time, I will

search for crop. And we get this node

called image crop. You can probably

guess what it does. It crops the image

that we loaded. You can change the image

using this button and upload any image

you want. If something goes into a node,

it is called an input. If something

comes out of a node, it is called an

output. The load image node has two

outputs but no inputs because the image

comes directly from your computer, not

from another node. The image crop node

has one image input and one image

output. It receives an image, modifies

it, and then sends out a new image. If

we leftclick on one of the outputs from

the load image node, we can drag a

connection or a cable to the next node

and connect it. Because the output and

the input have the same color and the

same name, it is easy to see that they

belong together. In most cases,

connections work between the same colors

and different colors usually do not

connect. There are a few special cases,

but we will talk about those later. Now,

if I try to connect the green output, it

does not connect. That is because the

green output is a mask and the input on

this node expects an image which is

blue. In the beginning, this color

system helps you quickly understand

which nodes can be connected. If two

nodes cannot connect, it usually means

they are not meant to be connected.

Sometimes you will also find nodes that

act like adapters or converters. These

nodes take one type of output and

convert it into a different type so it

can be used by another node. Now

basically we have a workflow but is the

workflow complete? How can we test it?

It is simple. We run it and see what

message we get. In this case it says the

prompt has no output. Even if you do not

understand exactly what that means yet

try to figure it out from the words. We

do not have an output node. So let us

close this message. If we look at the

workflow, the image is loaded from the

computer. Then it goes into the image

crop node which crops the image. But

after that nothing happens. There is no

output. Think of this like editing a

photo in Photoshop. You load an image,

crop it, but if you never save or export

it, the work exists, but you do not get

a file. In Comfy UI, the save image node

is the export step. So let us

doubleclick on the canvas again and

search for save. We have this save image

node. We can see that the image output

color matches. So we can connect it.

Even if the label says image or images,

it still works. Now let us make the

connection. If we run the workflow, it

will process from left to right. The

image is loaded, cropped, and then saved

in the output folder. We can also see it

directly inside the save image node. All

nodes can be resized using the corners.

You will see small arrow indicators on

the corners. You can click and drag to

resize a node. In this case, I want to

see the image preview bigger, so I

resize the node. To remove a connection,

you can leftclick on the output dot,

drag the cable out onto the canvas, and

it will disconnect. You can also

leftclick on the small dot in the middle

of the connection and choose delete. You

also have the option to add a reroute. A

reroute is like an extension cable or a

cable organizer. It does not change the

data at all. It only helps you route

connections more cleanly and keep your

workflow readable. From that reroute

node, you can add another link to

another node if you want. You can also

have multiple reroutes on the same link,

so you can arrange nodes, links, and

reroutes in a way that looks visually

clean or helps you see faster which node

connects to which node. This is very

helpful when you have a lot of nodes in

a workflow. To remove a reroute, you

just select it and press the delete key.

Let me arrange them and remove all links

so we can see it better. So in Comfy UI,

we have different types of nodes. First,

we have nodes that only have outputs.

These nodes usually load something from

outside Comfy UI like a file or some

text. In this case, the load image node

loads an image from your computer. So it

does not need any inputs, only outputs.

Then we have nodes that have both inputs

and outputs. These nodes are usually

placed in the middle of a workflow. They

receive something from one node, process

it, and then pass the result to the next

node. Finally, we have nodes that

usually sit at the end of a workflow.

These nodes only have inputs, and their

job is to show or save the result, for

example, by previewing an image or

saving it to disk. There are also nodes

that do not have any inputs or outputs

at all. For example, if I search for a

note node and add it to the canvas, you

can see that it is onlyformational.

These nodes are used to write notes and

make workflows easier to understand and

remember. They do not affect the

workflow at all and are just for

organization and clarity. On the top

left side of a node, next to the title,

you have a small gray dot. If you click

it, the node collapses, similar to

minimizing it. I often do this for nodes

where I already know the settings and do

not need to change them. Collapsing

nodes helps save space and makes the

workflow easier to read. If you right

click on a node, you get a menu called

the node context menu. This menu shows

options related to that specific node.

Each node has a slightly different menu

depending on what that node does. In

this case, we have options like opening,

saving, and copying the image, different

properties, resize, and colors. We can

also collapse the node from here instead

of using the gray dot. And there are

many more options. Try a few of them. If

you do not like what you did, you can

undo it with controll + z. You can also

change the title of a node. If you

double click on the node title, you can

rename it to anything you want. This

does not change how the node works at

all. It is only for your own

organization and to make the workflow

easier to understand. You can also

rightclick on a node and choose title to

rename it. This is another way to change

the node name. We already know that we

can move a node around once it is

selected. But when a node is selected,

you will also see a small floating bar

at the top. From here, you can delete

the node using this icon. You can also

click on this dot to change the node

color. This lets you choose from

different colors, which is useful for

organizing your workflow or grouping

nodes by function. Changing the color

does not affect how the node works. By

default, there is no color, the gray

one. This small eye icon is the node

info. If you click it, a properties

panel opens on the right with more

information about the node. Here you can

see what the node is supposed to do and

what the values mean. From this icon,

you can also close the properties panel.

All nodes, especially the default comfy

UI nodes, should have some kind of info

unless it is a custom node and the

creator did not add any documentation.

You can drag this side panel and resize

it the way you like. Here you can see

all the information about the image crop

node and what each setting does. Let us

close it for now. If you hover over an

icon, you can see more information about

what it does. For example, because this

node works with images, it lets you open

it in the mask editor. If we click on

it, you can see that it opens in the

mask editor. This will be useful later

when we do inpainting and image editing,

but that is for another episode. For

now, it is enough to know that it is

here and you will learn more about it

over time. These numbers are just

settings that you can change in Comfy

UI. They are called parameters.

Parameters control how a node behaves

and how it processes its input. Let me

reconnect the nodes. So, we have a

working workflow again. Now, if I run

it, you can see what these parameters

actually do. We are cropping a 512x 512

pixel area from the original image

starting from the X and Y coordinates

set to zero. That means the crop starts

from the top left corner of the image.

So basically we are taking this small

corner from the original image. The

original image was 1,024x

14 pixels and now the result is 512x 512

pixels. Even if it looks bigger here in

the node preview, it is not actually

larger. That is just the preview size.

The real image resolution is smaller. So

let us change some parameters or

settings or however it is easier for you

to remember them. Values is also fine.

And run it again. Now we have a

different crop. Let me speed up the

video while I try different values so

you can see how the result changes.

Let us remove this middle node, the

image crop node. Once it is removed,

something interesting happens. Comfy UI

tries to keep the workflow connected and

automatically reconnects the nodes

directly. That happens because the

output of the first node and the input

of the last node use the same type. If

the first and last nodes had different

input and output types, the connection

would disappear when the middle node is

removed. Now let us doubleclick on the

canvas. You should remember by now that

every time you see this search bar, it

means I doubleclicked on the canvas. Let

us search for invert and select invert

image. This node has an image input and

an image output. But it does not have

any parameters. That is because this

node is designed to do one specific

thing. Invert the image. Even without

parameters, the node still performs a

function. Let us connect this node into

the workflow. Watch what happens when I

connect it to the input. You can see

that the previous connection is removed

automatically. That is because an input

can only have one connection at a time.

An output on the other hand can connect

to multiple nodes. You can think of it

like electricity. An output is like a

power strip. It can send power to many

devices. An input is like a wall socket.

It can only accept one plug at a time.

If we run the workflow now, we can see

that the result is an inverted image. So

until now with these small workflows, we

did not use any AI. We only used simple

nodes like simple code to modify images.

We will see more in the next chapter

when we build a bigger workflow that

uses stable diffusion to generate an

image from text. But these small steps

help you understand how things work. At

least I hope they do. You can always ask

any questions you have on Discord as we

will have a special section for this

episode on the Discord forum. So we

learned that save image is usually the

last node in a workflow since it does

not have any outputs. And because the

output is an image that goes to disk,

not to another node. But that does not

mean we cannot continue the workflow. It

only means we cannot continue from that

node. We can still continue from the

previous node which has the same image

just not saved to disk yet. Let us clone

this node and use it again. One simple

way is to press the alt key and drag a

copy of this node where you want it. Let

us delete it and try again. Now we will

use controll + c to copy. And when I use

controll +v it will paste that node

where the mouse cursor is. Let us delete

it again. And now let me show you

another shortcut. Press the control key

and make a marquee selection over the

nodes you want to select. Now we

selected two nodes. With Ctrl + C, we

copy all selected nodes. And with Ctrl

+V, we paste them. If you click and drag

from any of the selected nodes, you can

move them together. If you press delete

while both are selected, it will remove

both. If we use controll + shift +v, it

will paste the nodes together with the

links they had in the workflow. Now we

have this extra link here. So basically

from one image we got two invert image

nodes and both do the same thing invert

the image. If the invert image node had

more parameters we could change the

settings in one and get different

results. Let us delete those again.

Practice this a few times. Press control

and select the nodes. Presstrl + c to

copy and ctrl + v to paste. Move them

into position. Now look at what I am

doing. I am continuing the workflow from

the last invert image node and then I

save the result. A workflow can have

many branches like a tree. The root

starts with the image. Then it inverts

the image and from there on another

branch it inverts it again. Can you

guess what happens when I press run? The

image is inverted again and looks like

the normal image. The original image is

inverted. Then that inverted image is

inverted again and we get the original

result. We can continue the workflow

even more. From the image that was

inverted twice, we connect it to an

image crop node. Now, instead of double

clicking and searching for a node, we

can drag a connection and release it.

When we do that, a context menu appears

with suggested nodes. From here, I can

easily pick the save image node and it

is added already connected. Let us

delete it and try again. Drag the

connection and release it. Then select

search. When I select the save image

node, it is added already connected. Let

us place the nodes properly and run the

workflow. You can see how many

operations are now in this workflow.

With a single image, we can invert it,

invert it again, crop it, and save it.

This is similar to a small program or an

action in Photoshop, but with more

control and much more flexibility. There

are nodes for images, audio, 3D, and

many other things. This is where you

start to see the power of comfy UI. Now

let us select everything. Hold controll

and drag to select all nodes. You can

press delete to remove everything or let

us cancel that and do it another way. Go

to the menu then edit and choose clear

workflow. It will ask if you want to

clear it. Click okay. And now we have a

blank workflow again. Do you like math?

I know you do not like it, but I just

want to show something quick to see the

different things it can do and help you

understand Comfy UI better. Double click

on the canvas and search for math. You

will see a few math nodes. If we look on

the right, you can see different names

like Comfy UI core, KJ nodes, easy use.

These names are the names of custom

nodes or extensions. By default, Comfy

UI comes only with the nodes you see

under Comfy UI core. With the easy

installer, you also get a few extra

custom nodes already installed. We will

talk more about custom nodes later when

we get to the manager. If you use the

easy installer like I showed at the

beginning of this video and install the

same version, you should have the same

nodes. So again, Comfy UI core nodes are

made by the Comfy UI team. Let us get

back to the math nodes. We will start

with something simple called math int.

int comes from the word integer which

means whole numbers. This node works

only with whole numbers like 1 2 10 and

so on, not decimals. All custom nodes

have an extra label on the top right

that shows which custom node pack they

belong to. This makes them easy to spot

compared to built-in nodes. These math

nodes are used for simple calculations

similar to a calculator. I personally do

not use math nodes very often, but they

can be very useful for automation. For

example, you might load an image, read

its width or height, and then use math

nodes to calculate a new value based on

that size. This allows you to

automatically adjust things like

resolution without manually changing

numbers every time. In this case, we

have letter A, letter B, and an

operation. The default operation is add.

Let us set A to five. and B to three.

For the operation, we will leave it on

add for now. Let us add another node

that I use often called preview as text.

You can see it comes with comfy UI. This

is one of those special nodes I

mentioned earlier that can be connected

to almost anything. Even if other nodes

cannot connect directly, this node will

convert the value to text and display

it. If I run the workflow, you can see

the result. Even though they look the

same, one is actually a number and the

other is a text display of that number.

This makes more sense if you have coding

experience, but we will not get into

technical details here. What is

important to remember is that we can use

this node to see a result as text. It

also has options for how the preview is

displayed. Let us move this node down

and make a copy of the math in node.

Now remember, we have a result in this

node, but it is not visible unless we

use a node to preview or save it. Here

is something interesting. We do not see

any inputs on this node, but when we

drag a link to it, two input dots

appear. This means we can actually

connect values directly to these fields.

You will see this behavior with many

nodes that have number fields or text

fields. We can copy a value from an

output and feed it into these fields to

use it in the workflow. Notice how the

field for letter A is grayed out. That

means it is no longer using a manual

value. Instead, it is taking the value

from the previous node which is 8. Now

let us change the operation to multiply.

We now have 8 multiplied by 3. Let us

add another preview as text node to see

the result. When we run it, the result

is 24. As expected, let us remove that

preview node and arrange the layout.

This small workflow does something

simple. It adds two numbers and then the

result is multiplied by three. That

three could also come from another node

and so on until you build more complex

workflows. If I change the value to four

and run it again, we get the correct

result for that formula. I hope this was

not too much math. Now let us select the

middle node that does the multiplication

and right click on it. We have a

function called bypass. When we enable

bypass, the node is temporarily ignored

as if it is not part of the workflow. By

the way, you can also access bypass

quickly from this icon when the node is

selected. Now, if I run the workflow,

you can see it ignored that node and

only did the addition. If I enable it

again and run the workflow, it takes

that node into account again. You can

see that the node changes color and

becomes purple and semi-transparent.

This visual change tells us that the

node is deactivated. Bypassing a node is

useful when you want to test a workflow

without removing the node completely.

Hold the control key and select all

three nodes. Now, if we rightclick on an

empty area of the canvas, we have the

option to add a group. If we choose add

group, it will create an empty group.

But since we already selected the nodes,

it is better to choose add group for

selected nodes. This creates a group

that contains all those nodes. You can

think of a group like a folder that

holds multiple nodes together. One very

important thing to remember is that if

you want to move the group with all the

nodes inside, you need to drag it using

the group's top bar. If you select and

move an individual node, it will move

outside of the group. Groups can also be

resized. You can see a small triangle in

the corner that lets you change the size

of the group. If you rightclick on a

group, you also have the option to

bypass all the nodes inside it. This is

very useful when you have multiple

workflows on the same canvas. For

example, you can deactivate one workflow

and enable another so only one workflow

runs at a time. This becomes important

as workflows get more complex and models

get larger because running multiple

workflows at once can require more

resources than your system can handle.

If you double click on the group title,

you can change the group name. Enough

with math. Let us work a little with

text as well. When we use AI, we give it

prompts. And sometimes it helps to

combine text from different sources to

get a better prompt.

Now I am searching for concat. And you

can see that there are multiple nodes

with similar names. That is because

concatenate is a general concept and it

exists for different data types. This

one here, concatenate, works with

strings, which means text. It simply

takes multiple pieces of text and joins

them together into a single string. That

is why I added this cat made from

multiple pieces joined together to make

it easier to remember. Even if you

search for cat, you can easily find the

concatenate node. Let us add it to the

canvas. For example, for string A, I add

the word home and for string B, the word

car. When I connect them, the output

becomes a single piece of text, a

string. Let us drag a connection from

that string and search for a node that

can preview it. We can use the same

preview as text node again. Now, because

the first workflow is bypassed, it will

only run this workflow with concatenate.

You can see how it joined those two

words, first home, then car. We can also

use a delimiter. For example, I can add

a space here and run it again. Now the

result has a space between the words or

I can add a comma and a space. And now

the result looks like proper text with

separation. Let us move this node down

and hold alt and drag a copy of the

concatenate node. You can move nodes

around to make room so the connections

are easier to see. Here we have these

text fields. And like you saw with the

math nodes, we can connect outputs

directly into these fields if they are

the same type. When I drag a link from

the string output, you will see input

dots appear showing that I can connect

there. I can connect to the first field,

the second field or even the delimiter.

Let us connect it to the first field. So

now the home and car result becomes the

first input. And for the second field,

let us add the word flower. I will hold

alt again and drag another duplicate

since that is faster. Then I connect it.

Can you guess the result? We now get

home, car, and flower. So basically this

is how people create workflows. You

connect nodes like Lego pieces. Some

nodes can be connected together because

they share the same input and output

types and you get a result. Over time,

you can build more complex workflows

that can save you a lot of time. Let's

add another node. Double click on the

canvas and search for primitive. This

node is called primitive because it

represents the most basic types of

values. Things like numbers, text, and

true or false values are considered

primitive values. The primitive node is

used to manually create a value inside

comfy UI instead of getting it from

another node. You can use it to type in

a number, write some text, or define a

simple value that can then be connected

to other nodes. Think of it like writing

a value by hand and injecting it into

the workflow. You can see here it says

connect to the widget input. So we can

drag a link from there. Now you can see

we have a lot of inputs where we can

connect this value. If we look at this

text, notice what happens when the

connection is complete. It changes to

the type of value that was connected, a

string. Now we can manually insert any

text value there. When we run the

workflow, the result will include that

value. This is useful because sometimes

you want to use the same value in

multiple nodes. Instead of typing it

manually each time, you add a primitive

value once and connect it to all the

inputs that need it. Let us right click

on this group. Usually nodes have a

bypass option to disable or enable them.

But for groups, this option is called

set group nodes to always. Now the nodes

inside the group are enabled and we can

run that workflow if we want. Let us add

another primitive node to see how it

adapts. Last time when we connected a

primitive node to a text field, it

automatically converted the value into a

string because that input expected text.

Now if we connect a primitive node to a

math int node, it adapts differently.

This time it is converted into an

integer value. You can see that now we

can only enter numbers. It does not

allow text because this node expects an

integer. Right now the value is set to

five. Let me resize the node so we can

see it better. You can clearly see that

this one is an int and the other one is

a string. If we change this number and

run the workflow, Comfy UI will rerun

all the workflows on the canvas using

the new values. In this simple example,

it runs almost instantly. But later when

we use larger models, you will see that

some workflows can take minutes to

generate instead of seconds. So if you

look at all the nodes in these

workflows, you can clearly see that we

use this easyuse custom node and all the

rest do not have that label. That means

they come with comfy UI by default. Let

us go to the menu then edit and choose

clear workflow. Now I want to do a quick

recap just to make sure you assimilated

some of the basics. We double click on

the canvas to bring up this search

option. So we can search for nodes. You

type a word to search like load and then

you can select a node. For example, the

load image node. This node is used to

load an image from your computer. If we

click choose file to load, we can

navigate our computer and load an image.

By the way, I asked EVO to include some

images for this first episode in the

input folder. So you can have the same

images I am using. The path is Comfy UI

easy install Comfy UI input. Let us say

I select this helmet but it can be any

image. We can choose open or we can

double click on the image and it will

open. Now that the image is loaded, let

us add another node, the image crop

node,

and connect it from left to right from

output to input. To remove a connection,

you just drag from the output and

release it somewhere on the canvas. It

is like unplugging a cable and leaving

it on the floor. Let us redo the

connection. You can also click on the

small dot in the middle of the

connection and choose delete and it does

the same thing as unplugging. Let us

connect it again. We can hold control

and select multiple nodes by dragging

with the left mouse button pressed. This

lets us select multiple nodes at once.

You can also hold control and click on

the nodes one by one. If you select a

node by mistake, just click on it again

to deselect it. Once nodes are selected,

we can move them together. If you plan

to move them a lot, you can also add

them to a group. If you click on the

canvas and drag, you are moving the

canvas itself. This is useful when you

have long workflows and want to see

different parts of the workflow. Let us

move these nodes to the left. Now,

double click on the canvas and add a

node called preview. This time, it is

not preview as text. We could add that

too, but it would show numbers. Here we

add preview image. This node is similar

to save image, but it does not save the

image in the output folder. It is useful

when you just want to preview parts of a

workflow and do not need to save the

image. If you like the image, you can

still save it. You can rightclick on the

image and choose save image. Then save

it anywhere you want on your hard disk.

Let us cancel that and remove the

preview image node. This time let us add

a save image node so we can save the

result and then run the workflow again.

Now the result is saved. Let us go to

the desktop. The easy installer comes

with a shortcut to the output folder. We

double click on it and now we are in the

output folder. You can see the path at

the top. Here you can see all the images

generated with Comfy UI. These images

are saved in this folder. You can delete

them, move them to different folders, or

organize them however you want. I

usually pick the images I need, move

them into the project folder, and then

delete the rest because over time you

will end up with thousands of images.

Here we can see the helmet image we just

generated, but not the previous one from

the preview image node. If we go back

one folder to the main Comfy UI folder,

we can see a temp folder. Comfy UI uses

this folder to store preview images

temporarily. The contents of this temp

folder are deleted when you start Comfy

UI again. So, you can still recover

preview images even if you did not save

them right away, as long as you did not

close Comfy UI yet. We can collapse a

node using the top left gray dot and

click it again to expand it. Once a node

is selected, it has multiple options at

the top. One very useful option is the

info icon, which gives you more

information about the node. You can

close the properties panel from here. We

can change the color of the node. And

this symbol here is for subgraphs.

Subgraphs are a bit more complex. So

maybe in a later chapter or another

episode, we will talk more about them.

This arrow lets you bypass the node. And

if you click on these dots, it shows

even more options for the node. For

example, you can change the shape,

change the color, or pin the node so it

is fixed and cannot be moved. If we move

these nodes apart to see the links, we

can also hide the links from here. Be

careful with that because it can look

like no nodes are connected. I never use

this option because I like to see how

nodes are connected. It helps me

understand the workflow better. If you

do not like how the links look, there

are ways to change their shape. I like

the default look, but some people prefer

other options. If we go to the bottom

left or open the menu and go to

settings, we can change this. Let us

click on settings. Here we have many

settings we can change. Let us search

for link since we want to change how

links are displayed. You can see the

current one is called spline under link

render mode. If we change it from spline

to straight and close the settings, you

can see the links are now straight, but

they still adapt when you move the

nodes. Let us go to settings again and

change it to linear. Now the links are

always straight lines.

Let us change it back to the default

which is spline. Now let us remove all

the nodes.

I personally prefer the spline view

because it reminds me of sci-fi scenes

with lots of cables hanging around.

Let us double click on the canvas and

add a load image node again. Now let us

add another node and search for upscale

image. We will select the node called

upscale image by and move it closer so

we do not waste space on the canvas.

Then we connect it to the workflow and

add a save image node at the end. So we

have a complete workflow. If we run this

now we get the same image as before.

That happens because some nodes have

default values that do not change

anything. They only start doing

something once you change their

parameters. In this case, the upscale

value is set to one. Scaling by one is

like multiplying a number by one. You

get the same result. Now, let us

increase the scale by value to two. When

we run it again, the image is upscaled

by two times. So, we get double the

resolution. This is similar to resizing

an image in Photoshop. In this case, it

does not use AI to add new detail. It

simply enlarges the image. These upscale

methods are different ways of resizing

an image. Nearest exact copies pixels

exactly, so it is very fast and keeps

hard edges, but it can look blocky.

Bilinear smooths pixels together, giving

a softer result that can look slightly

blurry. Area is mainly meant for

downscaling and is not ideal for

upscaling images. By cubic uses more

surrounding pixels to produce smoother

and better looking results. Lancos

preserves detail and sharpness the best,

but it is slower than the others.

Let us say you do a lot of changes to a

node like titles, values, and colors,

and you forget how the default values

were. You can add the same node again

and redo all the values and connections,

or you can rightclick on the node and

choose fix node, recreate. If you select

that, the node goes back to its default

state. If you rightclick again, you also

have the option to clone the node and

move that clone wherever you want. You

can also do this faster by holding alt

and dragging the node. You can remove a

node from this menu, but pressing the

delete key is faster. We also have this

pin option. If you use it, a pin appears

at the top of the node. And now if you

click and drag, the node does not move.

It is pinned to the canvas. To move it

again, you need to rightclick and select

unpin. Sometimes when you get workflows

from the internet, some people stack

many nodes on top of each other and pin

them. It can look like there are only

two nodes, even if there are 10 nodes

behind one. I do not recommend doing

this. If you do not want people to use

your workflow, just do not share it.

We also saw that we need to change

values on some nodes for them to work.

If we bypass a node, the workflow still

runs and ignores that node. The links

are still there and the connection

passes through the node. This is

important because there is another mode

where the connection does not pass

through. Let us enable the node again

using bypass. Now right click on it and

go to mode. You will see the option

always which means the node is active.

There is also an option called never.

This mutes the node and makes it behave

as if it does not exist. You can see

that the node is now gray, not purple

like bypass. When we run the workflow,

we get an error. That is because the

node is not passing anything through. So

the next node does not receive the image

it expects. It is like cutting the cable

where that node was. Let us remove that

node and delete the link as well. If we

run the workflow again, the result is

the same. The image is missing because

there is no connection. Let us go to the

menu then edit and click undo. You can

also use Ctrl + Z multiple times until

you get back to the state you want. I

will undo until everything is active

again. Let us zoom out with the mouse

wheel and add a group. Name your group

in a way that explains what the nodes

do. Do not name it something generic

like my group. You can move the group

around and you will notice that it works

like a magnet. If a node is inside the

group area, it stays inside. Let us make

the group larger and move it around. So

you can see that nodes are sticking to

it. Now adjust the group size and move

the nodes so it looks cleaner. Workflows

can get quite large, so I like to

optimize the space to make them easier

to read and navigate. Once the nodes are

positioned, hold control and select all

the nodes. You will see that only the

nodes are selected, not the group. Now

rightclick and choose fit group to

nodes. The group will resize to fit the

nodes tightly. Now we can move the group

and it does not take much space. Groups

can have more options especially when

using custom nodes like RG3. If we go to

settings in Comfy UI, we have general

settings, but we also have settings for

custom nodes. For example, for RG3, we

have extra settings here. I can click

this button to open them. RG3 is

installed when you use the easy

installer.

If you install Comfy UI manually, you

need to install RG3 from the manager. We

will talk more about custom nodes later.

You can also access the same RG3

settings directly from here, which is

faster. If we scroll down, we have

settings for groups. For example, there

is an option called show fast group

toggles in group headers. Let us enable

it. You can choose when to show it

always or on hover. I will leave it on

hover and save the settings.

Now when I hover over the group, you can

see extra buttons in the top right. From

here, we can bypass all the nodes in the

group easily. We also have an option to

mute the group. This is similar to

setting nodes to never. When a group is

muted, the nodes inside it do not run at

all and the workflow behaves as if they

do not exist. Bypass still lets the

workflow run through the nodes. Mute

does not. Let us make the group active

again. We can also run the workflow

using the play button on the group. We

can change values, for example, use

smaller values to get a smaller image,

maybe half the size. There are many more

things you can do with groups and switch

style nodes, but we will cover those in

later episodes. I told you at the

beginning to leave the nodes to option

turned off. At the moment of this

recording, it is still in beta and has

some bugs. Maybe over time they will fix

everything and it will become stable. If

I activate it, you can see that it

changes how the nodes look. For most

nodes, things still work in a similar

way, but this change exists. So, they

can add more functionality to nodes.

With the current system they use, there

are limitations in what nodes can do.

And the new node version should give

them more possibilities to build better

nodes. Instead of the gray dot, you get

an arrow that points down and then to

the right when the node is collapsed.

The inputs are placed on the edge of the

node and some nodes have more options.

For example, in load image, you can see

previews of images from the input

folder. And you can also browse for

another image on your disk. However, for

older workflows, this can slightly

change node sizes and mess up the

layout. Some nodes might not work yet

until the node creators update them.

Because of that, until everything is

fixed and stable, I recommend leaving

nodes 2 turned off. Just a quick

reminder that from mode you can mute a

node by setting it to never. This is

useful when a workflow is big and has a

lot of branches. You can mute a branch

of that workflow and it will still run

without errors as long as there are no

nodes after the muted ones that expect

an input. To turn the node back on, you

go to mode and choose always. We also

have shape options for nodes, but these

are only decorative. They just change

the corners of the node. By default, the

corners are rounded. There is also the

card option which rounds only two

corners. Personally, I do not think it

is worth spending much time on this. To

remove a group, you can select it and

press the delete key or you can write

click on it, choose edit group, and then

remove. This only removes the group

container, not the nodes inside it,

unlike folders in other systems. Let us

select these two nodes while holding

control and press delete to remove them.

Then add an image crop node and connect

the link to it. After that, let us add a

preview image node. Since we are only

testing with these settings, we get a

crop from the top left corner of the

image. Let us arrange the nodes. Then

hold control, select both nodes, and

press control + C to copy and then plus

shift + V to paste them with the links.

Since we have them copied, let us paste

again to get a third branch. Right now,

all the settings are the same. So, all

three give the same result. We can

change the x coordinate on one to get

the bottom right corner of the image.

For another one, let us change the

y-coordinate to get the bottom left

corner. Now, when we run it, we split

the image into three pieces. You could

add another one for the bottom right

corner to get the missing part. That is

homework for you to figure out the

correct coordinates. Now if we change

the input image and run it again, you

can see how useful this can be. In a

later episode, we will learn how to load

multiple images from a folder and

automate this process so we can apply it

to all images in a folder. Now select

all the nodes in the workflow using the

shortcuttrl + a and then press delete to

remove everything. It is time for

another short break. This has been a

long chapter and I want to make sure you

have time to absorb the information.

Take a few minutes, press pause, get a

drink, or step away from the screen, and

then come back. Now, I do not know what

learning method works best for you, but

I can tell you one method that usually

works very well for video tutorials.

First, watch the entire tutorial from

start to finish without stopping too

much. This helps you build a general

understanding of what is possible and

how things fit together. Then watch it a

second time, pause the video and follow

along step by step inside Comfy UI.

After that, try to repeat the same steps

without the tutorial playing just from

memory. Once you are comfortable, start

experimenting.

Try changing nodes, parameters, or

settings that were not covered in the

tutorial. And if something does not work

or you get stuck, that is completely

normal. You can always go back to the

tutorial, rewatch a part or ask

questions on Discord. Learning Comfy UI

is not about speed. It is about

understanding.

It is time to build a workflow from

scratch. But first, let us go to

workflows. Open the getting started

folder and open workflow number one, the

one we used in a previous chapter. What

I want to do now is give you an analogy

so you can understand what is happening

here with all these nodes connected. So

it makes more sense. I will use a note

node and add some info next to each

node. You do not have to do that. Just

watch and pay attention. I will open the

same workflow but with those notes added

next to each node and I will explain

each one in detail. You probably noticed

by now that when we generate images with

AI, we usually download a file called a

model. Sometimes people call it a model

and sometimes they call it a checkpoint.

In practice, they usually mean the same

thing. A model is the trained AI itself.

It contains everything the AI learned

during training like styles, shapes, and

how images are formed. The word

checkpoint comes from machine learning.

During training, the model is saved at

different points in time called

checkpoints. Those checkpoints are what

we download and use. So when you hear

model or checkpoint, you can think of

them as the same thing, the trained AI

file that does the image generation. In

Comfy UI, you will often see the term

load checkpoint, but what you are really

doing is loading the model you want to

use. We can think of the model as the

photographer we want to hire. The load

checkpoint node is the step where we

actually hire that photographer.

Depending on what the photographer

learned during training, they will be

good at different types of photos. That

is why there are so many different

models available. Just like in real

life, some photographers specialize in

portraits, others in landscapes, macro

photography, or food photography. AI

models work in a very similar way. The

better and more complex the training of

a photographer, the more expensive they

usually are. In our case, that cost is

not money, but computer power. Larger

and more advanced models usually need

more VRAM and a stronger graphics card

to run properly. To keep things simple

for now, we are hiring one photographer.

We will use a model called Juggernaut

Reborn. And this is the photographer

that will generate our images. So now

that we hired the photographer, what

comes next? We need to give instructions

to that photographer about what we want

to get and what we want to avoid. These

instructions are called prompts. We

usually use a positive prompt to

describe what we want to see in the

image and a negative prompt to describe

what we want to avoid. In Comfy UI, we

use the same node for both. I just

colored one green for the positive

prompt and one red for the negative

prompt so they are easier to recognize.

The node we use is called clip text

encode. This node takes our written text

and translates it into a form that the

model can understand. In simple terms,

clip text encode acts like a translator

between human language and the AI. It

turns words into instructions that the

photographer can follow during the photo

shoot. Besides giving instructions on

how the photo should look, we also need

to decide how big the photo will be. For

that, we use the empty latent image

node. This node is like choosing an

empty photo paper before taking the

photo. Here is where we decide the width

and height of the image. We are defining

the size of the photo before it even

exists. At this stage, there is still no

image. It is just an empty space where

the photo will be created. Once the

photo shoot happens, the final image

will always respect the size we set

here. Now, it is time for the photo

shoot. The case sampler node is the

photo shoot itself. This is where the

photographer follows the instructions

from the prompts and uses the empty

photo paper to take the photo. Each

different seed is like taking a new

photo of the same scene. The idea is the

same, but the result is slightly

different every time. The K sampler

controls how the image is generated. It

decides how many steps the photographer

takes, how much randomness is allowed,

and how closely the final photo follows

the instructions. You do not need to

understand every parameter right now.

What matters is that the K sampler is

the core of the workflow where the

actual image creation happens.

Everything before the K sampler prepares

the photo shoot. Everything after it

finishes the photo. After the photo

shoot, the image is created, but it is

not visible yet. That is because the K

sampler does not produce a normal image.

It produces something called a latent,

which you can think of as a hidden

version of the photo. It contains the

information of the image, but it is not

in a format we can actually view. This

is where VAE decode comes in. The VAE

decode node is like the dark room in

photography. The photo already exists,

but it still needs to be developed to

become visible. So, the VAE decode takes

that latent result and converts it into

a real image that we can see, preview,

and save. Without this node, the

workflow can still generate something,

but you would not be able to view the

final photo because it is still in that

hidden latent form. And finally, the

save image node is where the finished

photo is delivered to the client. After

the VAE decode step, we usually add a

node that either previews or saves the

image. Preview nodes let us see the

result inside Comfy UI, while the save

image node writes the final image to

disk. Without one of these output nodes,

the workflow has no final result. In our

photo studio analogy, this is the moment

where the developed photo is either

shown to the client or delivered as the

final file. Now, let us zoom out and

look at the entire process. First, we

load a model from our disk. This is like

hiring a photographer. Then, we give

instructions. The positive prompt

describes what we want. For example, a

close-up portrait of a pet. The negative

prompt describes what we want to avoid.

For example, saying we do not want dogs.

Next, we decide how big the photo should

be using the empty latent image node.

This is where we choose the size of the

photo before it is taken. Now, let us

run the workflow. You can see that all

these instructions are passed into the K

sampler where the image is actually

created. The K sampler is the photo

shoot. It uses steps and different

settings similar to camera settings like

shutter speed or aperture to decide how

the photo is taken. After that, the

image goes through VAE decode where it

is converted from latent space into

actual pixels. This is like developing

the photo in a dark room and finally we

save the image. This is when the

photographer delivers the finished photo

to the client. Every image generation

workflow in Comfy UI follows this same

basic idea even when it becomes more

complex. Let us do some quick

experiments. What happens if I change

the negative prompt the instructions

where we say what we want to avoid. For

example, if I say I do not want a cat,

it will probably give me another pet

that is not a cat and we might get a dog

instead. If we run it again, it is like

taking another photo of a pet because

the seed is random. Now we can change

the seed to be fixed. When the seed is

fixed, each time we use the same prompt,

the same settings, and the same seed, we

should get the exact same image. If I

try to run it again, you can see that

nothing happens. The result would be the

same. So, Comfy UI does not even bother

to generate it again. If we change a

setting like the seed, then it lets us

generate again and we get a different

image. If we go back to the previous

seed, we are back to the same image we

had before generated with that seed. Now

that we kind of understand how it works,

let us click on this plus sign and build

the same workflow from scratch. Double

click on the canvas and search for load.

Usually it is either load checkpoint or

load diffusion model. But in some cases

there are special loaders for specific

models. Now that we have the node, we

select the model. Since we did not

download more models yet, we only have

one juggernaut reborn. So we hired our

photographer. Now let us give it

instructions. Search for prompt. And we

can find this clip text end code node.

Let us move it next to the other node. I

like to change the color to green for

the positive prompt. Right click and

clone the node or just hold alt and drag

the node to make a copy. For this second

one, let us change the color to red.

Again, this does not influence how it

works. It is the same node. It is just

visual. For the positive prompt, I will

add closeup portrait of a pet. For the

negative prompt, I will add cat. Not all

models use negative prompts. Some older

models like this one still use it, but

you will see later that some newer

models are smarter and do not need a

negative prompt and they work better

when the negative prompt is disabled.

Can you guess how these are connected?

We have clip on both input and output.

So, we can only connect clip to clip. If

we try to drag from the model, you can

see it does not work. And the same if we

try from the VAE. So, let us connect the

clip output from the model to both of

the text encoders. Now we have the

instructions for how the image should

look but we still need to define the

size. Let us search again using the word

empty and add the empty latent image

node. There is also a newer one that we

will use later for newer models but for

this workflow we will use this simple

one. I like to change the color of this

node to purple but you can leave it as

it is if you want. Now we have width and

height. Because we work with computers,

most models work better with values that

are multiples of 64 or 8. That is why we

see values like 512 instead of 500. I

know that this model was trained with

square images at 512x 512 pixels. So I

use these values to get better results.

Some newer models are trained with

larger images and can generate bigger

images. But that comes at a cost. Just

like printing a big photo costs more

than a small one, a bigger image takes

more time to generate and sometimes your

PC cannot handle it. More about that

later. Now, let us add the most

important part where the magic happens,

the K sampler. As you can see, this node

has four inputs where it takes all the

instructions and one output. First, we

connect the model since it has the same

color and name. Then, we connect the

conditions. The instructions are yellow.

Even if the names are different, we

connect the positive output to positive

and the negative output to negative.

That is how it knows which one is

positive and which one is negative even

though they come from the same type of

node. The last input is the empty latent

image which defines the size of the

image we want. Now we have everything

needed to generate the image but it is

still in latent format. We need pixels

to actually see it. So let us drag a

link from the output and you can see

that it suggests VAE decode. We select

it and now the image is decoded like a

dark room where the photo is developed.

Here we also have a VAE input. In this

case the VAE model is included inside

the main model which is why we can

connect it directly. In some cases the

VAE comes as a separate file and then we

use a load VAE node. You will see that

later. Now the last step is to save the

image. So we add the save image node.

Let us run the workflow and see if it

works or if we forgot something. If

everything turns green, it worked

without errors. There are cases where

the image does not look right. Even if

there are no errors, that usually means

some settings are not ideal. People who

create AI models usually provide

recommended settings, especially for the

case sampler. Just like in photography,

macro and landscape use different camera

settings. The same idea applies here. If

we look at the previous workflow, we can

see recommended settings for this model.

Steps 35, CFG7, this sampler, and

thisuler.

So let us change steps to 35, CFG to 7.

For sampler, we use DPM++ 2M and foruler

we use caris. Now let us run it again.

For this seed, we get some small

deformations, but for next seed, it

looks fine. We will see later how to

improve the results even more. Let me

show you what happens when we try to

generate an image that is much bigger

than what the model was trained to

handle. For this example, I will double

the image size. On the first try, I did

not even get a pet. Sometimes you might

get something that looks okay, but most

of the time you will see problems. you

can get strange deformations, things

that do not make sense, or visible

mutations. If I increase the size even

more, these problems become even more

obvious. It also takes more processing

power and more time to generate the

image. The reason this happens is

because this model was trained mainly on

512x 512 pixel images. When we ask it to

generate a much larger image, it

struggles to understand the full space.

You can think of it like the model

trying to generate the image in parts.

One part might look okay, but then it

tries to continue the image next to it,

almost like stitching pieces together,

and that is where things break. That is

why you sometimes see double heads,

repeated objects, or strange structures

in large images. Bigger images are not

always better if the model was not

trained for that size. But if a model is

trained to handle larger images, you can

get more details and better results. Let

us say I add ugly to the negative

prompt. So we push the result toward

more beautiful images. For the positive

prompt, let us be more specific. We want

a dog and we want it to be beautiful.

Now when we run it, we get a more

beautiful dog. Because this model is

really old, like I told you, it is good

for practice. But today, we have much

bigger and more accurate models. They

produce better results with fewer

deformationations, but they are larger

and need more VRAMm to run properly. Our

desktop computers are very similar to

Comfy UI because they are both built

around the idea of connecting

specialized components together where

each one does a specific job. The CPU

acts like the central processor just

like the sampler or the model does the

main work in Comfy UI. The monitor is

like preview and output nodes that show

results. The keyboard and mouse are

inputs just like prompts and parameters.

Printers and speakers are output devices

like save image or audio nodes. Routers

handle communication similar to data

links between nodes. The reason we

design systems this way is because

breaking complex tasks into smaller

connected parts makes them easier to

understand, easier to control, easier to

upgrade, and more flexible. That is

exactly why Comfy UI uses nodes instead

of hiding everything behind a single

button. Now that we know how to create a

workflow, we also need to learn how to

save it. If you look at the top, you can

see it says unsaved workflow. That means

none of these settings or nodes are

stored yet. If you want to reuse the

same workflow later without recreating

everything from scratch, you need to

save it. If I click on this arrow next

to the workflow name, you can see there

are several save options. Personally, I

prefer using the main menu. So, I go to

file and here we have save, save as, and

export. When you click save and the

workflow has never been saved before,

Comfy UI will ask you to give it a name

and choose where to save it. If the

workflow was already saved and you just

made changes, clicking save will

overwrite the existing file with the

same name. Save as lets you save the

same workflow under a different name.

This is the option I use the most,

especially when I want to create

variations of a workflow. Export is very

useful because it is not limited to the

Comfy UI workflow folder. It allows you

to save the workflow anywhere on your

computer, even outside the Comfy UI

folder. The API option is mainly used

when working with online or cloud-based

workflows. So, we will not use it here.

So, let us click export. Now, it asks

for a name. Choose a name that makes

sense to you. Click confirm. Then,

choose where to save it. For example, I

can save it on my desktop. You can see

that the file is saved with theJSON

extension. This JSON file contains all

the nodes, connections, and settings of

your workflow. This file is your

workflow, and you can open it anytime,

share it with others, or modify it

later. JSON files are simple text files.

You can open them with any text editor

like Notepad. JSON stands for JavaScript

object notation, and it is just a

structured way of writing text so both

humans and computers can read it. In

Comfy UI, the JSON file stores things

like node types, connections,

parameters, and settings, all written as

text. That is why workflow files are

small in size and easy to share. They do

not include images or models, only

instructions. If we go to workflows, you

can see I have that folder with

workflows saved there. You can do that,

too.

Go to the menu. Go to file. Choose save

as. Give it a name

and confirm. Now if we go to workflows,

we can see the workflow is saved there.

Right now it is not organized into any

folder. It is just in the main list. But

you can add a folder name in front of

the workflow name when you save it. For

example, folder name, then a forward

slash, then the workflow name. Let us

see where it is saved. Go to your Comfy

UI folder. Then inside the Comfy UI

folder, go to user,

then default, then workflows. Here you

can see your saved workflow and also the

folder I created for this course that

comes with the easy installer. You can

create your own folder manually. For

example, I can create a folder called my

workflows, then drag that workflow into

it. Now, if we go back to Comfy UI,

nothing changes immediately because

Comfy UI usually reads this when it

starts. But we can refresh using this

refresh button. Now our folder appears

there and we can see the workflow inside

it. I suggest organizing your workflows

like this because over time you will

have a lot of workflows and it becomes

hard to keep track of everything. By the

way, you can also use the search bar to

search for a workflow by name. We also

have a bookmark icon. If we click it,

the workflow is added to the bookmarks

at the top. So the ones you use the most

stay there. If you click the bookmark

again, it is removed from the favorites

list. Let us collapse this and I will

show you one more thing. If we go to the

desktop and open the shortcut for the

output folder or if we go directly to

the output folder, you can see all the

images generated so far with Comfy UI.

The last one is this dog. You probably

did not think about this yet, but if you

open an image generated with Comfy UI in

Notepad, you can actually see some code

at the beginning. Just like with

workflows, this happens because Comfy UI

attaches the workflow to the image when

it saves it. After that, there is the

image data which we cannot really read.

This means that every image has the full

workflow embedded in it, including all

the settings and prompts. Let me drag

this image onto the Comfy UI canvas so

you can see what happens. Now you can

see that it loads as a workflow with the

file name. If we generate again, we get

exactly the same image because it uses

the same seed and settings. Let us go

back to the output folder and drag a

different image. For example, this

robot. Now it loads that workflow. And

if we run it, we get the exact same

robot. This is very useful. Another

thing you might notice is that all

images start with the word comfy UI

followed by a number. This happens

because in the save image node, the

prefix is set to that value. We can

change it. For example, I can set it to

pixa. And now when I run the workflow,

the image file name will start with that

word followed by a number. As you can

see here, if you hover over the prefix

field, you can get more information

about how to format it. You can include

things like the date and other values in

the file name. Now, let us change it

again. I will add a folder name. for

example, my images, then a forward

slash, then the image prefix.

When we run the workflow now, the images

will be saved inside that folder. Let us

go to the output folder. You can see we

now have a folder called my images. And

inside it, we have the images that start

with the prefix we set followed by a

number. Now, I will go back to the

workflows folder that we created earlier

and delete it.

Back in Comfy UI, if we refresh the

workflows list, you can see that the

folder is gone. We are left only with

the getting started folder we used for

this episode. When you create your own

folders and organize your workflows, I

suggest naming them in a way that makes

sense. You can name them by base model

like SDXL workflows or flux workflows or

by function like text to image

workflows, inpainting workflows or video

workflows. Choose whatever makes the

most sense to you, but organizing your

workflows early will save you a lot of

time later.

In this chapter, I want to show you how

Comfy UI is organized on your disk. This

is important because sooner or later,

you will need to know where to place

models, images, workflows, and custom

nodes. Do not worry if this looks

overwhelming at first. You do not need

to understand everything right now. I

will focus only on the folders you

actually need as a user. This is the

main Comfy UI easy install folder. Think

of this as the main workspace that

contains everything Comfy UI needs to

run. The most important things here are

the Comfy UI folder, the Python embedded

folder, the add-ons folder, and the

batch files used to start or update

Comfy UI. In normal usage, you will

mostly work inside the Comfy UI folder.

If you have a different version of Comfy

UI, you will not have the add-ons folder

and some of the BAT files will be named

differently, but pretty much everything

else should be similar. When we open the

Comfy UI folder, we see many files and

folders. Most of these are internal

files used by Comfy UI itself. As a

beginner, you do not need to touch most

of these. The important folders for us

are models, input, output, custom nodes,

and the user folder. The models folder

is where all AI models live. This

includes checkpoints, Laura files, VAEs,

control nets, upscalers, and more.

Inside the models folder, everything is

organized by type. For example,

checkpoints or diffusion models for main

image generation models, loris for Laura

files, V for VAE files, control net for

control net models. When a workflow

tells you to download a model, it will

also tell you exactly which subfolder to

place it in. If a model is not placed in

the correct folder, Comfy UI will not

see it. The input folder is where you

place images that you want to load into

Comfy UI. For example, images used for

image to image control net masks or

reference images. Any image you place

here will be visible inside Comfy UI

when using a load image node. The output

folder is where Comfy UI saves generated

images by default. Every time you use a

save image node, the result will appear

here. This makes it very easy to find

all your generated images in one place.

The custom nodes folder is where all

custom nodes are installed. These are

extra features added by the community.

Each folder here represents a custom

node package. For example, we already

used the RG3 node and we will use more

later. When you install nodes using the

manager, they usually end up here

automatically. If a custom node is

missing or broken, this is usually the

first folder you should check. Inside

the user folder, we have user specific

data. The most important part for us is

the workflows folder. This is where

Comfy UI stores workflows that you save

from inside the interface. These

workflow files are saved as JSON files.

The add-ons folder is specific to the

easy install version. It contains extra

tools, optimizations, and helper

scripts. You usually do not need to

touch this folder unless a tutorial

specifically mentions it. You do not

need to memorize this right now, but

this structure might change as new tools

are created by IVO. For example, this

BAT file lets you link a folder with

models from another Comfy UI

installation. This one installs the Naku

node and this one installs Sage

Attention. There are also different

torch pack versions for more advanced

users who need a specific version for

certain custom nodes. You will also find

extra tools like one for Windows 10 that

enables long paths so Comfy UI can

download models even if the path is very

long. There is also an update folder

with BAT files, but as you will see

later, for the easy install version, I

recommend using different update BAT

files. The Python embedded folder

includes a self-contained Python

installation. This helps avoid conflicts

with other software and makes Comfy UI

easier to run and update. As you use

Comfy UI more, this folder structure

will start to make sense naturally. In

the next chapters, I will always tell

you exactly where things need to go. Let

us talk a little bit about updates and

custom nodes. What you are seeing here

is the Comfy UI easy install folder.

This setup already includes everything

needed to update Comfy UI safely. The

most important rule is this. Always

close Comfy UI before updating. Never

update while it is running in the

browser. Start Comfy UI BAT. This only

launches Comfy UI. It does not update

anything. Update Comfy UI BAT. This

updates the core Comfy UI code. Use this

when you want the latest features or

fixes. Update Comfy UI and Nodesbat.

This updates Comfy UI and all installed

custom nodes. Update easy install.bat.

This updates the easy install system

itself. When should you update? Update

when something is broken. Update when a

node requires a newer version. Update

when you want new features. Do not

update right before an important

project. Updates can sometimes break

workflows. If something breaks after an

update, you can usually fix it by

updating again or removing the last

custom node you installed. One important

reminder, Comfy UI moves fast. Stability

comes from not updating every single

day. If everything works, it is okay to

stay on your current version. At some

point, you will mess up Comfy UI. Maybe

a node breaks or some dependencies get

messed up or an update has bugs. But

remember, you can always do a fresh

install when that happens. Just create a

new folder and reinstall using the easy

installer. Let us doubleclick on update

easy install. This updates only the easy

installer and adds extra tools and

add-ons. As we move forward in this

series, more models will appear, new

nodes will be added, and IVO likes to

create scripts that make these

installations easier. When you see that

the installation is complete, you can

read more about the new release using

this link or press any key to exit. You

may not see any changes immediately, but

if we go to the add-ons folder, you can

see that we now have more BAT files than

we had in the first chapter. Now, let us

go back to the main folder and try to

update Comfy UI to see if everything

still works or if we break some nodes.

Nodes sometimes break after an update

because Comfy UI itself changes how

things work internally. Many custom

nodes are made by independent

developers, not by the Comfy UI team.

These custom nodes often rely on

specific Comfy UI behavior, internal

APIs, or extra Python libraries and

dependencies. When Comfy UI updates,

those assumptions can change and the

node stops working until its creator

updates it to match the new version. So,

Comfy UI started after the update, but

let us open the command window to see if

everything worked correctly. Usually,

after startup, you can see import times

for custom nodes. As you saw before, all

custom nodes are inside the custom nodes

folder. But look what happened here.

After the update, one of the custom

nodes installed like TC failed to

import. That means if you have a

workflow that uses that node, it will

not work. If you do not use that node,

you can ignore it and try updating Comfy

UI again in a few days to see if it gets

fixed. I will close Comfy UI now and try

something else. Sometimes there are

newer versions of the custom nodes and

if the author fixed the issue, updating

the nodes can fix the problem. So this

BAT file updates only comfy UI and this

one updates both Comfy UI and the custom

nodes. This process can take a while

because it updates all the nodes. So I

will speed it up. Comfy UI started. So

let us check the command window to see

if the issue was fixed. The node was

still not fixed. This means that at the

time I recorded this video, the update

from that day broke that node. When you

watch this video, it might already be

fixed and work for you. Either because

Comfy UI fixed a bug, the node creator

patched the node, or a new developer

created a replacement node. There is one

more thing I want to try. We can go back

to an older version of Comfy UI that did

work, a version that had the right

conditions for that node. The downside

is that if Comfy UI released new

features or nodes for newer models,

those might not work on the older

version. So, it is always a compromise.

You have to choose between keeping a

specific custom node working or using

the latest Comfy UI updates. IVO hid

this option so beginners do not

accidentally mess up their Comfy UI. Let

us go to the add-ons folder, then to

tools, and here we have the version

switcher. When we run this BAT file,

Comfy UI is downgraded to a previous

version. In my case, it went from

version 0.7 back to version 0.6.

If you run this script again, it

upgrades Comfy UI back to the latest

master branch. Let us press any key to

close this. Now that we are on an older

version, it is time to check if that

node works. Let us start Comfy UI. Wait

for the interface to load. Then open the

command window and check the custom

nodes. Now it is fixed and there are no

errors with the nodes. In a few days I

will try updating again to see if it

gets fixed in the newer version. But

this is basically how you update and

downgrade Comfy UI using the easy

installer. Other Comfy UI versions might

require you to run commands manually,

but I keep pushing IVO to create BAT

scripts for these tasks. I want to spend

my time generating, not typing lines of

code. You will see that we have the

manager here. In other versions, you

might find it somewhere else in the

menu. Let us open the manager and see

what we have here. We also have update

and update comfy UI. These are similar

to the BAT files, but the BAT files have

something extra. They take into account

some dependencies needed for certain

custom nodes to work, which Comfy UI

itself does not handle when updating.

For example, for the nunchaku node to

work, it needs specific dependencies,

like a certain version of a library. The

BAT file updates Comfy UI, but then

adjusts or downgrades those dependencies

to the versions required by the custom

nodes we use. IVO tries to maintain

these BAT files and keep them updated so

they stay compatible with the versions

needed to run the workflows shown in

these video tutorials. Because I am

using the easy installer, I did not

touch these update buttons inside the

manager. I only use the BAT files. If

you have a different version of Comfy

UI, you will need to use these update

options or use a BAT file from the

update folder instead. In the manager,

you can also find the latest Comfy UI

news, such as what was fixed, what is

new, and recent changes. At the bottom,

you can see the Comfy UI version and the

manager version. Most of the time the

manager is used for managing custom

nodes. If we go to the custom nodes

manager, we can see all the available

custom nodes created by different

developers. There are a lot of them. I

personally try to keep the number of

installed nodes to a minimum and install

only what is essential or what I use

most often. Some people install hundreds

of nodes, but the more nodes you

install, the harder it becomes to keep

everything compatible because each node

can have its own dependencies and

requirements. If I filter by installed,

you will usually not see many nodes here

besides the manager itself. However, I

asked Ivo to include a few essential

nodes that I use most often. One example

is the RG3 custom node, which includes

the image compar node that is very

useful for comparing images side by

side. Each custom node has a title and a

version number. You can switch versions

if needed, for example, when an older

workflow only works with a specific

version of a node. For each node, you

also have several actions available.

Update only that node, switch the

version, temporarily disable it, or

uninstall it. You can also see how many

individual nodes are included in that

custom node package along with a short

description. Some nodes mention possible

conflicts with other nodes. If you click

on that yellow warning text, you can

read more details about those conflicts.

These conflicts usually matter only if

you use both conflicting nodes in the

same workflow. You can also see the

author of the node and the number of

stars it has on GitHub. Stars are given

by users and usually indicate how

popular or trusted a project is. Some