NodeWise Studio
RUDownload for Linux

Glossary

The words of ComfyUI and of the app, in short. Help ▸ Glossary opens this page. The first list is the app's own glossary: lesson steps and the tour of the window underline the first mention of these words with dots and show the same sentence on hover or Tab. A linked word leads to the page that explains it. In brackets: the word the ComfyUI community uses in English, the one to search for.

The glossary of the app

  • API format: A form of workflow file for programs, without positions and notes; ComfyUI saves it with "Export (API)".
  • assistant: The part of this app that answers questions about the graph and can propose changes.
  • batch: Several pictures made or passed at once; it multiplies the memory a run needs.
  • block swap: Keeping some blocks of a model in ordinary memory and bringing each to the card for its turn.
  • bypass: Skipping a node so that its inputs pass straight through (Ctrl+B in ComfyUI, Ctrl+Shift+B here; the node turns purple).
  • canvas: The surface where the nodes of a graph stand.
  • CFG: How strictly the model follows the prompt.
  • checkpoint: One file with a whole model: the part that draws, the text encoder and the VAE.
  • CLIP: A family of text encoders (and of picture encoders, CLIP Vision); in ComfyUI the CLIP link carries any text encoder.
  • CLIP Vision: An encoder that reads a picture for IP-Adapter, Redux or image to video.
  • ComfyUI: The program that runs AI models as a graph of nodes; this app prepares graphs for it.
  • ComfyUI Manager: The part of ComfyUI that installs and updates node packs.
  • conditioning: The encoded prompt that the sampler follows.
  • ControlNet: A model that makes a picture follow a pose, edges or depth from a guide image.
  • credits: The prepaid units of a Comfy account that partner nodes spend.
  • data type: What a link carries (MODEL, CLIP, LATENT, IMAGE…); an output connects only to an input of the same type.
  • denoise: How much of the starting latent is replaced with noise: 1 from scratch, less to keep part of a picture.
  • diffusion model (also: diffusion model (UNet)): Only the part that draws, loaded with Load Diffusion Model; also called the UNet.
  • distilled model (also: distilled / turbo / lightning): A model or LoRA trained to work in a few steps (turbo, lightning, lightx2v), usually with cfg 1.
  • embedding (also: embedding (textual inversion)): A tiny file that adds a word to the text encoder (textual inversion).
  • empty latent: The blank of noise of a set size that text to image starts from.
  • family (also: base model (architecture)): The base model a file belongs to (SDXL, Flux, Wan…); parts of different families do not mix.
  • field (also: widget (field)): A setting on a node, such as a number, a text or a file choice.
  • fine-tune (also: fine-tune (merge)): A model trained further from a base model for a style or a subject; it keeps the family.
  • fp8: An 8-bit format that halves the memory of a 16-bit model at a small loss.
  • fps: Frames per second: how fast the frames of a clip follow each other.
  • frame: One picture of a video.
  • GGUF: A file format of quantised models (Q8, Q5, Q4…), read in ComfyUI by the ComfyUI-GGUF pack.
  • graph: Nodes and the links between them: the recipe of a picture, a video or a sound.
  • graph version: A saved state of the graph in this app's history, to go back to.
  • grey drafts: Changes the assistant proposes, shown in grey on the canvas until you accept them.
  • group: A coloured frame with a title around nodes; it only organises the canvas.
  • hires fix: A second pass that enlarges a picture and redraws it with a low denoise.
  • image to image (also: image to image (i2i)): Redrawing an existing picture with a denoise below 1.
  • image to video (also: image to video (i2v)): A clip that starts from a given picture.
  • inpainting: Redrawing only a masked part of a picture.
  • input (also: input (socket, slot)): A dot on the left of a node where a link brings data in.
  • input folder: The folder ComfyUI/input where pictures, videos and sounds you load are kept.
  • IP-Adapter: An add-on that carries the look or the face of a reference picture into a new one.
  • language model (also: LLM (language model)): A model that reads and writes text; in a graph it can write or improve a prompt.
  • latent: The compressed form of a picture or a clip that the model works in.
  • link (also: link (wire, noodle)): A line from an output of one node to an input of another that carries data.
  • LoRA: A small add-on trained on top of a base model for a style, a character or a speed-up.
  • mask: A black and white picture that says which part to change.
  • MCP server: An optional program next to ComfyUI that lets this app read more of it; a plain ComfyUI address is enough.
  • model: A trained network in a file that draws, reads text or does another task.
  • models folder: ComfyUI/models, with one sub-folder per kind of model file.
  • mute: Switching a node off so that it and what depends only on it do not run (Ctrl+M, grey).
  • negative prompt: The text of what must not be in the result.
  • node: One block of a graph that does one thing: loads a model, encodes a prompt, saves a picture.
  • node pack (also: custom nodes (node pack)): A folder in custom_nodes that adds nodes to ComfyUI; it runs its author's code.
  • note: Text on the canvas that never runs; authors put instructions and model files there.
  • offloading: Keeping parts of the work in ordinary memory and moving them to the card when needed.
  • out of memory (also: OOM (out of memory)): The error when the graphics card has no room left for a step.
  • outpainting: Extending a picture beyond its edges.
  • output: A dot on the right of a node where its result goes out.
  • output folder: The folder ComfyUI/output where the save nodes write files.
  • output node: A node that shows or saves a result; only the part of a graph that leads to one runs.
  • partner nodes (also: partner nodes (API nodes)): Nodes that run commercial models in the cloud for money; the inputs are sent to that service.
  • pickle file (also: pickle (.ckpt, .pt, .pth, .bin)): An old model format (.ckpt, .pt, .pth, .bin) that can run code when loaded.
  • precision (also: precision (fp32, fp16, bf16)): How many bits each number of a model has: fp32, fp16, bf16; fewer bits, a smaller file.
  • primitive: A node that holds one value and passes it to fields of other nodes.
  • prompt: The text that tells the model what to make.
  • prompt weight (also: prompt weighting): More or less pull for words, written (words:1.2).
  • quantization: Storing a model with fewer bits per number to make it smaller.
  • queue: The list of graphs ComfyUI will run one after another.
  • reroute: A dot on a link that only passes data on, to route long links.
  • Run (also: Run (Queue Prompt)): The ComfyUI button (Ctrl+Enter) that puts the graph into the queue; older versions call it Queue Prompt.
  • safetensors: The safe model format: it holds only numbers and cannot run code.
  • sampler (also: sampler (KSampler)): The node (KSampler) that removes noise step by step and makes the picture.
  • sampler method (also: sampler (sampler_name)): The method of removing noise chosen in sampler_name: euler, dpmpp_2m and others.
  • scheduler: How the noise is spread over the steps: karras, normal, simple, beta.
  • seed: The number the starting noise is made from; the same seed repeats the result.
  • Set / Get (also: Set / Get nodes): Nodes of a pack that pass a value by name without a visible link.
  • shift: A setting of flow models that moves the steps toward composition or toward detail.
  • steps: How many times the sampler removes a share of the noise.
  • subgraph: A node that holds a whole graph inside.
  • switch: A node that passes one of two inputs, chosen by a yes/no value.
  • sync: This app reading the nodes and models of your ComfyUI anew ("Sync now").
  • T5: A large text encoder that understands sentences, used by Flux.1, SD3 and (as UMT5) by Wan.
  • template (also: workflow template): A ready workflow that ComfyUI offers in its template browser, with notes about the files it needs.
  • text encoder: The model that turns a prompt into conditioning; CLIP, T5 or a language model.
  • text to image (also: text to image (t2i)): Making a picture from a prompt alone.
  • text to video (also: text to video (t2v)): A clip made from a prompt alone.
  • tiling (also: tiled VAE (tiling)): Working on a picture piece by piece to need less memory, as the tiled VAE does.
  • trigger word: A word a LoRA was trained with that switches it on in the prompt.
  • upscale: Making a picture larger, by a resize, an upscale model or a second pass.
  • upscale model: A small model (ESRGAN and kin) that enlarges a finished picture in pixels.
  • VAE: The model that turns a latent into pixels and back.
  • VRAM: The memory of the graphics card, where models and the working data of a run must fit.
  • workflow: A graph saved as a .json file that ComfyUI opens and runs.
  • workflow in a picture (also: workflow metadata (workflow in PNG)): The workflow ComfyUI writes into every picture it saves; dropping the picture back restores the graph.

More words of the app

  • Ask, Build, Learn: the three modes of the assistant panel. Ask answers and suggests grey drafts; Build changes the graph; Learn opens the lessons. Ask, Build, Learn
  • Catalog: what the app read from your ComfyUI: node types, node packs and model files. Reading ComfyUI
  • Check: Graph ▸ Check graph; finds missing nodes and models, wrong links and empty fields before you save. Checking a graph
  • Choose the assistant: who answers for the assistant: a cloud service or your own server. Choosing who answers
  • Context window: how much text a model can read at once, counted in tokens. The context window
  • Conversation log: the record of what was sent to the model and what came back. The conversation log
  • Description card: the short card under a node that says what it is and why it is there. Description cards
  • Example: File ▸ Examples; the finished graph of a lesson, made of the nodes and model files you have.
  • Explanation: the text that tells what a node, a link or the graph does, with its source (built in, from the model, from the web, yours). The explanations tab
  • Lesson: a task you do by hand on the real canvas, step by step, checked by the app. How lessons work
  • Library: the left panel with your nodes, models and subgraphs. The library
  • My lessons: the lessons you made, imported or kept from the assistant. My lessons
  • Pause point: the assistant stops after the number of steps set in Settings ▸ Assistant and asks whether to go on. Not to be confused with a checkpoint model file. Pause and stop
  • Project file: a file with the graph and everything the app knows about it (*.nodewise.json). Project files
  • Step: one action of the assistant: reading the catalog, adding a node, drawing a link.
  • Token: a piece of a word, the unit models count text in. Also the access token a server asks for: a password for programs.
  • Tour: Graph ▸ Guided tour walks through the graph node by node; Help ▸ Tour of the window shows the parts of the window. The tour of a graph

See also

This page is imported from the application repository's wiki (docs/wiki/reference/Glossary.md, revision b8e3f71). The same guide is built into the app: Help ▸ User guide.

To refresh it, run npm run import and then npm run build in the website folder.