You seem a bit confused, so let’s just take a moment to sort things out:
Adding a custom node or model in ComfyUI / Hugging Face: what is probably going wrong, and where to start
You are probably not doing one single thing wrong. The more likely problem is that ComfyUI has several different “download and install” categories that look similar from the outside but are completely different underneath.
For a beginner, these all feel like the same action:
download something → extract/copy it somewhere → maybe run pip install → restart ComfyUI → expect something new to appear
But in ComfyUI there are at least four different things:
| Thing |
Plain-English meaning |
Usually goes here |
How it appears in ComfyUI |
| Custom node |
Extra code that adds new ComfyUI features |
ComfyUI/custom_nodes/<node_folder> |
Right-click node menu, left panel, Manager UI, workflow support, or backend feature |
| Model |
AI weights, usually a big file |
ComfyUI/models/<model_type> |
Dropdown inside a loader node |
| Python dependency |
Package a custom node needs to run |
ComfyUI’s Python environment |
Does not appear directly; errors show in the command window |
| Workflow |
A graph/recipe telling ComfyUI what to connect |
Opened or dragged into ComfyUI |
Shows missing-node or missing-model warnings if pieces are absent |
That distinction is the whole issue.
A .safetensors file is probably a model, not a custom node.
A GitHub ZIP with requirements.txt is probably a custom node, not a model.
A .json file or workflow PNG is probably a workflow, not a model or a custom node.
A requirements.txt file is not something you “load” in ComfyUI; it tells Python which packages a custom node needs.
My short diagnosis
From what you described:
“I keep downloading stuff, extracting to the comfyui/custom_nodes folder, removing the -main bit, running pip install -r requirements.txt, all looks good, reload ComfyUI, nothing.”
The most likely causes are:
- You may be running the wrong
pip.
- The custom-node folder may be nested incorrectly.
- The custom node may be failing to import during ComfyUI startup.
- You may be expecting every custom node to appear as a normal right-click node.
- ComfyUI Manager may not actually be enabled.
- You may be mixing up Hugging Face model downloads with GitHub custom-node installs.
- ComfyUI-Copilot is probably not the best first test because it has its own UI/activation flow.
That is a very normal beginner situation. ComfyUI is powerful, but its installation ecosystem is not beginner-obvious.
The biggest likely issue: plain pip may be installing into the wrong Python
If you are using ComfyUI Windows Portable, it has its own Python inside:
<ComfyUI_ROOT>\python_embeded\python.exe
So this command can be misleading:
pip install -r requirements.txt
It may install packages into your normal Windows Python, not into ComfyUI’s Python.
For ComfyUI Portable, the safer pattern is:
cd /d <ComfyUI_ROOT>
.\python_embeded\python.exe -m pip install -r .\ComfyUI\custom_nodes\<NODE_FOLDER>\requirements.txt
Example for ComfyUI-Copilot:
cd /d D:\ComfyUI_windows_portable
.\python_embeded\python.exe -m pip install -r .\ComfyUI\custom_nodes\ComfyUI-Copilot\requirements.txt
Why this matters:
You run pip.
The install looks successful.
Lots of text appears.
But the packages went into the wrong Python.
ComfyUI starts with its own Python.
The custom node tries to import a required package.
ComfyUI cannot find it.
The custom node fails to load.
Nothing appears in ComfyUI.
So “pip looked good” does not necessarily mean “ComfyUI can use it.”
Official references:
The second likely issue: the folder may be nested wrong
When you download a GitHub ZIP, it often extracts like this:
ComfyUI-Copilot-main
Renaming it to:
ComfyUI-Copilot
is not always enough.
You need to check the inside of the folder.
Correct custom-node folder shape
ComfyUI_windows_portable
└── ComfyUI
└── custom_nodes
└── ComfyUI-Copilot
├── __init__.py
├── requirements.txt
├── README.md
└── other files...
Wrong: double nested
ComfyUI_windows_portable
└── ComfyUI
└── custom_nodes
└── ComfyUI-Copilot
└── ComfyUI-Copilot
├── __init__.py
├── requirements.txt
└── other files...
Wrong: extracted folder but real code is one level deeper
ComfyUI_windows_portable
└── ComfyUI
└── custom_nodes
└── ComfyUI-Copilot-main
└── ComfyUI-Copilot
├── __init__.py
└── requirements.txt
For custom nodes, the actual node package should usually sit directly under:
ComfyUI\custom_nodes\<node_folder>
not one or two folders deeper.
That is why I would avoid ZIP installs at first. Use Manager first, Git clone second, and ZIP only if necessary.
The third likely issue: the node may be failing to import
A custom-node folder can exist, and the dependency install can look successful, but ComfyUI can still fail to load the node.
When ComfyUI starts, it tries to import every custom node. If one fails, it is skipped.
You need to look in the black command window for words like:
IMPORT FAILED
Traceback
ModuleNotFoundError
ImportError
No module named
Cannot import
Example:
0.0 seconds (IMPORT FAILED): D:\ComfyUI_windows_portable\ComfyUI\custom_nodes\ComfyUI-Copilot
That means:
ComfyUI found the custom-node folder, tried to load it, failed, and skipped it.
The node will not appear.
If you see:
ModuleNotFoundError: No module named 'xyz'
that means:
The custom node needs package xyz, but ComfyUI’s Python cannot find it.
Then install the requirements using ComfyUI’s embedded Python, not plain pip.
Useful references:
ComfyUI Manager: you may need to enable it, not “install it from Essentials”
This part is very important.
Current ComfyUI Manager behavior can differ from older tutorials.
For Windows Portable, the current ComfyUI docs say the new ComfyUI Manager is built into ComfyUI core, but it needs to be enabled.
From your ComfyUI portable root folder, run:
cd /d <ComfyUI_ROOT>
.\python_embeded\python.exe -m pip install -r .\ComfyUI\manager_requirements.txt
.\python_embeded\python.exe -s .\ComfyUI\main.py --windows-standalone-build --enable-manager
Example:
cd /d D:\ComfyUI_windows_portable
.\python_embeded\python.exe -m pip install -r .\ComfyUI\manager_requirements.txt
.\python_embeded\python.exe -s .\ComfyUI\main.py --windows-standalone-build --enable-manager
Then open ComfyUI in the browser.
Important: if you normally start ComfyUI by double-clicking:
run_nvidia_gpu.bat
Manager may disappear again unless that .bat file also includes:
--enable-manager
Open run_nvidia_gpu.bat in Notepad and look for the line that launches ComfyUI. Add --enable-manager.
It should look roughly like:
.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --enable-manager
Official reference:
Why LoRA Manager worked but Copilot / Actor / Manager did not
This is not surprising.
One successful install does not prove all installs will work.
LoRA Manager may have worked because it came through a clean one-click path:
known extension
known registry entry
dependencies handled
visible UI result
But other nodes can be harder.
ComfyUI-Copilot may involve:
frontend UI
left-panel activation
API/model configuration
Python dependencies
possibly conflicting packages
Actor/video/animation nodes may involve heavier dependencies such as:
opencv
onnxruntime
insightface
ffmpeg
torch-related packages
special model files
video models
face models
pose models
Those are not beginner-friendly first tests.
The safe order is:
basic ComfyUI works
Manager works
one simple custom node works
one simple model works
then Copilot
then Actor/video/advanced nodes
ComfyUI-Copilot specifically
ComfyUI-Copilot is probably not supposed to appear only as a normal right-click node.
Its own project page describes a left-side activation button and configuration flow. So after installing it, do not only do this:
Right click canvas → Add Node → search "copilot"
Also check:
left side panel
extension/plugin area
ComfyUI startup log
API/model configuration step
There are two different possibilities:
| Situation |
Meaning |
| Copilot failed to import |
It will not appear anywhere; terminal likely says IMPORT FAILED |
| Copilot loaded correctly |
It may appear through a left-side panel button, not as a normal canvas node |
Useful reference:
Hugging Face downloads: model files are not custom nodes
This is the other big beginner trap.
A Hugging Face page often hosts model files, not ComfyUI custom nodes.
A file like this:
model.safetensors
does not usually go here:
ComfyUI\custom_nodes
It usually goes somewhere under:
ComfyUI\models
ComfyUI model files appear in loader-node dropdowns. They do not usually create new right-click nodes.
Basic model-folder cheat sheet
| Downloaded file type |
Usually put it here |
Usually load it with |
SD / SDXL checkpoint .safetensors or .ckpt |
ComfyUI\models\checkpoints |
Load Checkpoint |
LoRA .safetensors |
ComfyUI\models\loras |
Load LoRA |
VAE .safetensors |
ComfyUI\models\vae |
Load VAE |
ControlNet .safetensors |
ComfyUI\models\controlnet |
Load ControlNet Model |
Upscaler .pth / .safetensors |
ComfyUI\models\upscale_models |
Upscale model loader |
| Text encoder / CLIP |
ComfyUI\models\clip or ComfyUI\models\text_encoders |
CLIP/text encoder loader |
| Newer diffusion model / Flux-style model |
often ComfyUI\models\diffusion_models |
Load Diffusion Model or workflow-specific loader |
| GGUF model |
depends on custom node |
GGUF-specific loader |
Workflow .json or PNG with metadata |
not a model folder |
open/drag into ComfyUI |
Official and practical references:
Hugging Face repos can contain different formats
A Hugging Face repo is not always “one file for ComfyUI.”
It may contain:
model.safetensors
lora.safetensors
vae.safetensors
config.json
model_index.json
unet/
vae/
text_encoder/
scheduler/
tokenizer/
*.gguf
README.md
workflow.json
If a Hugging Face repo has folders like:
unet/
vae/
text_encoder/
scheduler/
model_index.json
that is probably a Diffusers-style repo, not a simple ComfyUI checkpoint.
Do not just dump that whole folder into:
ComfyUI\models\checkpoints
Instead, look for one of these:
ComfyUI instructions
a ComfyUI workflow
a single-file checkpoint version
separate ComfyUI-format weights
custom node instructions
Useful Hugging Face references:
Where I would start
Do not start with Copilot, Actor nodes, video nodes, Flux, Wan, Qwen, GGUF, or complex Hugging Face repos.
Start with one boring, known-good path.
Stage 1: make basic ComfyUI work
Use the official beginner guides:
You want to understand this basic chain:
Load Checkpoint
→ CLIP Text Encode positive prompt
→ CLIP Text Encode negative prompt
→ Empty Latent Image
→ KSampler
→ VAE Decode
→ Save Image
If this works, ComfyUI itself is basically healthy.
If this does not work, do not debug custom nodes yet. Fix the base install, model file, GPU/Torch issue, or checkpoint path first.
Stage 2: enable Manager properly
From the portable root:
cd /d <ComfyUI_ROOT>
.\python_embeded\python.exe -m pip install -r .\ComfyUI\manager_requirements.txt
.\python_embeded\python.exe -s .\ComfyUI\main.py --windows-standalone-build --enable-manager
Then add --enable-manager to your normal launch .bat.
Reference:
Stage 3: install one simple custom node
Do not test with Copilot first.
Pick one simple custom node through Manager that clearly adds normal canvas nodes.
Install it.
Restart ComfyUI.
Check the terminal.
You want no:
IMPORT FAILED
Traceback
ModuleNotFoundError
ImportError
This proves the custom-node system is working.
Stage 4: test one simple Hugging Face model download
Start with something simple:
one checkpoint
or
one LoRA
or
one VAE
Do not start with a full Diffusers repo or a split modern model.
Example folder logic:
checkpoint → ComfyUI\models\checkpoints
LoRA → ComfyUI\models\loras
VAE → ComfyUI\models\vae
After placing the file:
press R in ComfyUI if appropriate
restart ComfyUI if needed
select the file in the matching loader node
References:
Stage 5: return to ComfyUI-Copilot
Once Manager works and a simple custom node works, install Copilot cleanly.
Prefer Git over ZIP if possible:
cd /d <ComfyUI_ROOT>\ComfyUI\custom_nodes
git clone https://github.com/AIDC-AI/ComfyUI-Copilot.git
Then install requirements with ComfyUI’s Python:
cd /d <ComfyUI_ROOT>
.\python_embeded\python.exe -m pip install -r .\ComfyUI\custom_nodes\ComfyUI-Copilot\requirements.txt
Then launch:
.\python_embeded\python.exe -s .\ComfyUI\main.py --windows-standalone-build --enable-manager
Then check:
left side panel
Copilot activation button
startup log
API/model configuration prompts
Reference:
Beginner-safe diagnostic checklist
When a custom node does not appear
Check:
Is the folder directly under ComfyUI\custom_nodes?
Is there an __init__.py file in the node folder?
Did I accidentally create a double-nested folder?
Did I install requirements with python_embeded\python.exe -m pip?
Did I fully restart ComfyUI?
Did the terminal show IMPORT FAILED?
Is this node supposed to appear in the right-click menu, or somewhere else?
When a model does not appear
Check:
Is it actually a model file?
Is it in the right ComfyUI\models subfolder?
Am I using the correct loader node?
Did I refresh/restart ComfyUI?
Is the workflow asking for an exact filename?
Is this model compatible with the workflow architecture?
When Manager does not appear
Check:
Did I install manager_requirements.txt?
Did I launch with --enable-manager?
Did I add --enable-manager to run_nvidia_gpu.bat?
Am I looking at an old guide showing an older Manager UI?
When pip install looked fine but nothing changed
Check:
Did I use plain pip?
Did I use ComfyUI’s embedded Python?
Did the package install into python_embeded?
Did the startup log still show ModuleNotFoundError?
Good guides to read first
Core beginner ComfyUI
Custom nodes and Manager
Models and Hugging Face
Copilot specifically
What I would avoid for now
Avoid these until your basics are stable:
installing many custom nodes at once
using ZIP installs when Git/Manager is available
starting with Copilot as the first custom-node test
starting with Actor/video nodes
starting with Flux/Wan/Qwen/GGUF workflows
downloading entire Hugging Face repos blindly
putting model files in custom_nodes
putting custom-node code in models
using plain pip with Windows Portable
The safer beginner sequence is:
1. basic text-to-image workflow works
2. Manager works
3. one simple custom node works
4. one simple checkpoint/LoRA download works
5. Copilot works
6. Actor/video/advanced nodes work
My final answer to “what am I doing wrong?”
Most likely:
- You are using plain
pip instead of ComfyUI Portable’s embedded Python.
- Some ZIP folders may be nested incorrectly.
- Some nodes are probably failing import during startup.
- You may be expecting every custom node to appear in the right-click node list.
- Manager may not be enabled with
--enable-manager.
- Hugging Face model files and GitHub custom-node code are being mixed together.
- ComfyUI-Copilot is not a simple first custom-node test because it uses a side-panel/configuration flow.
That is not a rare failure. It is a very common ComfyUI beginner trap.
The best way out is not more random installs. It is a clean, boring, testable path:
make basic ComfyUI work
enable Manager
install one simple custom node
install one simple model
then try Copilot
then try Actor/video nodes
Once that chain is stable, Hugging Face downloads and custom-node installs become much less mysterious.