OmniNodes

OmniNodes — ComfyUI Custom Node Pack

By TensorVizion · 130 node files across 10 categories · Verified against the actual pack contents on 2026-09-05.

A production-grade ComfyUI custom node pack covering audio processing, image post-processing, latent space manipulation, model utilities, GGUF quantized model loading, prompt/wildcard tooling, sampling primitives, video processing, web API integration, and workflow control.

Most of the pack (Audio/Image/Latent/Model/Prompt/Sampling/Video/Workflow) is built on PyTorch, NumPy, and Pillow — all bundled with any ComfyUI install, so no extra pip install is needed for those eight categories. The Web API and GGUF categories are the exceptions: Web API's HTTP-dependent nodes need requests, and all six GGUF Nodes need the gguf package (see Requirements).

---

Installation

# Option A — Git clone (recommended)
cd ComfyUI/custom_nodes/
git clone https://github.com/TensorVizion/OmniNodes

# Option B — Manual
# Download the zip, extract, and place the OmniNodes/ folder into:
# ComfyUI/custom_nodes/OmniNodes/

If you plan to use the Web API or GGUF categories, also install their external dependencies:

cd ComfyUI/custom_nodes/OmniNodes/
pip install -r requirements.txt

# Or install just the GGUF dependency on its own:
pip install gguf

Restart ComfyUI after installing. The loader (__init__.py) recursively scans every .py file in the pack — nodes don't need to follow a specific filename pattern to be picked up, but each file must define its own NODE_CLASS_MAPPINGS dict or it will be silently skipped.

Nodes appear in the node search menu under ten sub-groups: Audio, Image, Latent, Model Utilities/Model, GGUF, Prompt, Sampling, Video, Web API, and Workflow — see Known Quirks for why Model and Sampling nodes are split the way they are.

---

Node Reference

🎵 Audio Nodes — TensorVizion/Audio (12 nodes)

| Node | Summary | |------|---------| | Audio Beat Detect 🥁 | Energy-based onset detection; returns beat timestamps, count, and estimated BPM. | | Audio Loudness Match 🎚️ | Matches one audio clip's perceived loudness to a reference clip — the audio equivalent of Video Color Match. Differs from Audio Normalize by targeting another clip's actual level rather than a fixed dBFS number. | | Audio Mixer 🎚️ | 4-channel stereo mixer with per-track gain, pan, and mute. | | Audio Normalize 🔊 | Peak or RMS normalization to a target dBFS level, with DC-offset removal and soft-clip. | | Audio Pitch Shift 🎼 | Phase-vocoder pitch shift, ±24 semitones, pure NumPy. | | Audio Reverb 🏛️ | Algorithmic (Schroeder comb + allpass) or convolution (synthetic IR) reverb. | | Audio Sidechain Duck 🦆 | Ducks one audio signal's level based on another's envelope (classic sidechain compression). | | Audio Spectrogram 🎛️ | Renders an STFT spectrogram as an IMAGE, with linear/log-power scaling and 4 colormaps. | | Audio Stem Splitter (Freq Band) 🍰 | Frequency-band splitter into bass/mid/high stems (not source-separation ML). | | Audio-to-Latent Modulator 🎧 | Converts an audio envelope into a per-frame FLOAT curve and a scaled LATENT for audio-reactive generation. | | Audio Transient Shaper 🥊 | Boosts or reduces the attack/sustain portions of a signal. | | Audio Waveform 🎵 | Renders a waveform visualization as an IMAGE. |

🖼️ Image Nodes — TensorVizion/Image (18 nodes)

| Node | Summary | |------|---------| | Apply Upscale Model 🔭 (new) | Runs an UPSCALE_MODEL (loaded by Upscale Model Loader) over an image, with an optional post-resize to a target long-edge size. Closes the gap between loading an upscale model and actually using it — previously the pack had no node to run one. | | Quick Save Image 💾 (new) | Saves a single image into ComfyUI's own managed output tree (gallery-visible immediately, standard prefix_00001_ naming) with seed/model/notes embedded as PNG text chunks. Different from Metadata Embed and Custom Folder Batch Saver, both of which save outside the managed output tree. | | 3D LUT Apply 🎞️ | Loads a standard Adobe/IRIDAS .cube 3D LUT file and applies it via trilinear interpolation, with an adjustable strength blend. | | Contact Sheet Maker 🗺️ | Tiles a batch of images into an unlabeled thumbnail grid for browsing. | | Custom Folder Batch Saver 📁 | Saves a batch to an arbitrary directory (not ComfyUI's managed output root) with persistent zero-padded numbering. | | Aspect Ratio Bucket 📐 | Snaps an image to the nearest standard SD/SDXL aspect-ratio training bucket. | | Image Blend 🖌️ | Blends two images with selectable blend modes, ratio, strength, and optional mask. | | Image Color Grade 🎨 | Exposure/contrast/saturation/gamma/lift/gain/temperature/tint grading. | | Image Grid Compare 🆚 | Labeled side-by-side comparison grid — one text label per cell, plus an optional highlight border. Genuinely different from Contact Sheet Maker: this is built for labeled comparison (sampler/strength/seed sweeps), not just browsing a batch. | | Face Detect & Crop 🙂 | Detects faces and returns cropped outputs plus a detection mask. | | Image Mask Composite 🖼️ | Draws shape/effect masks (darken, brighten, blur, color) directly onto an image. | | Image Noise Inject 🎞️ | Adds film-grain-style noise with selectable blend mode and monochrome option. | | Image Sharpen & Blur 🔎 | Unsharp-mask sharpening or Gaussian blur in one node. | | Image Vignette & Glow ✨ | Vignette darkening plus a bloom/glow effect on bright regions. | | Load Image + Recovered Metadata 🔍 (new) | A LoadImage-equivalent (delegates actual pixel/mask decoding to core LoadImage) that ALSO recovers embedded generation parameters — seed, prompt, steps, cfg, sampler, checkpoint — from A1111/Forge-style PNG text chunks or ComfyUI's own embedded workflow JSON, exposed as individually-wireable outputs rather than a text dump. See details below. | | Mask Morphology 🩹 | Grow, shrink, feather, or invert a MASK. | | Resize to Multiple 📏 | Pads, crops, or stretches an image to the nearest multiple of N (8 by default, for SD/SDXL VAE compatibility). | | Text Overlay ✏️ | Draws text onto an image with font/size/color/anchor-position/stroke/background-box controls. |

Load Image + Recovered Metadata details

Drag in any finished PNG — your own past output, or a shared render — and if it has embedded generation data, this node hands back a real seed INT you can wire into Seed Stepper, a real positive_prompt STRING you can wire into CLIPTextEncode, and the sampler/steps/cfg/checkpoint it was made with, instead of a paragraph of text you'd read and retype by hand. source selects auto (tries ComfyUI's embedded workflow JSON first, falls back to A1111-style text), comfyui, or a1111 explicitly. If no embedded metadata exists (a photo, a hand-drawn image, an unsupported tool's output), metadata_found is False and the text/numeric outputs return empty/zero defaults — the image still loads normally either way. For ComfyUI-format graphs with multiple CLIPTextEncode nodes, the longest text is guessed as positive and the shortest as negative — a heuristic, not a guarantee, for workflows that don't follow a simple single-KSampler structure. Different KSampler-family core nodes use different seed parameter names (KSampler uses seed, KSamplerAdvanced uses noise_seed) — both are checked.

🌀 Latent Nodes — TensorVizion/Latent (12 nodes)

| Node | Summary | |------|---------| | Latent Anomaly Mask 🚩 | Flags statistically anomalous latent regions and outputs a corrected latent + mask. | | Latent Blend 🌀 | Blends two latents by weighted average. | | Latent Channel Mixer 🎚️ | Mixes/reweights latent channels, analogous to Image Channel Mixer. | | Latent Histogram 📊 | Renders a per-channel value-distribution histogram as an image, plus an outlier-percentage stat. A different diagnostic from Latent Visualizer's point statistics — shows distribution SHAPE (bimodal/heavy-tailed patterns point stats can hide). | | Latent Interpolate 🌉 | Walks between two latents (spherical/linear interpolation). | | Latent Mask 🎭 | Generates rectangle/ellipse/gradient masks directly in latent space. | | Latent Noise Inject 🌊 | Adds controlled noise directly to a latent tensor. | | Latent Palette Extractor 🧬 | Extracts a signature/fingerprint summary from a latent for comparison. | | Latent QC Gate 🚧 | Automated PASS/FAIL sanity check on a sampled latent — NaN/Inf, near-blank (suspiciously flat) output, and outlier saturation (via median/MAD, robust to large-fraction contamination unlike a naive mean/std check) — with an optional fallback latent on failure. Nothing else in the pack checks a LATENT tensor itself before it reaches VAEDecode/Save; Try/Catch (Workflow Nodes) only covers STRING/scalar values. | | MiniMax H3 AV QC Gate 🚧 (new) | The Latent QC Gate concept, but for MiniMax H3's genuinely different joint video+audio latent shape (a comfy.nested_tensor.NestedTensor wrapping separate [B,24,T,H//16,W//16] video and [B,32,2,T] audio tensors, confirmed from ComfyUI core's real EmptyMiniMaxH3LatentAV source) — checks each modality independently, since a broken audio branch and a broken video branch are unrelated failures. A normal LATENT QC check cannot handle this shape at all. | | Latent Structure Probe 📡 | Renders a heatmap of latent activation structure. | | Latent Visualizer 🔬 | Renders a human-viewable preview image of raw latent channels, plus stats. |

🧰 Model Nodes — TensorVizion/Model Utilities and TensorVizion/Model (33 nodes)

| Node | Summary | |------|---------| | ControlNet Apply (Advanced) 🕹️ (new) | Applies a loaded ControlNet + control image to positive/negative conditioning, with strength and start/end-percent windowing. Was the one missing step between ControlNet Loader / ControlNet Preprocessor and sampling — previously required dropping back to a stock node. | | Universal Checkpoint Loader 🌐 (new) | Model-family-agnostic MODEL/CLIP/VAE loader (SD1.5/SD2.x/SDXL/SD3/Flux), with a filename-based family guess in its summary output as a sanity check before wiring into family-specific sampling. Complements Simple SDXL Loader, which is SDXL-only. | | Image Prompt Loader 🖼️ (new) | Loads a CLIP vision encoder + style model pair in one node, for image-conditioned ("style transfer from a reference image") workflows — a conditioning path the pack had none of before. Pairs with Image Prompt Apply. | | Image Prompt Apply 🖼️ (new) | Encodes a reference image and applies it through a style model onto conditioning, at an adjustable strength. | | Simple SDXL Loader 📀 | One-node MODEL/CLIP/VAE loader for SDXL checkpoints. | | Batch Folder Loader 📂 | Loads a checkpoint by name from a subfolder under ComfyUI's registered checkpoint roots. | | CLIP Text Compare 🔍 | Encodes two prompts and reports a similarity score between their conditioning. | | CLIP Text Weight ⚖️ | Applies a scalar weight multiplier to CLIP conditioning. | | ControlNet Loader 🕹️ | Loads a ControlNet model with a summary output. | | ControlNet Preprocessor 🕹️ | Converts an IMAGE into ControlNet conditioning (canny edges, a lightweight depth estimate, or lineart) without needing a separate ControlNet-aux install. | | DoRA Loader (Custom) 🎯 | Real magnitude/direction-decomposition DoRA merge engine — computes W' = m·(W₀+BA)/‖W₀+BA‖_c directly rather than treating DoRA as a scaled LoRA. See Known Quirks for real limitations. | | Dual Model Merger 🔀 | Merges two MODELs by weighted sum. | | Krea 2 Guidance Helper 🎚️ (new) | Calculator/sanity-check for Krea 2's confirmed real guidance formula (cond + guidance_scale*(cond-uncond)). Recommends the right default per variant (1.0 Turbo / 4.5 Raw) or flags a manual value that's far off-spec, with a rough "how much is guidance actually doing" preview percentage. | | Krea 2 Variant Validator ✅ (new) | Catches the single most consequential Krea 2 misconfiguration: applying Raw-variant settings (28 steps, cfg 4.5, negative prompt) to a loaded Turbo checkpoint, or vice versa — both loading paths look identical in the graph, so nothing else stops this mistake, which produces a technically-running but badly wrong result rather than an error. | | LoHa Loader (Custom) 🌀 | Real Hadamard-product LoHa merge engine — ΔW = (W1a@W1b) ⊙ (W2a@W2b), applied via ComfyUI's add_patches API. | | LoKr Loader (Custom) 🧩 | Real Kronecker-product LoKr merge engine — ΔW = W1 ⊗ W2, supporting both fully-dense and factored (low-rank) forms of either factor. | | LoRA Info Inspector 🔬 | Reports rank, alpha, and target modules of a LoRA file without loading it into a pipeline. | | LoRA Stack 🗂️ | Chains multiple LoRAs onto a MODEL/CLIP pair in one node. | | LyCORIS Format Inspector 🔬 | Reads a LoRA-family file's actual tensor key names to identify whether it's really LoRA, LoHa, LoKr, or DoRA-tagged — run this before any of the three loaders above, since misidentifying the format means applying the wrong math entirely. | | Metadata Embed 🏷️ | Embeds custom metadata into a saved file. | | Metadata Reader 🔖 | Reads embedded metadata back out as raw text and parsed JSON. | | Model Block Freeze 🧊 | Freezes specific U-Net blocks (for partial fine-tuning workflows). | | Model Info Inspector 🔬 | Reports key count, architecture guess, and precision of a loaded MODEL. | | LoRA Metadata Diff 🆚 | Compares two LoRA files' metadata and reports structural compatibility. | | Model Merge Weighted 🔀 | Weighted merge of two models with a single output. | | Multi-LoRA Weight Sweep 📶 | Applies one LoRA at a range of strengths, outputting a real ComfyUI list so downstream nodes (KSampler, etc.) automatically run once per strength value — no manual duplication of your sampler chain. Pairs with Image Grid Compare. | | Quick LoRA Stacker ⚡ | Lighter/faster variant of LoRA Stack for simple single-LoRA cases. | | Smart Unloader 🧹 | Frees VRAM by unloading models and running garbage collection; passes any type through unchanged. | | Trigger Word Extractor 🏹 | Pulls a LoRA's trigger word out of a prompt and returns the cleaned remainder. | | Upscale Model Loader 🔭 | Loads an upscale model (ESRGAN-family, etc.) with a summary output. | | VAE Loader 🗝️ | Loads a VAE with a summary output. | | VRAM / Model Size Estimator 📐 | Estimates VRAM footprint for a checkpoint + up to 4 LoRAs, reading file headers only (no full load). Reports inference AND full-fine-tune estimates — a floor estimate, not a guarantee. |

DoRA / LyCORIS node details

LyCORIS Format Inspector — Reads only the safetensors header (tensor names/shapes), never the weight data, so it's fast even on large files. Detects format from real key-naming conventions: LoRA/LoCon (lora_down.weight/lora_up.weight/alpha), LoHa (hada_w1_a/hada_w1_b/ hada_w2_a/hada_w2_b), LoKr (lokr_w1/lokr_w2, or their factored _a/_b variants), and a DoRA marker (dora_scale) that can appear alongside any of the above. Reports detected_format="mixed" with a warning if a file contains more than one format's keys — unusual, but not impossible for a hand-merged file.

LoHa Loader / LoKr Loader / DoRA Loader (Custom) — All three compute their weight delta directly from the real published formulas (Hadamard product, Kronecker product, and magnitude/direction decomposition respectively — see each node's module docstring for the exact math and citations) and apply it via ComfyUI's own ModelPatcher.add_patches() API, never by editing a state_dict directly. This matters because ComfyUI's built-in LyCORIS auto-detection has a documented, open issue (ComfyUI #8683) where LoHa/LoKr files can be silently mis-routed through the plain-LoRA merge path, producing a technically-running but mathematically wrong result. Loading explicitly through these nodes — after confirming the format with LyCORIS Format Inspector — avoids depending on that auto-detection succeeding. Conv2d (4D) weight support is NOT implemented in any of the three loaders (Linear/2D layers only) — see Known Quirks.

Multi-LoRA Weight Sweep — Uses OUTPUT_IS_LIST = (True, True, True), ComfyUI's real "List processing" mechanism (new to this pack — no other node uses it) — connecting the model/clip outputs into a downstream KSampler causes ComfyUI to run that KSampler once per strength value automatically. Wire the labels output into Image Grid Compare's labels input for an automatically-labeled comparison grid across the whole sweep.

🧬 GGUF Nodes — TensorVizion/GGUF (6 nodes) (new)

Requires the external gguf package — see Requirements. All six nodes are read/write tools around the GGUF quantized-model file format (the same format used by llama.cpp), for opening pre-quantized .gguf diffusion/CLIP/VAE checkpoints and for making your own.

| Node | Summary | |------|---------| | GGUF File Info 🔍 | Read-only inspector: architecture/name metadata plus a per-tensor quantization-type breakdown (real mixed-precision mix, not just a filename guess). Run this first on any downloaded .gguf file. | | GGUF Diffusion Model Loader 🧠 | Loads a quantized UNet/diffusion-model .gguf file, dequantizing every tensor to fp16/fp32 and handing the result to ComfyUI's own diffusion-model-loading path — output is a normal MODEL. | | GGUF CLIP Loader 📝 | Loads one or two quantized text-encoder .gguf files (CLIP-L/CLIP-G/T5-XXL) into a normal CLIP, mirroring core CLIPLoader/DualCLIPLoader's clip_type selector. | | GGUF VAE Loader 🗝️ | Loads a quantized VAE .gguf file into a normal VAE. Included for symmetry — GGUF VAEs are uncommon in the wild since VAE weights are already small. | | GGUF Checkpoint Converter 🔄 | The write-side counterpart to the three loaders above: quantizes any checkpoint ComfyUI can load into a new .gguf file (Q4_0 through Q8_0, or plain F16/F32), via the real gguf package's own GGML block-quantization code — not a custom scheme only this pack understands. | | GGUF Quant Validator ✅ | Spot-dequantizes a sample of tensors from a .gguf file and flags NaN/Inf, all-zero, or zero-element tensors — a fast sanity check for a truncated download or bad conversion before it fails confusingly three nodes downstream. |

GGUF node details

All three loaders (Diffusion Model / CLIP / VAE) work the same way under the hood: they fully dequantize every tensor to fp16 (or fp32) at load time, then hand a plain state dict to ComfyUI's own core loading functions. That means the resulting MODEL/CLIP/VAE behaves identically to one loaded from safetensors — but it also means loading one of these files uses the full fp16/fp32 VRAM/RAM footprint, not the reduced footprint a dedicated quantized-inference extension (like the community ComfyUI-GGUF extension, which keeps weights quantized on the GPU via custom ops) provides. Use these nodes when you want to open a .gguf file without installing that extension and don't need its memory savings; reach for that extension instead when VRAM headroom is the actual point of using GGUF for you.

GGUF Checkpoint Converter's block-quant types (Q4_0/Q4_1/Q5_0/Q5_1/ Q8_0) require each tensor's last dimension to be divisible by 32. Tensors that don't satisfy this (commonly small 1-D bias/norm vectors) are automatically kept at F16 instead of being dropped, so the output file is always complete — the fallback count is reported in report. K-quants (Q4_K etc.) are intentionally not offered here, since a faithful K-quant conversion needs an importance-matrix-aware pipeline that a single generic tensor-by-tensor pass can't do properly.

🎲 Prompt Nodes — TensorVizion/Prompt (13 nodes)

| Node | Summary | |------|---------| | CLIP Skip ✂️ (new) | Stops CLIP text-encoding early at N layers from the end — the standard "clip skip" option many SD1.5-era/anime checkpoints expect, and a basic utility the pack was missing entirely. | | Conditioning Composer 🧩 (new) | One node covering combine / concat / set_area modes for merging two conditionings — regional and multi-concept prompting without needing three separate stock nodes. | | CLIP Text Encode (Simple) ✍️ | Minimal CLIP text encode with a summary output, as a lighter alternative to core CLIPTextEncode. | | Embedding Helper 🧷 | Helps format/insert textual-inversion embedding tokens into a prompt. | | Negative Prompt Presets 🚫 | Dropdown-selectable common negative-prompt blocks. | | Prompt Cleaner 🧹 | Strips duplicate tags, extra whitespace, and malformed weighting syntax from a prompt. | | Prompt Combiner ➕ | Joins multiple prompt fragments into one string with configurable separators. | | Prompt Random Line 🎯 | Picks a random line from a multi-line text block, seeded. | | Prompt Token Counter 🔢 | Counts CLIP tokens in a prompt and warns if it will be truncated. | | Prompt Weight Scheduler ⏳ | Produces a prompt fragment with a scheduled/varying attention weight. | | Wildcard List Inspector 📋 | Lists available wildcard files and their line counts. | | Wildcard Loader 🎲 | Loads and resolves __wildcard__ syntax from text files, seeded. | | Wildcard Prompt Builder 🧩 | Assembles a full prompt from multiple wildcard categories in one node. |

🌡️ Sampling Nodes — TensorVizion/Model Utilities and TensorVizion/Sampling (10 nodes)

| Node | Summary | |------|---------| | Detailer (Crop-Inpaint-Paste) 🔎 (new) | Full region-fix loop: crops a masked region (e.g. from Face Detect & Crop) to its bounding box, upscales it for a full-resolution sampling pass, re-samples with fresh conditioning, then feather-pastes the result back. The pack had detection and sampling as separate pieces with nothing tying them into one pass — this is that missing connective node. | | Empty Latent Image ⬜ | Creates a blank latent at a given resolution/batch size, wrapping core EmptyLatentImage with a summary output. | | KSampler Base+Refiner 🎭 (new) | Real SDXL base+refiner two-stage handoff in one node — two MODEL inputs, internally runs KSamplerAdvanced twice with a correct leftover-noise handoff at switch_fraction (default 0.8, matching Stability AI's own published recommendation), instead of needing two manually-wired KSamplerAdvanced nodes. | | KSampler Conditioning Blend 🔀 (new) | Takes TWO positive CONDITIONING inputs and a blend_ratio, weighted-averages them (same math as ComfyUI's own core ConditioningAverage), then samples — one extra CONDITIONING input instead of an extra model or image/mask pair. | | KSampler Masked Inpaint 🖌️ (new) | Takes IMAGE+MASK directly instead of a pre-built LATENT — encodes via core VAEEncodeForInpaint (mask-grow handled correctly, not reimplemented) then samples in one call, fewer required inputs than the usual two-node VAE-Encode-for-Inpainting → KSampler chain. | | KSampler Seed Variator 🎲 (new) | One config, many outputs: samples the same prompt across num_variations consecutive seeds and returns one batched LATENT — a "seed lottery" pass without wiring N separate KSampler nodes in parallel. | | Seed Stepper 🌱 | Tracks a persistent history of seeds used across queue runs. Supports increment, random-but-never-repeat, and cycle-through-a-fixed-list modes — Batch Counter already derives a fresh seed per run, but has no memory of which specific seeds were used. Uses CATEGORY = "TensorVizion/Sampling", distinct from this category's other nodes — see Known Quirks. | | Simple KSampler 🌡️ | Wraps core KSampler with a summary output describing the sampling run. | | VAE Decode 🔓 | Wraps core VAEDecode with a summary output. | | VAE Encode 🔒 | Wraps core VAEEncode with a summary output. |

Empty Latent Image, Simple KSampler, VAE Decode, and VAE Encode are thin summary-adding wrappers around ComfyUI's own core sampling nodes. Seed Stepper is an independent utility node. The four new KSampler variants each delegate their actual sampling math to ComfyUI's own core KSampler/KSamplerAdvanced/VAEEncodeForInpaint classes (called via getattr(instance, instance.FUNCTION) rather than a hardcoded method name, so they stay correct even if a future core version renames the internal method) — none of them reimplement diffusion sampling from scratch. Each one differs from the others in its actual input/output SHAPE (two models vs. two conditionings vs. image+mask vs. a seed-count widget), not just its default parameter values.

🎬 Video Nodes — TensorVizion/Video (12 nodes)

| Node | Summary | |------|---------| | MiniMax H3 Duration Calculator ⏱️ (new) | Converts a plain "how many seconds" value into MiniMax H3's real required frame count, snapped to the model's confirmed 17k+5 frame grid at 24fps (the official ComfyUI template does this with a raw MathExpression string — this wraps the same confirmed formula into a labeled, documented, reusable node), plus resolution validation the official template skips entirely. | | Video Color Match 🎨 | Matches the color grade of a video batch to a reference frame/image. | | Video Concat / Splice 🔗 | Joins or splices IMAGE batches (ComfyUI's "video = batch of images" convention) end-to-end. | | Video Frame Interpolate 🎥 | Generates in-between frames to increase apparent frame rate. | | Video Load 📹 | Loads a video file into an IMAGE batch, reporting source FPS and frame count. | | Video Loop Composer 🔂 | Builds seamless ping-pong/looping sequences from a batch. | | Video Motion Trail 🌌 | Adds a motion-trail/ghosting effect across frames. | | Video Mux Audio 🔊 | Muxes an audio track onto a saved video file. | | Video Save 🎬 | Encodes an IMAGE batch to MP4/WEBM/GIF via imageio (requires the imageio/imageio-ffmpeg packages — not bundled). | | Video Scene Detect 🎬 | Detects hard cuts and reports scene boundaries/timestamps. | | Video Speed Ramp 🐢 | Applies variable-speed time-remapping to a batch. | | Video Trim / Extract ✂️ | Crops a batch to a start/end frame range. |

🌐 Web API Nodes — TensorVizion/Web API (10 nodes)

The category that submits requests, waits on async jobs, extracts/builds JSON, saves results, notifies on completion, and tracks simple file queues.

| Node | Summary | |------|---------| | HTTP Request (WebAPI) | Sends a GET/POST/PUT/DELETE request; returns JSON, raw text, status code, and headers. | | OAuth2 Token Manager (WebAPI) | Obtains an OAuth2 access token via client-credentials or password grant. | | RSS Feed Parser (WebAPI) | Fetches and parses an RSS/Atom feed into a list of entries. | | Webhook Listener (Dummy) (WebAPI) | ⚠️ Does not actually start an HTTP server — see Known Quirks. | | JSON Field Extractor 🔎 | Pulls one value out of nested JSON via a dot-path (e.g. data.items.0.title), with a fallback if the path doesn't resolve. | | JSON Builder 🧱 | Assembles a JSON object from up to 4 key/value pairs (with auto type coercion) plus an optional merged JSON blob — for constructing request bodies without hand-typing JSON. | | Endpoint Poller ⏳ | Repeatedly GETs a URL until a JSON field matches an expected value (or any 2xx if no field given), for async job-style APIs. Times out cleanly after max_wait_seconds. | | Response Saver 💾 | Writes a JSON or text response to disk with the pack's standard collision-avoiding numbered-filename convention. | | Discord Notify 🔔 | Posts a message, optionally with an attached image, to a Discord webhook URL — the "ping me when this batch finishes" node. | | Folder Watcher 👁️ | Scans a folder and returns the next file not yet recorded in a manifest, enabling simple queue-style batch processing without a real job queue. |

Web API node details

HTTP Request — Sends GET/POST/PUT/DELETE to url with JSON headers/body widgets (parsed as JSON if valid, otherwise sent empty/raw). Returns the parsed response JSON, raw response text, HTTP status code, and response headers. Catches all exceptions internally and returns status_code=0 with the error message in response_text rather than crashing the queue.

OAuth2 Token Manager — Supports client_credentials and password grant types against any standard OAuth2 token endpoint. Returns access token, refresh token, a computed expires_at unix timestamp, and token type. Exceptions are caught and surfaced as an "Error: ..." string in the token_type output rather than raising.

RSS Feed Parser — Fetches feed_url and extracts <item> blocks via regex (not a full XML parser), pulling title/link/description/pubDate. filter_keyword optionally restricts results to entries whose title or summary contains that keyword (case-insensitive). Regex-based parsing means malformed or heavily-namespaced feeds may parse incorrectly — for strict RSS compliance, a real XML parser would be more robust.

Webhook Listener (Dummy) — See Known Quirks below; this node's port/endpoint/auth_token inputs currently have no effect.

JSON Field Extractor — Accepts either a JSON dict (e.g. from HTTP Request's response_json) or a raw JSON string on the same socket, auto- detecting which it received. field_path uses dot notation with numeric segments indexing into arrays ("data.items.2.name"). Returns found=False and the fallback string if the path doesn't resolve, rather than raising — a bad path won't stop the workflow.

JSON Builder — 4 key/value text-widget pairs with light type coercion: "true"/"false" → booleans, "null" → JSON null, plain numeric strings → int/float, and values starting with {, [, or a quoted string are parsed as nested JSON. extra_json optionally merges in a larger hand-written object for cases needing more than 4 fields.

Endpoint Poller — GETs url every interval_seconds. If success_field_path is set, polls until that dot-path resolves to success_value (string-compared); if left blank, any 2xx response counts as success. Stops and reports timed_out=True after max_wait_seconds regardless of which mode is used. Requires requests — see Requirements.

Response Saver — Accepts JSON (dict/list, pretty-printed on save) or a plain string (saved verbatim, or re-parsed and pretty-printed if format="json" and it happens to be a JSON string) on the same content socket. Uses the same name_001, name_002 collision-avoidance numbering as Video Save and Custom Folder Batch Saver, so repeat runs never overwrite a previous save.

Discord Notify — Posts message to webhook_url via Discord's webhook API. If an image is connected, the first frame of the batch is attached as a PNG — for multiple images, either call this node once per image or combine them into one image upstream with Contact Sheet Maker first. Requires requests; if missing, returns a clear error rather than crashing. Treat the webhook URL like a password — anyone with it can post to that Discord channel.

Folder Watcher — Scans folder_path for files matching extensions, sorted alphabetically, and returns the first one not yet recorded in a manifest JSON file (defaults to <folder_path>/.tensorvizion_processed.json). mode="scan_and_return" finds and returns the next unprocessed file; mode="mark_only" records a specific filename as processed without scanning — useful if you don't want mark_processed_immediately to fire until downstream processing actually succeeds. Uses only the Python standard library, no extra dependency.

🔀 Workflow Nodes — TensorVizion/Workflow (9 nodes)

| Node | Summary | |------|---------| | Any Switch 🔀 | Boolean-gated router for any ComfyUI type — one reusable switch instead of a type-specific one per socket type. | | Batch Counter 🔢 | Tracks a run count across queue executions and derives a seed from it. | | Timer Start ⏱️▶️ | Starts a named timer, passing any type through unchanged. | | Timer Stop ⏱️⏹️ | Stops a named timer and reports elapsed seconds. | | Conditional Gate 🚦 | Routes to one of two outputs based on a boolean condition, reporting which branch fired. | | Prompt List Iterator 📜 | Reads prompts from a text file (one per line) or a folder of .txt files and returns the Nth one — pair with Batch Counter's index output to step through a whole list one prompt per queue run. | | Try/Catch (Value Guard) 🛟 | Checks an upstream value against common failure signals (None, an error-prefixed string, NaN/Inf) and substitutes a fallback if detected. See its docstring for an important scope note — it cannot intercept an upstream node crashing outright, only validate a value an upstream node's own error handling already produced. | | Workflow End 🏁 | Terminal node that accepts up to 4 inputs of any type and produces a run summary. | | Workflow Manifest Writer 📋 | Writes a JSON record of the parameters that produced a given output — checkpoint, prompt, sampler settings, seed, LoRA stack — saved alongside the image with matching numbering. The pack had no "what exactly produced this image" record-keeping before this. |

---

Known Quirks

These are real, verified characteristics of the current pack — not bugs introduced by this doc rewrite, but worth knowing before you build around them:

• Web API category naming was inconsistent until this update. The original 4 Web API nodes (node_http_request.py, node_oauth_manager.py, node_rss_parser.py, node_webhook_listener.py) used CATEGORY = "WebAPI Nodes" — the only category in the pack not prefixed with TensorVizion/. This has been corrected to TensorVizion/Web API to match every other category.
• Webhook Listener is a dummy/stub. Its docstring says it "starts a local HTTP server," but the code never binds a port or starts a listener — it only checks a class-level _last_payload attribute that nothing in the file ever sets. As written, this node will always return new_data=False. Treat it as a placeholder for a future real implementation, not a working webhook receiver.
• Model nodes are split across two category strings. Most Model Nodes use CATEGORY = "TensorVizion/Model Utilities", but four files (metadata_embed_node.py, metadata_reader_node.py, model_lora_metadata_diff_node.py, trigger_word_extractor_node.py) use CATEGORY = "TensorVizion/Model" instead — so they'll show up in a separate submenu from the rest of the category in the node search.
• Sampling Nodes live in TensorVizion/Model Utilities, not their own category despite having their own Sampling Nodes/ folder on disk. This is a folder-vs-category mismatch, not a bug — the loader doesn't care what folder a file is in, only its CATEGORY string.
• latent_mask_node.py had a real syntax error (four lines each containing two statements with no separator, e.g. x0 = int(x * W) y0 = int(y * H)) that made the entire file fail to import in every prior release. This has been fixed as part of this update — see the Changelog.
• Seed Stepper uses CATEGORY = "TensorVizion/Sampling", a new category string not used by any other file in the Sampling Nodes folder (the other four use TensorVizion/Model Utilities). This was a deliberate choice — Seed Stepper is a standalone utility, not a core-node wrapper like the other four — but it means the Sampling Nodes folder now spans two submenus in the node search, similar to the existing Model Nodes split.
• ControlNet Preprocessor's depth_lite mode is a heuristic, not a real depth model. It estimates "near vs. far" from luminance and local sharpness, which works reasonably for a clear-subject-against-soft- background composition but is not comparable to a trained MiDaS/Depth- Anything model. Use a real depth ControlNet preprocessor node for anything depth-accuracy-sensitive; this mode exists for quick iteration without an extra model download.
• 3D LUT Apply only supports 3D .cube LUTs (LUT_3D_SIZE header), not 1D LUTs (LUT_1D_SIZE) — it raises a clear error naming the file if a 1D LUT is loaded, rather than silently misreading it.
• LoHa Loader, LoKr Loader, and DoRA Loader only support Linear-style 2D weights — Conv2d (4D) layers are NOT implemented in any of the three. Real LoHa/LoKr/DoRA files commonly include both Linear (attention projections) and Conv2d (ResBlock/UNet conv) layers; this pack's engines will apply the Linear layers correctly and report every Conv2d layer as skipped in the node's summary output, rather than silently ignoring them or (worse) applying incorrect math to them. This means a full file's effect will typically be PARTIAL, not complete, until Conv2d support is added in a future update. Always check the summary output's skip counts before assuming a merge fully applied.
• The key-name translation from LyCORIS's flattened naming (lora_unet_...) to ComfyUI's internal dotted module paths is a best-effort heuristic (documented in each loader's _map_to_model_key method), not a verified mapping table for every architecture. It's been tested against the standard SD1.5/SDXL UNet naming convention; other architectures (video models, non-UNet DiTs) may have layers that fail to map and get skipped. This mirrors a real, currently-open upstream ComfyUI issue (#12638) where LoKr keys go completely unloaded for at least one non-UNet architecture — this pack's loaders make that failure visible in summary rather than silent, but do not solve the underlying mapping problem for every possible architecture.
• DoRA Loader requires reading the model's CURRENT weight for each affected layer to compute its magnitude/direction decomposition correctly. If other patches were already applied to those same layers earlier in your workflow graph, the DoRA math will be computed relative to the already-patched weight, not the original base checkpoint weight — for predictable results, apply DoRA Loader before other model-patching nodes in your graph, not after.
• The 4 new KSampler variants call ComfyUI's core sampler classes via getattr(instance, instance.FUNCTION) rather than a hardcoded method name — this is deliberate (verified against real core source during development, where a naive assumption about KSamplerAdvanced's exact parameter name for seed turned out to be wrong: it's noise_seed, not seed, unlike plain KSampler). If ComfyUI core ever changes a sampler's parameter order (not just method name), these nodes would need updating — they pass arguments positionally, matching core's confirmed real signatures as of this pack's last verification date.
• Load Image + Recovered Metadata's ComfyUI-format parser uses a heuristic for multi-prompt graphs: with more than one CLIPTextEncode node in the embedded workflow, the longest text is guessed as positive and the shortest as negative. This is correct for the common single positive/negative pair but not guaranteed for workflows with several prompt nodes (e.g. a base+refiner workflow with separate refiner prompts, or a regional-prompting setup).
• Latent QC Gate's outlier check uses median/MAD, not mean/std — deliberately. An earlier mean/std version failed to catch a deliberately-constructed test case where 20% of a latent's values were extreme outliers, because that large a contaminated fraction pulls the mean and standard deviation far enough to hide the very values that should have tripped the check (the "masking effect" — mean/std have a 0% breakdown point; median/MAD have 50%). If you're comparing this node's outlier-percent output to Latent Histogram's outlier stat (Latent Nodes), note that node still uses mean/std — the two aren't computing the exact same statistic, by design, for different purposes (a chart you read yourself vs. an automated gate that needs to resist being fooled by a large bad batch).

---

Folder Structure

OmniNodes/
├── __init__.py                 ← recursive auto-discovery loader
├── README.md
├── requirements.txt             ← declares `requests` for Web API, `gguf` for GGUF Nodes
├── pyproject.toml
├── Model Links.md               ← creator links (CivitAI/Ko-fi/Patreon), not node docs
│
├── Audio Nodes/                  (12 files, TensorVizion/Audio)
├── Image Nodes/                  (16 files, TensorVizion/Image)
│   └── load_image_with_metadata_node.py ← new
├── Latent Nodes/                  (11 files, TensorVizion/Latent)
│   └── latent_qc_gate_node.py           ← new
├── Model Nodes/                  (26 files, TensorVizion/Model Utilities + TensorVizion/Model)
├── GGUF Nodes/                    (6 files, TensorVizion/GGUF) ← new
│   ├── gguf_file_info_node.py
│   ├── gguf_diffusion_model_loader_node.py
│   ├── gguf_clip_loader_node.py
│   ├── gguf_vae_loader_node.py
│   ├── gguf_checkpoint_converter_node.py
│   └── gguf_quant_validator_node.py
├── Prompt Nodes/                 (11 files, TensorVizion/Prompt)
├── Sampling Nodes/                 (9 files, TensorVizion/Model Utilities + TensorVizion/Sampling)
│   ├── ksampler_base_refiner_node.py       ← new
│   ├── ksampler_masked_inpaint_node.py     ← new
│   ├── ksampler_seed_variator_node.py      ← new
│   └── ksampler_conditioning_blend_node.py ← new
├── Video Nodes/                  (11 files, TensorVizion/Video)
├── Web API Nodes/                 (10 files, TensorVizion/Web API)
├── Workflow Nodes/                 (9 files, TensorVizion/Workflow)
│
└── Configs/                      ← JSON schema files for select nodes

---

Requirements

| Dependency | Notes | |------------|-------| | ComfyUI | Any recent version | | Python 3.9+ | Included with ComfyUI | | PyTorch | Included with ComfyUI | | NumPy | Included with ComfyUI | | Pillow | Included with ComfyUI | | requests | NOT bundled with ComfyUI. Required for HTTP Request, OAuth2 Token Manager, RSS Feed Parser, and Endpoint Poller. Install with pip install -r requirements.txt from the pack folder, or pip install requests directly. Nodes that need it check for its presence and return a clear error message (rather than crashing) if it's missing. | | gguf | NOT bundled with ComfyUI. Required for all 6 GGUF Nodes (File Info, Diffusion Model Loader, CLIP Loader, VAE Loader, Checkpoint Converter, Quant Validator). Install with pip install -r requirements.txt or pip install gguf directly. Every GGUF node checks for its presence and returns a clear error message (rather than crashing) if it's missing. | | imageio + imageio-ffmpeg | Optional. Only required for Video Save's mp4/webm output (GIF works with plain imageio). Not bundled with ComfyUI. |

All Audio/Image/Latent processing (FFT, phase vocoder, reverb, beat detection, color grading, blending, channel mixing) is implemented in pure NumPy/PyTorch/Pillow. The Model Utilities nodes use ComfyUI's own folder_paths, comfy.sd, comfy.utils, and comfy.model_management modules, already part of any ComfyUI install. The GGUF Nodes use those same comfy.sd/comfy.utils/folder_paths modules for the actual MODEL/CLIP/VAE construction, plus the external gguf package for reading, dequantizing, and writing .gguf files.

---

Troubleshooting

Nodes do not appear after install Restart ComfyUI completely. Check the terminal for [OmniNodes] log lines — ✅ Loaded means the file registered, ⚠️ No NODE_CLASS_MAPPINGS means the file was found but skipped, and ❌ Error importing means a real failure with a traceback printed below it.

Web API nodes fail to import with ModuleNotFoundError: No module named 'requests' Run pip install -r requirements.txt from inside the OmniNodes/ folder (or pip install requests directly) into the same Python environment ComfyUI runs in, then restart ComfyUI.

Endpoint Poller always times out Check success_field_path matches the actual shape of the JSON your endpoint returns — a typo'd path never resolves, so the node polls until max_wait_seconds and reports timed_out=True. Leave success_field_path blank to instead succeed on any 2xx response if your endpoint has no status field to check.

Webhook Listener never returns new data This is expected — see Known Quirks. It's a dummy node that was never wired to a real HTTP server.

Import error on a specific node Read the traceback in the ComfyUI terminal. Failures here are almost always missing ComfyUI internals (e.g. folder_paths, comfy.sd, or core nodes like KSampler/VAEDecode) not being on the Python path, which usually means the pack isn't actually inside ComfyUI/custom_nodes/ — check the install location first.

LoRA Stack / Quick LoRA Stacker / LoRA Info Inspector say LoRA not found LoRA filenames come from ComfyUI's folder_paths registry. Make sure your LoRAs are in the folder ComfyUI expects (usually ComfyUI/models/loras/).

Simple SDXL Loader / Batch Folder Loader can't find a checkpoint Same as above — both nodes only see files under ComfyUI's registered checkpoints/ search paths, not arbitrary filesystem locations.

Smart Unloader doesn't seem to free any VRAM Check the summary output string — if CUDA isn't available, it reports "CUDA not available" and skips VRAM accounting, since there's nothing to measure. The unload/GC calls still run either way.

---

Changelog

2026-09-05

• Added a new GGUF Nodes category (TensorVizion/GGUF, 6 nodes) — the pack's first support for quantized .gguf model files:
  • GGUF File Info 🔍 — architecture/metadata + per-tensor quant-type breakdown, read-only.
  • GGUF Diffusion Model Loader 🧠, GGUF CLIP Loader 📝, GGUF VAE Loader 🗝️ — dequantize-and-load a GGUF UNet/CLIP/VAE into a normal MODEL/CLIP/VAE via ComfyUI's own core loading functions. See these nodes' docstrings (and GGUF node details) for the VRAM trade-off vs a dedicated quantized-inference extension.
  • GGUF Checkpoint Converter 🔄 — quantizes any checkpoint into a real .gguf file (Q4_0–Q8_0/F16/F32) using the gguf package's own GGML block-quantization code.
  • GGUF Quant Validator ✅ — spot-checks a .gguf file for NaN/Inf, all-zero, or zero-element tensors before it gets loaded downstream.
  • Requires the new external gguf dependency — see Requirements.

2026-08-31

• Added 8 new nodes closing the biggest gaps preventing a fully self-contained workflow from being built with OmniNodes alone (no dropping back to stock ComfyUI nodes for these steps):
  • ControlNet Apply (Advanced) 🕹️ (Model Nodes) — the missing apply step between ControlNet Loader / ControlNet Preprocessor and sampling.
  • Apply Upscale Model 🔭 (Image Nodes) — runs the model Upscale Model Loader loads; previously nothing in the pack executed it.
  • Universal Checkpoint Loader 🌐 (Model Nodes) — model-family-agnostic loader (SD1.5/SD2.x/SDXL/SD3/Flux) alongside the SDXL-only Simple SDXL Loader.
  • Conditioning Composer 🧩 (Prompt Nodes) — combine/concat/set_area in one mode-switching node for regional/multi-concept prompting.
  • Detailer (Crop-Inpaint-Paste) 🔎 (Sampling Nodes) — full crop → upscale → resample → feathered-paste loop off a mask input (e.g. from Face Detect & Crop), the pack's first complete "fix a region" node.
  • Image Prompt Loader 🖼️ and Image Prompt Apply 🖼️ (Model Nodes) — a CLIP-vision/style-model pair enabling image-conditioned generation, a conditioning path the pack had none of before.
  • CLIP Skip ✂️ (Prompt Nodes) — standard clip-skip utility.
  • Quick Save Image 💾 (Image Nodes) — single-image save into ComfyUI's managed output tree with seed/model/notes embedded as PNG metadata.
• Version bumped to 0.8.0.

2026-08-09

• Added 4 new nodes supporting MiniMax H3 and Krea 2 — both very recent (H3 merged into ComfyUI core Aug 3, 2026) models with native ComfyUI support already; these are OmniNodes-style QC/utility additions on top of the official nodes, not replacements for them. Built against real confirmed source (ComfyUI core's actual comfy_extras/nodes_minimax_h3.py and the official H3 template), not assumed API shapes.
  • MiniMax H3 AV QC Gate 🚧 (Latent Nodes) — the Latent QC Gate concept adapted for H3's genuinely different joint video+audio latent (a NestedTensor wrapping separate video/audio tensors, confirmed from core source), checking each modality independently.
  • MiniMax H3 Duration Calculator ⏱️ (Video Nodes) — wraps the confirmed real 17k+5 frame-grid snap formula (verified against known real grid points, including the exact 124-frame value cited in an independent community source for a 5-second clip) into a labeled node.
  • Krea 2 Variant Validator ✅ (Model Nodes) — catches Turbo/Raw variant setting mismatches (8-step/cfg-1.0 vs 28-step/cfg-4.5) before a wasted run.
  • Krea 2 Guidance Helper 🎚️ (Model Nodes) — calculator/sanity-check for Krea 2's confirmed guidance formula and per-variant defaults.
• All 4 new nodes are covered by real functional tests, including a test built around a genuine mock NestedTensor matching H3's confirmed real structure, and a 1000-iteration randomized test confirming the frame-grid snap formula always lands on a valid grid point.

2026-08-08

• Added 6 new nodes: 4 KSampler variants with genuinely different input/output shapes, plus a Load Image variant and a Latent QC gate.
  • KSampler Base+Refiner 🎭 — real SDXL base+refiner handoff (two MODEL inputs) via two internal KSamplerAdvanced calls with correct leftover-noise handoff, not two independent samples stitched together.
  • KSampler Masked Inpaint 🖌️ — IMAGE+MASK in, LATENT out; encodes via core VAEEncodeForInpaint internally.
  • KSampler Seed Variator 🎲 — one config in, one batched LATENT out across N seeds; the inverse shape of Base+Refiner.
  • KSampler Conditioning Blend 🔀 — two positive CONDITIONING inputs blended by ratio before sampling, using the same weighted-average approach as core's own ConditioningAverage node.
  • All four call ComfyUI's core sampler classes via getattr(instance, instance.FUNCTION) rather than a hardcoded method name, and were built against real core source (not assumed) — development caught a real signature difference (KSamplerAdvanced uses noise_seed, not seed) before it shipped as a bug.
  • Load Image + Recovered Metadata 🔍 (Image Nodes) — loads an image via core LoadImage AND recovers embedded generation parameters (seed/prompt/steps/cfg/sampler/checkpoint) from A1111-style PNG text or ComfyUI's own embedded workflow JSON as individually-wireable outputs, not a text dump.
  • Latent QC Gate 🚧 (Latent Nodes) — automated PASS/FAIL check on a sampled latent (NaN/Inf, near-blank, outlier saturation) with an optional fallback latent. Uses median/MAD for outlier detection specifically because an initial mean/std version failed a deliberate 20%-contamination test case during development — see Known Quirks for the full explanation.
• All 6 new nodes' core logic is covered by real functional tests, and two genuine bugs were caught and fixed during that testing (the mean/std masking-effect issue above, and an A1111 parser bug that duplicated text across both positive/negative fields when no Negative prompt: marker was present) — both are the kind of bug that would have shipped silently without the tests catching them.

2026-08-06

• Added 8 new nodes: 4 real DoRA/LyCORIS merge engines plus 4 workflow utility nodes.
  • LyCORIS Format Inspector 🔬 — detects real LoRA/LoHa/LoKr format and DoRA marker presence from actual tensor key names, header-only (fast, no weight data loaded).
  • LoHa Loader (Custom) 🌀 — real Hadamard-product merge engine.
  • LoKr Loader (Custom) 🧩 — real Kronecker-product merge engine, supporting both dense and factored (low-rank) forms.
  • DoRA Loader (Custom) 🎯 — real magnitude/direction-decomposition merge engine (not a scaled-LoRA approximation).
  • All three merge engines apply their computed delta via ComfyUI's own ModelPatcher.add_patches() API and were built specifically to avoid a documented ComfyUI core issue (#8683) where built-in LyCORIS auto-detection can silently mis-route LoHa/LoKr files through the plain-LoRA path. Conv2d/4D layer support is NOT yet implemented in any of the three — see Known Quirks.
  • Workflow Manifest Writer 📋 (Workflow Nodes) — JSON run-record alongside saved outputs.
  • Image Grid Compare 🆚 (Image Nodes) — labeled comparison grid, distinct from Contact Sheet Maker's unlabeled thumbnail tiling.
  • Multi-LoRA Weight Sweep 📶 (Model Nodes) — first node in this pack to use ComfyUI's real OUTPUT_IS_LIST list-processing mechanism; outputs a strength sweep as a true list for automatic downstream iteration.
  • VRAM / Model Size Estimator 📐 (Model Nodes) — header-only VRAM footprint estimate for a checkpoint + up to 4 LoRAs, before queuing.
• Corrected a factual error in this README's own description of Contact Sheet Maker (previously described as "labeled" — it is not; verified against its actual docstring while writing Image Grid Compare's differentiation note).
• All 8 new nodes' core math/logic is covered by real functional tests — the three merge engines were verified against hand-computed reference values and, for DoRA specifically, against the defining mathematical property of the algorithm itself (post-merge weight row norms exactly equal the trained magnitude vector).

2026-08-04

• Added 12 new nodes spread across 6 categories:
  • Model Nodes: ControlNet Preprocessor 🕹️ — canny/depth-lite/lineart extraction, filling the pack's biggest prior gap (a ControlNet Loader with nothing upstream to build its conditioning image).
  • Image Nodes: Mask Morphology 🩹 (grow/shrink/feather/invert a MASK), Resize to Multiple 📏 (pad/crop/stretch to a valid latent dimension), Text Overlay ✏️ (draws text onto an image — no prior text-rendering capability existed anywhere in the pack), 3D LUT Apply 🎞️ (loads and applies a .cube LUT via trilinear interpolation).
  • Latent Nodes: Latent Histogram 📊 — per-channel distribution histogram + outlier-percentage stat, a distribution-shape diagnostic distinct from Latent Visualizer's point statistics.
  • Sampling Nodes: Seed Stepper 🌱 — persistent seed history with increment/random-no-repeat/cycle-list modes, complementing Batch Counter's simpler per-run increment.
  • Workflow Nodes: Prompt List Iterator 📜 (steps through a file/folder of prompts, one per queue run), Try/Catch (Value Guard) 🛟 (routes to a fallback when an upstream value shows a failure signal).
  • Web API Nodes: Discord Notify 🔔 (post a message + optional image to a Discord webhook on completion), Folder Watcher 👁️ (manifest-based "next unprocessed file" for simple queue-style batch processing).
• Updated requirements.txt comment to include Discord Notify among the nodes needing requests.
• All 12 new nodes are covered by real functional tests (not just syntax checks) — see each node's module docstring for the specific behaviors verified.

2026-07-30

• Added 4 new Web API nodes: JSON Field Extractor 🔎, JSON Builder 🧱, Endpoint Poller ⏳, Response Saver 💾 — rounding out the category into a full request → poll → parse → save loop.
• Recategorized the original 4 Web API nodes from CATEGORY = "WebAPI Nodes" to TensorVizion/Web API, matching every other category's naming.
• Added requirements.txt declaring the requests dependency, previously undeclared anywhere in the pack.
• Fixed a real syntax error in latent_mask_node.py (four lines each containing two unseparated statements) that made the file fail to import in every prior release.
• Rewrote this README from scratch to reflect the pack's actual current contents — the previous version predated the Sampling, Video, and Web API categories entirely and had drifted on per-category counts elsewhere.

---

License

MIT — see LICENSE file.

---

OmniNodes by TensorVizion · github.com/TensorVizion/OmniNodes