Skip to content

Where to Put Models: The models Directory and extra_model_paths Explained ​

If you're searching for "where to put ComfyUI models," you're probably holding a freshly downloaded, several-GB .safetensors file and feeling stuck: the tutorial just says "put it in the models directory," but when you open it there are dozens of subfolders and you don't know which one to drag it into.

This lesson explains ComfyUI's model directory rules clearly: what the default models directory looks like, which subdirectory each model type goes in, how to make the files you put there appear in node dropdown lists, and how to use the official extra_model_paths.yaml to place models on any large drive — even sharing the same files with WebUI.

This page is lesson 4 of the Quick Start. You can follow along as soon as ComfyUI is installed — no prior workflow knowledge required.

What You'll Be Able to Do After This Lesson ​

  • Answer "where do ComfyUI models go" in one sentence: the type-matched subdirectories under <安装目录>/ComfyUI/models/
  • Put checkpoints, LoRAs, VAEs, ControlNets, and upscaling models into the correct subdirectories and find them in the corresponding loader nodes' dropdown lists
  • Use the r key to refresh (or restart) so models added while running get recognized
  • Write an extra_model_paths.yaml: let multiple ComfyUI instances, or even WebUI (A1111), share the same model files and stop downloading duplicates
  • Distinguish the model directory locations and configuration entry points across the three installation methods: portable package, Comfy Desktop, and manual installation

Your Current Predicament ​

  • You downloaded a roughly 4GB model, the tutorial just said "put it in models," you opened models and found twenty or thirty folders, dropped it in randomly, and now no node can find it
  • The model is definitely in there, but it just doesn't show up in the Load Checkpoint dropdown, and refreshing the page doesn't help
  • You have both WebUI and ComfyUI installed, the same model gets downloaded twice, and tens of GB of disk space vanish just like that; you want to move it to the D drive but are afraid ComfyUI won't find it

When to Use This Technique ​

When you need to:

  • Find the correct subdirectory for a freshly downloaded model file
  • Make ComfyUI recognize models placed outside the default directory (e.g., a dedicated model drive)
  • Have multiple ComfyUI instances, or ComfyUI + WebUI, share one set of model files

And you don't want to:

  • Re-download all your models every time you switch software or follow a new tutorial
  • Pile tens of GB of models in the default location on the C drive
  • Spend half a day puzzling over configuration file syntax

🎒 Preparation Before You Start ​

  • Have ComfyUI installed and able to start: for the Windows portable package see Installation: Windows Portable Package; for the desktop version / macOS / Linux see Alternative Installations
  • Have a model file on hand: if not, first download the official starter SD1.5 weights v1-5-pruned-emaonly-fp16.safetensors (about 4GB; the next lesson's first image generation also uses it)
  • Leave enough disk space: the official documentation reminds that a single generative model is often several GB, and both downloading and syncing require budgeting time and space
  • A cup of water ☕ (enough time to finish it while the model downloads)

⚠️ Download Tips for Users in Mainland China

Model files are mostly hosted on Hugging Face and Civitai (the community download sources listed in the official documentation). The official documentation notes that users in mainland China may need to configure a proxy for stable access. Slow downloads don't mean you did anything wrong.

Core Idea ​

**ComfyUI finds models through "agreed-upon folders." ** The installation package itself is tiny and contains no model files; the ComfyUI models folder is by default at <安装目录>/ComfyUI/models/, with type-based subdirectories underneath. ComfyUI scans these directories at startup (plus the paths configured in extra_model_paths.yaml) and fills the files it finds into the dropdown lists of the corresponding loader nodes (most of their names start with Load).

**"Where to put it" always comes down to two steps: first ask the type, then the directory. ** Checkpoints go in checkpoints, LoRAs in loras, VAEs in vae... Putting a model in the wrong subdirectory is about the same as not putting it there at all — drop a checkpoint into the loras folder and no LoRA node will ever list it.

**The directories can be left unchanged, or you can add to them. ** extra_model_paths.yaml is the official "extra search paths" solution: centralize models on one large drive and point multiple ComfyUI instances, or even WebUI, at it. The entry points differ across the three installation methods:

Installation MethodDefault models DirectoryEntry Point for Adding External Paths
Windows Portable PackageComfyUI_windows_portable\ComfyUI\models\ComfyUI root directory's extra_model_paths.yaml
Manual Installation (git clone)<克隆位置>\ComfyUI\models\ (the cloned repository folder)Same as above (inside the repository folder)
Comfy DesktopManaged by the desktop version; view via capsule menu → StorageStorage interface (or its configuration file)

Why can't it be found even though it's in the right place? Besides location, there are two more dimensions: the file extension must be in the supported list (.ckpt / .pt / .pt2 / .bin / .pth / .safetensors / .pkl / .sft); files added while it's running only enter the list after a refresh. These three things are the stars of the "Pitfall Reminders" later on.

Follow along with me ​

Step 1: Find your models directory — where ComfyUI models go ​

Why: The three installation methods use different directory locations; find the door first, then talk about putting things in it.

Windows portable package users ​

Enter this in File Explorer's address bar (replace ComfyUI_windows_portable with your extraction location, e.g. D:\ComfyUI_windows_portable\ComfyUI\models\):

text
ComfyUI_windows_portable\ComfyUI\models\

Manual installation users ​

The official manual installation is git clone https://github.com/Comfy-Org/ComfyUI.git; the cloned folder is called ComfyUI, and the models inside it is the models directory:

text
<你的克隆位置>\ComfyUI\models\

Comfy Desktop users ​

No need to dig through folders: click the capsule menu at the top of the desktop app → open the Storage tab to see the various model directories; click the folder icon next to a directory to open it directly in your system file manager. Official note: on the desktop version, models are shared between multiple instances by default.

You should see: a row of subfolders under the models directory — checkpoints, loras, vae, controlnet, etc.

  • I can open my own models directory and see subfolders such as checkpoints

Step 2: Know your directories — which model goes in which folder ​

Why: Model types and subdirectories must match up; a model placed in the wrong location won't appear in any node.

Common type reference table (subdirectory names are the registered names in the ComfyUI source folder_paths.py):

Model typeWhich subdirectory to put it inCorresponding loader node (where the dropdown is)
Checkpoint main modelmodels/checkpoints/Load Checkpoint
LoRAmodels/loras/Load LoRA
VAEmodels/vae/Load VAE
ControlNetmodels/controlnet/ (models/t2i_adapter/ also counts as this type)Load ControlNet
Diffusion models (DiT / UNet, common in new architectures)models/diffusion_models/ (the old directory name models/unet/ is also recognized)Load Diffusion Model
Text encoders (CLIP / T5 / Qwen, etc.)models/text_encoders/ (the old directory name models/clip/ is also recognized)Load CLIP (use DualCLIPLoader for FLUX and other dual-encoder setups)
Upscale models (ESRGAN, etc.)models/upscale_models/Load Upscale Model
Embeddingmodels/embeddings/—

💡 New models often come as "three files, placed separately"

New models like Z-Image-Turbo, Qwen-Image, and Wan2.2 are not a single checkpoint; they are split into three files — a diffusion model (→ diffusion_models), text encoders (→ text_encoders), and a VAE (→ vae) — each placed into its own directory. The model lists in the official tutorials all give paths in this format. For which file goes in which slot, see the tutorial for the corresponding model in Model × Task Overview.

💡 You can further categorize within subdirectories

Each type directory supports nesting: you can create folders such as sd15/ and flux/ under models/checkpoints/ to organize things; ComfyUI scans recursively, and files appear in the dropdown with their subdirectory paths included.

You should see: Using the table above, every model file you have on hand can be assigned to its subdirectory — the first model, v1-5-pruned-emaonly-fp16.safetensors, is a checkpoint and goes into models/checkpoints/.

  • Using the table above, I know which subdirectory each of my models belongs in

Step 3: Put the model in place and make it appear in the node list ​

Why: ComfyUI only scans directories at startup; a running ComfyUI will not automatically discover newly added files.

How to do it:

  1. Put the model file into the corresponding subdirectory. For your first model, the official beginner pick is SD1.5: v1-5-pruned-emaonly-fp16.safetensors → models/checkpoints/
  2. If ComfyUI is running, press r on the canvas to refresh node definitions; if it still hasn't appeared in the list, restart ComfyUI
  3. Double-click the canvas to search for Load Checkpoint (or drag one out of the node library), then open its dropdown list

You should see: v1-5-pruned-emaonly-fp16.safetensors appears in the Load Checkpoint dropdown list.

💡 Model library sidebar: drag and drop to insert

Click the Models icon in the left sidebar to open the model library: browse by folder tree, search by name; drag a model directly onto the canvas and it will automatically insert the corresponding loader node with the file selected — dragging from checkpoints gives CheckpointLoaderSimple, loras gives LoraLoader, and vae gives VAELoader. If a newly added file doesn't show up, click the refresh button at the top of the panel (the shortcut is likewise r).

With the first model in place, you can actually jump straight to Your First Generation to produce an image; if you want to manage model directories systematically, continue with step 4.

  • My model appears in the loader node's dropdown list

Step 4: Add external model paths with extra_model_paths.yaml (portable package / manual installation) ​

Why: Models are often several GB each. If you want to keep models centralized on a dedicated large drive, or let multiple ComfyUI instances or a WebUI share one copy of the files, this single yaml file is the official solution.

Method A: Copy the official example file (recommended) ​

  1. Open the ComfyUI root directory — for the portable package it's ComfyUI_windows_portable\ComfyUI\, for manual installation it's the repository folder you cloned. Inside there is a extra_model_paths.yaml.example (the official readme file bundled with the portable package also says: rename it to extra_model_paths.yaml and then edit it)
  2. Make a copy, rename it to extra_model_paths.yaml, and keep it in the same directory
  3. Open it with Notepad or any text editor and write the configuration based on where your model library is. Suppose all your models are under D:\AIModels\models\:
text
D:\AIModels\
  └── models\
        ├── checkpoints\
        ├── loras\
        ├── vae\
        └── controlnet\

The corresponding minimal configuration (from the official documentation example):

yaml
my_custom_config:
    base_path: D:\AIModels
    loras: models/loras/
    checkpoints: models/checkpoints/
    vae: models/vae/
    controlnet: models/controlnet/

How to read it: the top-level my_custom_config is the config block name — call it whatever you like; base_path is the model library root directory; each key below is a model type (matching the types in the step 2 table), and its value is a subdirectory relative to base_path. Just write only the types you actually have.

  1. Save, restart ComfyUI—the official docs state clearly: changes take effect only after a restart.

You should see: lines like Adding extra search path ... appear in the startup log (each added path makes ComfyUI log one of these); the loader dropdown now includes models from the external directory.

  • Adding extra search path appears in the startup log, and models in the external directory can be selected

Method B: If the file doesn't exist, create it yourself ​

It's fine if you can't find .example—the official docs say: create extra_model_paths.yaml with any text editor and place it in the ComfyUI root directory. For the full list of key names, see the official example file (the source code folder_paths.py is the final authority on key names).

Advanced syntax (all of these appear in the official example file) ​

  • Mount multiple directories under one type: use YAML's | multiline syntax, one per line:
yaml
loras: |
    models/loras/
    models/LyCORIS/
  • base_path supports writing ~ (the user's home directory); when writing relative paths, they are resolved relative to the directory containing the yaml file
  • is_default: true: puts this path at the front of the list and makes it the default download directory (e.g., the template library's automatic downloads go there)
  • You can also mount external custom nodes: add a custom_nodes: <路径>. Note this doesn't change the default install location for nodes; it only adds another search path; a node's Python dependencies still need to be installed in the corresponding environment

Method C: Share one set of models with the WebUI (A1111) ​

The official docs give a configuration block for coexisting with the A1111 WebUI. If your WebUI is installed in D:\stable-diffusion-webui\, write it like the official example:

yaml
a111:
    base_path: D:\stable-diffusion-webui\
    checkpoints: models/Stable-diffusion
    configs: models/Stable-diffusion
    vae: models/VAE
    loras: |
         models/Lora
         models/LyCORIS
    upscale_models: |
                  models/ESRGAN
                  models/RealESRGAN
                  models/SwinIR
    embeddings: embeddings
    hypernetworks: models/hypernetworks
    controlnet: models/ControlNet

After saving and restarting, ComfyUI reads the WebUI's model directories directly—one copy of the models, two apps using them, no re-downloading for either.

Step 5: Comfy Desktop users—add directories via the Storage interface ​

Why: the desktop version has a graphical interface, and the official recommendation is to add directories directly in the UI instead of hand-writing yaml.

How: click the capsule menu at the top → Storage tab → add your model directory. The official desktop docs give two levels of granularity:

  • Shared across all instances: Desktop Settings → Storage → Shared Models → + Add Shared Directory
  • For a single instance only: Manage → Storage → Model Directories

You can also edit the config file directly: on Windows it's at C:\Users\<用户名>\AppData\Roaming\ComfyUI\extra_models_config.yaml, on macOS at ~/Library/Application Support/ComfyUI/extra_models_config.yaml. The official docs give three reminders:

  • Back up the config file before editing so you can restore it if something breaks; don't overwrite the path configuration generated at install time
  • The newer desktop docs add: the file in app data above is used by the old desktop version; the current version prefers using the Storage interface
  • You can also put extra_model_paths.yaml in that instance's ComfyUI folder (<安装目录>/ComfyUI/extra_model_paths.yaml); it will also be loaded at startup

You should see: the directory you added appears in the Storage tab; after a restart, the model library sidebar can browse models in the external directory.

  • (Desktop users) I've added the directory in the Storage tab and backed up the config file

Checkpoint ✅ ​

  • I can open my models directory in one go and state the full path
  • I know which subdirectory checkpoint / LoRA / VAE / ControlNet / upscaler models each go into
  • For models added while running, I press r to refresh (or restart if that doesn't work) so they appear in the dropdown
  • If external paths are configured: extra_model_paths.yaml is in the ComfyUI root directory, I restarted after editing, and the log shows Adding extra search path
  • If sharing with the WebUI: both sides' loaders list the same model files

Pitfall reminders ​

❌ The model is in place but doesn't show in the dropdown ​

Go through the official troubleshooting order: confirm the file is in the correct subdirectory (checkpoints in models/checkpoints/, not the models root, and not loras) → press r to refresh node definitions → restart ComfyUI → confirm you're looking at the right loader node. If it still can't be found, check the extension: the supported list is .ckpt / .pt / .pt2 / .bin / .pth / .safetensors / .pkl / .sft. If none of that works, the model itself may not be recognized by the current version—the official reminder is to keep ComfyUI updated and first check the template library for a corresponding workflow; for more model errors (architecture mismatch, load failure), see model loading failures.

❌ .gguf files do nothing after being added ​

ComfyUI does not natively support GGUF—.gguf isn't in the extension list above. To use GGUF quantized models, first install the community nodes city96/ComfyUI-GGUF, then use the loader it provides. For when GGUF is worth using and how to configure it, see GGUF quantized models.

❌ extra_model_paths.yaml changes don't take effect ​

The three most common causes:

  • Wrong location: the file must be in the ComfyUI root directory (for the portable package, ComfyUI_windows_portable\ComfyUI\, not the outer folder)
  • No restart: the official docs explicitly require a restart for changes to take effect
  • Wrong filename: Windows Notepad easily saves it as extra_model_paths.yaml.txt—turn on "show file extensions" in File Explorer to check

If it won't start after editing the config and restarting, that's a startup problem—see what to do if installation fails.

❌ yaml indentation mixes in Tabs and the config can't be read ​

YAML syntax requires space indentation; the official example file uses 4 spaces throughout. Don't press the Tab key when editing in Notepad; type key names must be aligned under the config block name (like the example above). If you break it, copy .example again and start over.

Advanced tips (optional) ​

🔧 Change the model directory directly with launch arguments: You can also use launch arguments instead of editing the yaml. --models-directory <目录> points the whole model directory elsewhere; --base-directory <目录> is more thorough, moving models, custom_nodes, input, output, temp, and user all at once. Portable package users edit .bat and add the argument (create the target directory first):

bat
.\python_embeded\python.exe -s ComfyUI\main.py --models-directory D:\AIModels\models --windows-standalone-build
pause

🔧 Have ComfyUI read an extra config file: --extra-model-paths-config <路径> can load one or more yaml files in addition to extra_model_paths.yaml—for example, put shared configuration in a separate synced directory and mount it whenever needed.

🔧 Where the template library's automatic downloads are saved: When the template library automatically downloads a missing model, Desktop's Download button saves it directly into the corresponding subdirectory of ComfyUI/models/; the self-hosted version opened in a browser instead triggers a browser download, and you need to place the file into the directory manually. See Template Library for how to use the template library.

🔧 Deleting models: There is no "uninstall model" button in the interface—if you no longer want a model, just go to the corresponding subdirectory and delete the file.

🔧 The official name of the r key: This refresh shortcut corresponds to the setting Comfy.RefreshNodeDefinitions. For more keybindings, see Shortcuts & Interface Quick Reference.

Lesson Summary ​

✅ ComfyUI Where models go: by default <安装目录>/ComfyUI/models/, and for the portable package ComfyUI_windows_portable\ComfyUI\models\; Comfy Desktop lets you view and manage them in the capsule menu → Storage.

✅ Which model goes in which folder: checkpoint→checkpoints, LoRA→loras, VAE→vae, ControlNet→controlnet, diffusion models→diffusion_models, text encoders→text_encoders, upscalers→upscale_models; file extensions are limited to .ckpt / .pt / .pt2 / .bin / .pth / .safetensors / .pkl / .sft.

✅ Refresh after placing files: press r while running; if that doesn't work, restart, and only then will the models appear in the loader dropdown list.

✅ ComfyUI Model paths can be added: put extra_model_paths.yaml in the ComfyUI root directory, base_path + type key names; one type can mount multiple directories, and you must restart after changes; Desktop uses the Storage interface. This is the official ComfyUI shared-model solution.

Key configuration fields recap:

FieldSyntaxDescription
base_pathRoot of the model library (supports ~)Root of the config block; subpaths are resolved relative to it
checkpoints / loras / vae / controlnet…Subdirectories relative to base_path; multiple entries use `` multiple lines
is_defaulttrue (optional)Puts the path first and makes it the default download directory
custom_nodesExternal node directory (optional)Appends node search paths without changing the default install location
File locationComfyUI root directory (next to main.py)for the portable package it's ComfyUI_windows_portable\ComfyUI\
Takes effect whenrestart after saving ComfyUIofficially required

Next Lesson Preview ​

With the models in place, the next lesson produces your first image: First Generation: The Default Workflow Explained Node by Node.

You will learn:

  • What each of the 6 nodes in the default text-to-image workflow does (Load Checkpoint → Empty Latent Image → CLIP Text Encode → KSampler → VAE Decode → Save Image)
  • Where to write positive and negative prompts, and how to use (关键词:1.2) weight syntax
  • How to tune KSampler parameters like steps / cfg / denoise
  • Press Run (Ctrl+Enter) to generate and save your first image

Don't want to start with SD1.5 and prefer to jump straight into workflows for newer models like Z-Image-Turbo, Qwen-Image, or FLUX? Go to Models × Tasks Overview and pick a page to follow along.

gaodong.aiAboutPrivacyContact

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