DENO-owned nodes, docs, examples, workflows, and project-local assets in this repo are released under GNU GPL v3.0 (GPL-3.0-only). Commercial use is allowed, but distributed modified versions must follow GPL-3.0 and preserve the required license and copyright notices.

Third-party models, checkpoints, LoRAs, libraries, tools, and services keep their own licenses and terms. If a workflow uses a specific model or asset, check and follow that license before sharing or selling outputs.

Practical ComfyUI custom nodes focused on fast real-world workflow improvements. This repo is built for global creators and production workflows, with a focus on practical UX and reliable daily use.

Most Deno nodes include a small green i button in the top-right corner for quick node info without leaving the ComfyUI canvas. If a newer Deno Custom Nodes version is available, the button turns yellow and shows a small ! badge. The pack also includes lightweight frontend/browser helpers such as DENO Visual Fold, optional DENO Floating Tools for Free VRAM, ComfyUI Stable update checks, and GPT/Gemini-ready Error Help reports, the no-install Video Compare page, the Video to GIF/WebP converter page, and the 한국어 전용 디스코드용 영상 / 이미지 압축 page.

Release Notes

Public updates are tracked in CHANGELOG.md. GitHub Releases should use the same short format, with optional notes hidden in collapsible sections.

Web Tools

Run these directly in your browser:

DENO Video Compare - compare two rendered videos with slider, side-by-side, difference, and toggle views.
DENO Video to GIF/WebP - trim, crop, resize, and export short clips as GIF or smaller WebP files.
DENO 디스코드용 영상 / 이미지 압축 - 영상이나 이미지를 줄여 가능하면 10MB 이하 디스코드용 파일로 저장합니다.

DENO Visual Fold

DENO Visual Fold is a visual-only cleanup helper for large ComfyUI graphs. It is enabled automatically when the latest Deno Custom Nodes package is installed or updated.

Select two or more nodes and the native ComfyUI selection toolbar shows a readable green Fold badge. Click it to collapse the selected nodes into one compact visual group; use Unfold to restore them.

You can also select one normal ComfyUI group and use Fold Group to collapse the nodes inside that group while keeping the workflow logic untouched. When two or more groups are selected, the same toolbar adds readable Align badges for left/right/top/bottom alignment and horizontal/vertical spacing.

This is different from ComfyUI Subgraph. Subgraph moves nodes into a child graph, which can be powerful, but it may not be ideal when a workflow depends on keeping Get / Set nodes or parent-child graph structure visible in the main graph. Visual Fold is meant for simple visual organization only. It does not turn the selected nodes into a subgraph or change the workflow logic.

DENO Floating Tools

DENO Floating Tools is an optional helper under Settings > DENO > Tools. It is off by default.

When enabled, it adds a small draggable DENO icon to the ComfyUI screen. The panel can free ComfyUI VRAM through ComfyUI's built-in memory cleanup endpoint, show read-only current/latest status for the ComfyUI Stable core release, and open an Error Help report when a run fails.

Error Help creates a GPT/Gemini-ready report with the current workflow, Python executable and environment type, package versions, GPU details, recent traceback/log context, and custom node summary. It is read-only, opens a report window first, and copies only when you click Copy Report. Common secrets such as tokens, cookies, passwords, private keys, and URL credentials are masked before copy.

Floating Tools does not install, update, restart, repair, or modify workflows.

Included Nodes

`(Deno) Ideogram Director`

Visual Ideogram 4 prompt builder for structured JSON captions and bbox layout work.

Main features:

draw and edit bbox regions directly on the ComfyUI canvas
temporarily disable individual bbox elements without deleting or reordering them
double-click a bbox to edit beside the pointer, or repeatedly Alt+click an overlap to cycle through the boxes underneath
import JSON prompts from a Local LLM Loader or other STRING source
optionally connect Summary and Background STRING inputs to override those two board fields for a run; disconnected inputs continue to use the saved board text
ask before replacing an existing board, or switch to always replace
reject malformed JSON clearly instead of passing broken prompt text downstream
style and layout preset galleries with lightweight preview thumbnails
Language view for reading and editing board descriptions in your language while final output stays model-ready English. Literal TEXT box words such as signs, logos, and headlines are preserved exactly
outputs: prompt, width, height, seed, bboxes

`(Deno) Resize Box`

Resolution helper and image resize node for ComfyUI.

Deno Resize Box

Main features:

Preset Ratio and Manual Input modes
common ratio presets
megapixel-based size calculation
divisible_by alignment
Center Crop (Fill), aspect-locked zoomable Crop Position (Fill), and Fit (Letterbox/Pillarbox) resize modes
lanczos default interpolation
live ratio preview; Crop Position (Fill) shows the full connected source, lets you drag the crop box to reposition it, and lets you drag any corner to zoom while keeping the output ratio and megapixels fixed
outputs: image, width, height

`(Deno) Multi Image Loader`

Minor-upgrade multi-image loader designed for batch guide workflows.

Inspired by the original workflow ideas from WhatDreamsCost, then adapted and refined for the Deno workflow style.

Main features:

scrollable fixed-height gallery instead of endlessly growing node height
drag reorder with stable placeholder insertion
upload button, drag-and-drop upload, and paste image support
Input Folder browser for reusing existing ComfyUI input images
input subfolder browsing with folder tiles, double-click navigation, and a Parent button
nested input images can be added while preserving their ComfyUI subfolder paths
external symlinks or junctions that leave ComfyUI's input folder are skipped for security; use (Deno) Advanced Image Source Loader's External Folder mode for those sources
newest-first input image sorting based on file modified time
responsive input-folder thumbnails for smoother browsing with many images
Keep Input Ratio, Preset Ratio, or Manual Input size mode
ratio preset, megapixels, divisible-by sizing, or direct width/height control
resize method and interpolation selection
outputs: multi_output, width, height
optional crop or fit resizing during export

`(Deno) MiniMax H3 Multi Reference Image Loader`

One-cable reference-image loader for ComfyUI's native MiniMax H3 Reference to Video workflow.

Main features:

the same upload, paste, drag-and-drop, Input Folder, card reorder, and clear workflow as (Deno) Multi Image Loader
up to 9 ordered reference images through one dedicated socket
keeps each decoded image's own dimensions and aspect ratio without resize, crop, pad, or letterbox processing
displays each preview card at the source image's own aspect ratio, so mixed landscape and portrait references stay fully visible without preview cropping
card order maps directly to <Picture 1>, <Picture 2>, and so on
connects to the single ref_images input on (Deno) MiniMax H3 Reference to Video
also exposes the same ordered sources as an image_list output that connects directly to (Deno) Local LLM Loader's image input
the H3 node keeps ComfyUI's native reference-video, paired-video-audio, and standalone-audio Autogrow inputs

The dedicated H3 socket is intentional: a normal ComfyUI IMAGE batch requires one shared width and height, so it cannot preserve mixed reference sizes. The additional image_list is a list output rather than a same-size batch, so the original dimensions, order, and aspect ratios remain separate when reused by list-aware nodes. MiniMax H3 may still downscale references during its normal ref_image_size processing while preserving their aspect ratio.

These two MiniMax H3 nodes require ComfyUI 0.30.0 or newer. See the portable MiniMax H3 multi-reference workflow for the complete native H3 pipeline with the two stock Load Image nodes replaced by the one-cable DENO loader.

MiniMax H3 R2V Audio Reference workflow

The beginner audio-reference workflow keeps ComfyUI's stock MiniMax H3 reference-audio path and adds an automatic prompt-direction lane:

(Deno) Audio Transcript uses local OpenAI Whisper for lyrics or dialogue, segment timing, detected language, and a confidence summary. Optional user-entered lyrics remain the wording authority.
(Deno) Audio Analysis Finalizer keeps only the documented acoustic-analysis fields from ComfyUI's TextGenerate result and can unload that CLIP model after the analysis.
(Deno) Local LLM Loader receives the transcript and acoustic report through its optional audio_context STRING input. Raw AUDIO is not sent to the local LLM, and upstream analysis is treated as data rather than instructions.
The selected source-audio section is both H3's <Audio 1> reference and the audio muxed into the final MP4. H3's internally generated audio is not decoded in this workflow.

Requirements:

current ComfyUI Stable with MiniMax H3 and audio-capable TextGenerate support
ComfyUI-VideoHelperSuite for Load Audio (Upload)
gemma4_e4b_it_fp8_scaled.safetensors in ComfyUI/models/text_encoders/ for acoustic analysis
LM Studio with google/gemma-4-12b-qat loaded and its Local Server running for the final prompt-director step

openai-whisper is installed as a node dependency. The selected Whisper checkpoint downloads from OpenAI on the first (Deno) Audio Transcript run, is checksum-validated by the official Whisper loader, and is cached under ComfyUI/models/stt/whisper/.

`(Deno) Advanced Image Source Loader`

Advanced image source loader for workflows that need external folders, local file paths, web image URLs, and mixed-size image-list output.

This is a separate advanced node. The standard (Deno) Multi Image Loader remains the simpler recommended option for normal ComfyUI input folder workflows.

Main features:

keeps the familiar Deno image-loader gallery workflow
supports existing ComfyUI input folder browsing
supports external local folder paths outside the ComfyUI input folder
supports folder tiles, nested-folder browsing, and a Parent button
supports URL / Path input for web image URLs, absolute local image paths, and local folder paths
supports upload, drag-and-drop, paste, and browser folder upload where the browser allows it
includes a visible Paste button plus normal Ctrl+V image paste
click thumbnails to disable/enable sources without deleting them
disabled sources stay readable and remain saved with the workflow until re-enabled or removed
drag thumbnail cards to reorder output sequence
the gallery follows the node's available height in both the classic canvas and Nodes 2.0
thumbnails use a masonry-style flow so mixed portrait/landscape references are easier to scan
Load Path reads an external folder directly without first importing it into ComfyUI input
Upload Folder... is an optional browser upload/import helper, not required for external path loading
recursive_folders option for loading nested folder images
Keep Input Ratio, Preset Ratio, or Manual Input size mode
ratio preset, megapixels, divisible-by sizing, or direct width/height control
resize method and interpolation selection, including center, top, or bottom crop fill modes
optional images input can chain an upstream image batch/list into the same output stream
outputs a resized batch image tensor for normal batch workflows
outputs image_list for workflows that need per-image list handling
Original Size list mode can preserve mixed source resolutions in image_list
Match Batch Size list mode makes image_list match the resized batch dimensions
outputs: batch, image_list, width, height, image_count

`(Deno) Image Compare`

Visual A/B comparison node for quickly checking two images on the ComfyUI canvas.

Deno Image Compare

Main features:

compares image_a and image_b directly inside the node
modes: Slider, Side by Side, Difference, and Toggle
hover-move slider interaction for fast before/after inspection
visible A/B labels and a Swap button for checking either direction
resizes the internal preview area with the node so portrait and landscape images stay readable
visual-only node with no output connection, keeping the graph cleaner when the comparison is just for inspection

`(Deno) Video Compare`

Visual A/B comparison node for videos, built for checking upscale and FPS-interpolation results directly on the ComfyUI canvas. All compositing is pure tensor work — no external encoder. The in-node player draws a downscaled WebP frame sequence on a <canvas> on a virtual clock (so A/B stay frame-exact) and plays audio via WebAudio; the files are written to ComfyUI's temp dir and served by the existing /view route, then auto-cleared on restart.

Main features:

video_a / video_b (IMAGE batches) and optional audio_a / audio_b (AUDIO, e.g. from VHS Load Video)
modes: Slider, Side by Side, Difference, Toggle (freeze-frame A/B flip), plus Swap
hover-move slider, click = play/pause, scrub bar, frame step, speed, loop; hover the preview to hear the selected side
shared timeline: both sides play over the same duration, so an upscale (same frame count) stays frame-locked while an FPS-interpolation result (e.g. RIFE 24 to 48) just looks smoother at the same length
node resizes to the clip aspect; wheel and middle-drag are passed to the ComfyUI canvas
🏷 Output Badges toggle: optionally adds A/B + resolution badges to the saved output (off by default; the in-node preview always shows them)
comparison: full-resolution lossless IMAGE output of the chosen mode (Slider / Side by Side / Difference / Toggle), ready to wire into a save/encode node such as VHS Video Combine

Too heavy to run the node? Use the no-install browser tool: https://deno2026.github.io/comfyui-deno-custom-nodes/video-compare/ (also linked at the bottom of the node).

Deno Video Compare - Slider

Deno Video Compare - Side by Side

Deno Video Compare - Difference

`(Deno) Video Preview`

Drop-in, full-resolution preview for checking real encoded output at any point in a graph. It encodes the actual H.264 video at the original resolution in-process with PyAV (no external process is launched) using +faststart so the browser plays it inline reliably, then passes the images straight through — so you can insert it inline at multiple sampling points without branching the wire.

Main features:

images (IMAGE batch) in, images straight-through out, frame_rate, and an optional audio input that is muxed into the preview as AAC (tolerant of dict / object / (waveform, sr) AUDIO and [C,N] / [N,C] shapes; if audio can't be used it is logged and the video still previews)
clean auto-looping in-node player like the VHS preview: no control chrome, hover to hear audio, click = play/pause, a Full screen button, and the wheel is passed through to the ComfyUI canvas
a compact top-left info badge shows the current preview's resolution, FPS, frame count, and duration
the node fits the clip aspect and stays fitted as it is resized
each node reuses one temp file, overwritten every run, so heavy iteration never piles up temp storage
needs PyAV (pip install av); if it is missing the node shows a clear one-line install hint instead of failing the graph

Deno Video Preview

`(Deno) RTX Video Super Resolution`

Optional Windows/NVIDIA RTX Video Super Resolution helper node for users who want to try NVIDIA VFX inside ComfyUI without manually hunting for the right Python environment.

This node is intentionally separate from the core Deno nodes. It only imports NVIDIA VFX during upscale execution, so normal Deno node installs do not require NVIDIA VFX. ComfyUI Manager installs the node pack without auto-installing NVIDIA VFX.

Deno RTX Video Super Resolution

Beginner install flow:

Install or update deno-custom-nodes, then start ComfyUI.
Add (Deno) RTX Video Super Resolution and run it once with an image.
If NVIDIA VFX is missing, close every ComfyUI window/process.
Click the node's How to install button.
Follow the visual web install guide: download the ZIP from that page, move it into ComfyUI\custom_nodes\deno-custom-nodes\tools, extract it there, and run install_rtx_vfx.bat from the extracted installer files inside that tools folder.
If the BAT asks Install RTX VFX here?, type Y only when the shown Windows path is inside the ComfyUI app you just closed. If it looks wrong, type N and stop.
Wait for the green INSTALL COMPLETE message.
Restart ComfyUI completely, then use (Deno) RTX Video Super Resolution again.

For the full beginner-friendly visual walkthrough, open the DENO RTX VFX install page. If a tutorial video tells you to open the tools folder after installing from ComfyUI Manager, open tools/OPEN_INSTALL_GUIDE.txt; it points to the same current install page.

Official NVIDIA references:

Mode guide:

| If your image is... | Use | | --- | --- | | small, low-res, or compressed | VSR | | already clean, but needs a larger sharper output | High Bitrate | | noisy or grainy | Denoise | | soft, out of focus, or mildly blurred | Deblur |

Main features:

uses NVIDIA's official nvidia-vfx / nvvfx.VideoSuperRes package path
links from the node UI to NVIDIA's official Video Super Resolution documentation
shows a compact RTX panel with effect buttons, a separate quality selector, a mode-coach line, and only the resize controls that apply to the selected effect
single-pass and 2-pass RTX panels pass mouse-wheel scrolling through to the ComfyUI canvas, so normal canvas zoom still works while the pointer is over the node
installer targets the Python used by the current ComfyUI install
installer refuses to continue if ComfyUI is still running with that Python
installer asks before installing into the detected Python
installer stops if no NVIDIA GPU is detected unless the user explicitly overrides the check
installer reinstalls nvidia-vfx cleanly when the user confirms the target Python
installer first verifies the normal nvvfx package path used by the current ComfyUI Python
installer uses the ASCII Windows runtime fallback only when the normal nvvfx path fails verification
node startup prefers the recorded ASCII fallback path only when that fallback was actually selected
if another NVIDIA VFX native module is already loaded from a conflicting path, the node stops and asks for a full ComfyUI restart instead of trying to reload the native extension
installer verifies that NVIDIA's VideoSuperRes effect can actually be created after install
if NVIDIA VFX reports an unsupported runtime feature, the node shows a readable GPU/driver/runtime-path message instead of a raw stack trace
if NVIDIA Broadcast/NGX VFX DLLs from another RTX node are already loaded, the node reports that native runtime conflict separately from GPU/driver support
if another Broadcast-based RTX node works while DENO fails, treat it as a native runtime conflict, not proof that the DENO install is broken
keeps the installer BAT and ZIP on GitHub instead of inside the Manager package, while the node UI provides a How to install button that opens the visual web install page plus a Copy steps helper
keeps a small tools/OPEN_INSTALL_GUIDE.txt file in Manager installs so the tools folder still exists for users following older tutorial videos
exposes four clear effect buttons: Video SR, High Bitrate, Denoise, and Deblur
shows a compact mode coach line that explains the selected effect in plain language
keeps Low, Medium, High, and Ultra quality as a separate selector
for Video SR and High Bitrate, supports Scale, Keep Ratio, Manual, and Preset Ratio resize choices
Keep Ratio and Preset Ratio use target megapixels; Manual uses width and height
exposes divisible_by alignment for resizable modes, with 1 as the default so standard video sizes such as 1920x1080 stay exact
higher alignment values such as 32 remain available when a workflow specifically needs forced multiple-of-N output
shows Center Crop (Fill) / Fit (Letterbox/Pillarbox) when a manual, preset-ratio, or aligned keep-ratio resize can change aspect ratio
Denoise and Deblur keep the original size and hide resize controls, matching NVIDIA's same-size VSR modes
shows resize controls only when they apply to the selected effect
Easy Upscale outputs: images

`(Deno) RTX Video Super Resolution (2 Pass)`

Two-pass RTX finishing node for full video workflows. It can run an optional same-size Denoise or Deblur pass first, then an optional VSR or High Bitrate upscale pass.

Example workflow:

RTX 2-pass upscale workflow

Main features:

includes both Low System Memory and High System Memory lanes in the example workflow
the low-memory lane uses VHS Meta Batch so longer videos can be processed in smaller frame chunks
uses VHS_VideoInfoSource to carry the source FPS into VHS_VideoCombine
preserves source audio through the VHS load/combine path
useful when finishing actual encoded video outputs, not just testing a single image batch
outputs: images

`(Deno) LTX Sequencer`

LTX guide sequencer tuned for multi-image workflows.

Inspired by WhatDreamsCost's LTX workflow approach, with Deno-side adjustments focused on day-to-day usability.

Deno LTX Sequencer

Main features:

works with the batch output from (Deno) Multi Image Loader
auto-fills num_images from the connected loader when possible
keeps the existing sync-style workflow
allows only strength values to break out into manual control when needed
bypass switch passes positive, negative, and latent through unchanged for quick A/B tests

`(Deno) LTX Model Loader`

One compact loader for the common LTX 2.3 model-loading patterns.

Main features:

Checkpoint Style, KJ Style, and GGUF Style modes
outputs: model, clip, video_vae, audio_vae
uses ComfyUI's built-in checkpoint / diffusion / DualCLIP loading paths where possible
uses KJNodes VAELoaderKJ for split video/audio VAE workflows
uses ComfyUI-GGUF UNet loading for GGUF workflows
includes clearer dependency errors and an audio VAE compatibility fallback for mixed ComfyUI/KJNodes environments

`(Deno) LTX Tiled Spatial Upscaler`

Helper for high-resolution LTX video-latent second passes. It splits each frame into overlapping spatial tiles, runs the LTX latent spatial upscaler per tile, and blends the result back into one latent.

Use it on video-only LTX latents. If your workflow carries combined video/audio latents, separate the audio path first and rejoin it after the tiled video pass.

`(Deno) LTX High resolution Tiled Sampler`

Sampler for high-resolution LTX AV refinement passes. It keeps one global sampler trajectory while video predictions are evaluated through overlapping spatial tiles and fused before the sampler update.

The full audio latent is passed to every video tile as context, while the returned audio latent is kept unchanged in freeze mode.

`(Deno) Easy Model Download Helper`

Preset-based setup helper for recommended model file sets. The built-in presets cover the LTX 2.3 8GB VRAM GGUF starter set and the official LTX 2.5 Distilled INT8 two-stage model set.

Deno Easy Model Download Helper

Main features:

opens official model links in the browser instead of downloading files in Python
includes the LTX 2.5 diffusion model, projected Gemma 4 text encoder, video and audio VAEs, and x2 spatial upscaler required by the two-stage workflow
shows detected ComfyUI model roots and lets users copy the selected root
supports saved creator presets inside the workflow and restores them from browser storage after a page reload
supports Hugging Face direct links and Civitai page/download links without Python-side network requests
checks ComfyUI-registered model folders, including custom folder names from extra_model_paths
checks each preset's exact target path inside those registered model folders without scanning unrelated nested project folders
shows target ComfyUI model subfolders so viewers know exactly where files should go

The LTX 2.5 repository requires a Hugging Face account and Agree and Access before its files can be downloaded. The helper does not bypass that gate or download files automatically. Review the LTX-2 Community License, request access on the official LTX 2.5 repository, then use the helper's browser links and move each downloaded file into the displayed ComfyUI model folder.

Creator preset link guide:

Hugging Face: right-click the small download icon next to the target file, choose Copy link address, then paste that direct file URL into the preset URL field.
Civitai: copy the model page URL from the browser address bar, paste it into the preset URL field, then press the Civitai button in the editor to convert it to a direct browser download link. If the filename is not visible in the URL, enter the downloaded filename manually.
For Civitai pages, do not copy the blue Download button link unless you intentionally want to provide a direct API download URL.
File name is used only for the target-path check. It should match the downloaded file on disk, especially for Civitai/API links.

Hugging Face link guide

Civitai page URL guide

Civitai preset editor guide

`(Deno) LTX Multi LoRA Loader`

Power-LoRA-style multi LoRA loader for LTX workflows.

Main features:

add multiple LoRAs in one compact node
per-slot enable toggle
per-slot strength, video, and audio strength controls
per-slot trigger word and LoRA note editor
copy saved trigger words from the LoRA row
outputs patched model and clip
designed to stay close to the familiar Power LoRA Loader workflow while adding LTX-friendly A/V controls and lightweight LoRA reference notes

`(Deno) LTX Prompt Guide`

Prompt helper that combines LTX prompt encoding, optional negative prompt handling, built-in LTX conditioning, and dialogue-length planning.

Deno LTX Prompt Guide

Main features:

positive prompt text encoding
optional collapsible negative prompt
built-in LTX conditioning with frame_rate
estimates minimum video length from quoted dialogue
supports Auto, Korean, English, Japanese, and Chinese dialogue estimates
outputs: positive, negative, frame_rate

`(Deno) Bernini Prompt Guide`

KJ-style Bernini prompt helper that combines positive and negative prompt encoding into one beginner-friendly node.

Deno Bernini Prompt Guide

Main features:

System Prompt selector with readable modes such as Text to Video, Image to Video, and Reference Video Edit
shows the active system prompt prefix directly on the top of the node
writes prompts in instruction style, for example Replace the jacket with the shirt from image0. Keep the camera motion, background, lighting, and shadows unchanged.
reference modes automatically add a short image0, image1, image2 naming hint internally
collapsible negative prompt section
negative presets fill the visible negative prompt box; edit that box directly to change the final encoded negative prompt
outputs: positive, negative

Note: this node prepares text conditioning only. Bernini visual conditioning still requires a ComfyUI/KJ backend that supports Bernini context latents. While that backend support is still a draft ComfyUI PR, use tools/DENO_Bernini_Preview_Backend_Update.bat only on a copied/test portable ComfyUI folder.

`(Deno) Local LLM Loader` and `(Deno) Local LLM Reviewer`

Local LLM workflow helpers for calling models that are already running on your PC and using text reviews to control what gets saved.

Main features:

call local Ollama, LM Studio, llama.cpp, vLLM, Custom OpenAI-compatible, llama-swap, or Unsloth Studio models from ComfyUI
local-only server safety: use 127.0.0.1 or localhost
refresh provider-specific model lists from the node
stop a running local LLM request before unloading the model
use llama-swap's live running-state and management APIs for manual or post-run unload; any configured llama-swap server timeout still owns automatic unloading
use the Unsloth provider only with an Unsloth Studio server (default http://127.0.0.1:8888/v1); if an Unsloth GGUF is running inside LM Studio, select LM Studio instead
list Unsloth Studio models, send OpenAI-compatible chat requests without tool-definition or tool-choice fields, and use Unsloth Studio's management API for manual or post-run unload; Keep for minutes does not schedule a timed Unsloth unload
connect prompt batches through one node run so the local model can stay loaded until the batch finishes
optionally attach an IMAGE to a vision-capable local model call
preview Thinking and Result text directly on the node
embed the node's final Result in saved PNG/workflow metadata whenever the Local LLM node executes, so reopening the file restores it inside the node; Thinking/reasoning remains preview-only and is not persisted
keep named System Prompt presets in ComfyUI user data so they survive browser-profile cleanup; existing browser presets can be imported once while the browser copy stays untouched as a backup
see the actually applied System Prompt preset name on the node and in the editor; edited unmatched text is shown as Custom
connect a positive FLOAT to video seconds to append a sentence such as This is an 8-second video. to each LLM user prompt without changing the saved Prompt text
use (Deno) Local LLM Reviewer as a gate before Save nodes
pass or block IMAGE and AUDIO outputs from a review text result
approve the current reviewed result once, or rerun the path before the reviewer

The Unsloth provider requires an API key in the DENO_LOCAL_LLM_UNSLOTH_API_KEY environment variable. Set it before starting ComfyUI. The key is not stored in a workflow or PNG metadata.

LM Studio compatibility note: if LM Studio rejects its optional reasoning-control field before any generated output starts, the node retries once without that field. The selected server and model then decide their default reasoning behavior; the Thinking toggle cannot force a reasoning mode that the server does not expose.

Audio note: the Local LLM Loader does not send raw AUDIO into a local model. Its optional audio_context STRING input can carry an upstream transcript and acoustic report as data while preserving the user's prompt. The Reviewer can gate AUDIO when another text-generation node, including ComfyUI audio-capable text generation, creates the review text.

Why This Exists

These nodes are built to reduce repeated setup friction in actual ComfyUI production work. The goal is not to chase huge feature lists. The goal is to make the workflows people repeat every day feel faster, cleaner, and easier to teach.

Search Tips

Useful search terms for GitHub, ComfyUI Manager, and this README:

deno custom nodes
(deno)
comfyui custom nodes
ideogram
ideogram 4
ideogram director
json prompt
bbox
bounding boxes
layout prompt
rtx super
rtx video super resolution
rtx 2 pass
2 pass upscale
low ram workflow
meta batch
video super resolution
nvidia vfx
nvvfx
image compare
video compare
video preview
video to gif
gif webp
webp converter
video converter
ltx
ltx 2.3
ltx sequencer
ltx model loader
ltx tiled
ltx tiled sampler
ltx spatial upscaler
ltx multi lora
prompt guide
system prompt
local llm loader
local llm prompt
local llm reviewer
prompt only
final prompt
ai reviewer
media reviewer
audio review gate
ollama
lm studio
llama.cpp
vllm
llama-swap
unsloth
unsloth studio
bernini
bernini prompt guide
bernini conditioning
comfyui bernini
kj bernini
reference video edit
wan-2.2
wan2.2
multi image loader
advanced image source
external folder
resize
image resize
lora loader
gguf
visual fold
fold selected nodes
workflow tools
floating tools
free vram
comfyui stable
stable update check

Install

Clone inside your custom_nodes folder:

git clone https://github.com/Deno2026/comfyui-deno-custom-nodes.git
cd comfyui-deno-custom-nodes
python -m pip install -r requirements.txt

ComfyUI Manager/Registry installs requirements.txt automatically. For a manual clone, run the command above with the same Python executable that starts ComfyUI, then restart ComfyUI.

Deno Custom Nodes

Nodes (21)