TrentNodes

KO | EN

gitlite — search

#javascript #python #go #golang #android #machine-learning #docker #nodejs #windows #cli #kubernetes #pytorch #security #ios

(★ 35)

Professional video processing, scene detection, and utility nodes for ComfyUI.

TrentNodes 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Trent Nodes

Professional video processing, scene detection, and utility nodes for ComfyUI.

[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/TrentHunter82/TrentNodes/main/LICENSE)
[![ComfyUI](https://img.shields.io/badge/ComfyUI-Custom%20Nodes-orange)](https://github.com/comfyanonymous/ComfyUI)

---

### NEW: Batch Loader Cowboys (Text File / Ref Folder / Ref Preview)

> Filename-keyed batch loading for per-clip render pipelines. Wire
> **VideoFolderCowboy**'s `filename` output into the new
> **TextFileCowboy** and **RefFolderCowboy**, and clip `000.mp4`
> automatically pairs with `prompts/000.txt` and `refs/000/`.
> TextFileCowboy loads one prompt file per clip (natural sort,
> wrap/clamp/error index modes, mtime cache-busting).
> RefFolderCowboy loads up to six reference images onto six fixed
> IMAGE outputs — empty slots emit None, which optional inputs like
> the MiniMax H3 `ref_image` sockets silently skip, so all six stay
> wired and empty folders run ref-less instead of erroring.
> **RefPreviewCowboy** previews whichever slots actually hold images
> (None-tolerant, mixed sizes OK).
> Find them under **Trent/Text** and **Trent/Image**.

### NEW: Organize Group as Grid (Canvas Tool)

> One-hotkey cleanup for messy groups. Select any group(s), hit
> **Shift+Alt+A**, and every child node snaps into a left-to-right
> layered layout based on connection order — sources on the left,
> sinks on the right, columns ordered by topological depth. Within
> a column, nodes are stacked top-to-bottom by the mean y of their
> downstream targets so wires stay roughly parallel. Collapsed
> nodes right-align inside their column so their output sockets
> stay close to the next column. The group then resizes to wrap
> the result. One Ctrl+Z reverts everything.
> Find it under **TrentNodes** menu.

### NEW: PSD Background Replacement (3 modes + auto-detect)

> Swap backgrounds in messy PSDs where there's no clean single
> "background" layer. **PSDLayerCompositor** now supports three
> replacement modes:
>
> - **single** — swap one layer by index (original behavior).
> - **replace_range** — swap a contiguous range of layers
>   `[replacement_index..replacement_end_index]` with one image,
>   sized to the canvas or the layers' union bbox.
> - **underlay** — paste the replacement under all original layers
>   (escape hatch when you can't pin down the background range).
>
> **PSDBackgroundDetect** scores layers from the splitter manifest
> using name regex, full-canvas coverage, opacity, blend mode, and
> bottom-bias, and outputs a recommended `bg_start` / `bg_end` range
> to wire into the compositor. Use the detect → range → underlay
> ladder when one mode doesn't quite fit.
>
> v1 limitation: PSD re-export (`output_psd_path`) only works in
> `single` mode. Find them under **Trent/PSD**.

### NEW: CorridorKey Green Screen Keyer

> Neural green screen keying using **CorridorKey** (Corridor Digital).
> Instead of producing binary masks, it **unmixes true foreground color**
> from the green background, preserving semi-transparent details like
> hair, motion blur, and out-of-focus edges. Outputs clean foreground,
> alpha matte, and composite preview. Uses **BiRefNet** for automatic
> alpha hint generation when no mask is provided.
> Find it under **Trent/Video**.

### NEW: Video Degradation

> Apply configurable, **temporally coherent degradation** to video frames
> for generating synthetic training pairs. 15 built-in presets (VHS,
> dashcam, security cam, old film, underwater, and more) plus full custom
> control over motion blur, defocus, noise, compression artifacts,
> chromatic aberration, interlacing, rolling shutter, and lens distortion.
> Find it under **Trent/Video**.

### NEW: VHS Swap (Canvas Tool)

> One-hotkey swap of native ComfyUI video nodes to **VHS equivalents**.
> Replaces LoadVideo with VHS_LoadVideo and SaveVideo with VHS_VideoCombine,
> automatically collapsing intermediate GetVideoComponents and CreateVideo
> nodes. Works on selected nodes or the entire graph. **Shift+V**
> Find it under **TrentNodes** menu.

### NEW: Wire VHS Combine (Canvas Tool)

> Pairs with VHS Swap. Once you have a VHS Load Video and a
> VHS_VideoCombine in the graph, hit **Shift+Alt+V** to: add (or
> reuse) a `VHS_VideoInfo` off the Load's `video_info` output,
> convert the Combine's `frame_rate` widget to an input and wire
> the source `loaded_fps` into it, and set the Combine to
> `video/h264-mp4` with `crf=13`. Selection-aware (uses selected
> nodes when present, otherwise falls back to the single matching
> pair in the graph). Single Ctrl+Z reverts everything.
> Find it under **TrentNodes** menu.

---

## Installation

### Via ComfyUI Manager (Recommended)
Search for "Trent Nodes" in ComfyUI Manager and click Install.

### Via Comfy CLI
```bash
comfy node registry-install trentnodes
```

### Manual Installation
```bash
cd ComfyUI/custom_nodes
git clone https://github.com/TrentHunter82/TrentNodes.git
cd TrentNodes
pip install -r requirements.txt
```

## Nodes

All nodes are organized under the `Trent/` category for easy navigation.

### Trent/Video (13 nodes)

**Cut Detective**

Neural shot-boundary detection with a film-strip preview. Finds every cut in a clip, says what kind of cut each one is, and hands the cut list to the H3 Auto Prompt Generator.

- **Detectors.** The `detector` widget defaults to `auto`, which tries [OmniShotCut](https://github.com/UVA-Computer-Vision-Lab/OmniShotCut) first: a 2026 shot-query video Transformer from the UVA Computer Vision Lab, range F1 0.883 against 0.814 for both TransNetV2 and AutoShot, and the only one of the three that labels a boundary as a dissolve, wipe, fade, whip-pan or sudden jump instead of just flagging it. `transnetv2` is the proven baseline, ships its weights in the wheel, runs on CPU, and reports hard cuts only. `classic` is the frame-difference detector Chop Cuts uses — no model, no download, and a safety net rather than a peer.
- **Knowing which detector ran.** A cascade that quietly slides down to `classic` would hand H3 a worse cut list with nothing to show for it. The `detector_used` output names what actually ran, the report headlines a fallback, the film-strip subtitle flags it, and the console logs it as a warning. `fallback_policy` sets how far `auto` may fall: `cascade` (all three), `neural_only` (never `classic`), or `strict` (OmniShotCut or an error).
- **Tuning.** `sensitivity` drives TransNetV2's threshold and the classic detector's, and OmniShotCut ignores it — it predicts shot ranges directly. Its real knob is `omnishotcut_overlap`, the overlap between 100-frame inference windows; raise it when a boundary near a window edge looks wrong. Move `sensitivity` on the OmniShotCut path and the report says it did nothing.
- **Outputs.** `cut_times` (comma-separated seconds), `shot_table` (one readable line per shot), `film_strip` (a labelled contact sheet with a colour-coded cut marker per shot and a proportional timeline ribbon), `report`, `cuts_json`, `num_shots`, `detector_used`.
- **Film strip.** One thumbnail per shot by default; `thumbs_per_shot` samples further into long shots. The first card of a shot is always the frame right after the cut, and only it carries the coloured edge, so a boundary stays legible when a shot wraps across rows. Shots are never dropped to fit the sheet — the thumb count degrades instead, and the subtitle says so.
- **Feeding H3.** Wire `cut_times` into the H3 Auto Prompt Generator's `cut_times` input. The VLM is then told to write exactly those shots, and the assembler forces the `[Shot N]` times onto the measured cuts instead of rescaling them proportionally. Any of the three string outputs works — the parser also reads timecodes, `[Shot N] At MM:SS.mmm` labels, and hand-typed lists across several lines.

OmniShotCut is not on PyPI and is not installed automatically. Install it with `--no-deps`, which matters: its `requirements.txt` pins `transformers==4.57.3` and its `pyproject` lists torch, so a plain install can downgrade a working ComfyUI environment.

```bash
pip install --no-deps git+https://github.com/UVA-Computer-Vision-Lab/OmniShotCut.git
```

It needs CUDA, and downloads a 164 MB checkpoint from HuggingFace on first use. Without it, Cut Detective falls back to TransNetV2.

**Chop Cuts**

Accurate scene detection and video splitting. Automatically detects cuts, fades, and transitions using multi-metric analysis, then exports each scene as a separate MP4 file with a detailed report of cut locations and timestamps. For cut *detection* alone, Cut Detective above is substantially more accurate; Chop Cuts remains the node that splits a clip into per-scene MP4 files.

**Video Folder Analyzer**

Scans directories for video files and generates detailed reports including resolution, frame rate, codec, duration, and file size. Outputs as text, JSON, or markdown.

**Latest Video Last N Frames**

Extracts the final N frames from the most recently modified video in a specified directory. Useful for monitoring render outputs.

**Latest Video Final Frame**

Retrieves the last frame from the newest video file in a folder. Streamlines iterative video generation workflows.

**Cross Dissolve with Overlap**

Creates smooth frame transitions with configurable overlap duration. Blends adjacent frames for professional video effects.

**Batch Slowdown**

GPU-accelerated frame duplication to slow down image, mask, or latent batches. Supports multiple input modes: direct multiplier (2x, 3x, 1.5x), target frame count, or FPS conversion (24fps to 60fps). Features smart decimal distribution for non-integer slowdowns and optional speedup mode for sampling every Nth frame.

**Frame Ramp Boogie**

GPU-accelerated frame interpolation that inserts blended intermediate frames between consecutive frame pairs. Features configurable easing curves (linear, ease in/out, cubic bezier with presets) and region targeting (full batch, start, middle, end). Creates smooth slow-motion with actual frame blending instead of simple duplication.

**Save Transparent Video**

Export image batches as video with alpha channel transparency. Three output formats: Animated WebP (good compression, browser-ready), ProRes 4444 MOV (lossless for DaVinci Resolve / After Effects), and PNG image sequence (universal lossless fallback). Alpha is sourced from an optional MASK input, the 4th channel of RGBA images, or defaults to fully opaque. Supports mask auto-resize, single-mask-to-batch broadcast, and configurable quality/FPS. All alpha compositing is GPU-accelerated.

**Video Folder Cowboy**

Directory iterator for video files with natural sorting (vid1 < vid2 < vid10). Browse folders with a built-in file browser dialog, load frames via OpenCV with configurable frame skipping, max frame limits, and start frame offset. Supports glob patterns, sorted subdirectory processing, and configurable index overflow handling (wrap, clamp, error). Returns frames as IMAGE batch plus filename, total video count, file path, frame count, and FPS.

**MatAnyone Video Matte**

Temporally-consistent video matting using MatAnyone (CVPR 2025). Given a single initial mask (or auto-generated via BiRefNet), propagates it across all video frames with memory-based temporal consistency. Produces flicker-free alpha mattes for compositing over chroma key or custom backgrounds. All compositing is GPU-accelerated via torch.lerp.

**CorridorKey Green Screen Keyer**

Neural green screen keying using CorridorKey (Corridor Digital). Instead of producing binary masks, it unmixes true foreground color from the green background, preserving semi-transparent details like hair, motion blur, and out-of-focus edges. Outputs clean straight foreground color, a linear alpha matte, and a composited preview. Uses BiRefNet for automatic alpha hint generation when no mask is provided. Features CNN refiner control, green spill removal, auto-despeckle for tracking markers, edge feathering, and mask expansion. Supports custom background images, transparent RGBA output, and multiple chroma key colors (green, blue, aqua, white, black).

**Video Degradation**

Apply configurable, temporally coherent degradation to video frame batches for generating synthetic training pairs. 15 built-in presets (mild, moderate, severe, phone_indoor, social_media_reupload, zoom_call, dashcam, night_handheld, old_youtube, old_vhs, shaky_handheld, security_cam, livestream, old_film, underwater) or full custom control. Supports motion blur (directional with angle modes), defocus blur (uniform, breathing, rack focus, edge softness), noise (gaussian, poisson, film grain, sensor, mixed), compression artifacts (JPEG, H.264, blockiness), chromatic aberration, temporal flicker, resolution degradation, color degradation, interlacing, rolling shutter, vignette, and lens distortion. Outputs degraded frames plus a JSON degradation map. All operations GPU-accelerated.

### 🎬 Trent/Compositing (1 node)

**Video Layer Ho Down**

Multi-layer compositing node with interactive drag-to-position canvas preview. Place up to 5 transparent foreground layers onto a background image or video batch. Dynamic layer inputs -- connect one and the next appears automatically (up to 5). Each layer has independent scale, opacity, and blend mode (normal, multiply, screen, overlay, add). Supports RGBA 4-channel images for transparency, automatic batch size alignment (single frame layers repeat across entire video), and partial off-screen placement. All compositing is GPU-accelerated via PyTorch. Features a live canvas with checkerboard transparency indicator, click-to-select layers, drag-to-position, crosshair alignment guides, coordinate display, and a center-reset button.

### 🎨 Trent/PSD (6 nodes)

**PSD Layer Splitter**

Rasterizes a `.psd` into per-layer PNGs and writes a `_manifest.json` capturing index, position, size, opacity, blend mode, visibility, group path, and (v2) `bbox_area_ratio`, `covers_canvas`, `is_fully_opaque` for downstream tools. Supports `canvas` or `cropped` layer sizing, optional group extraction, hidden-layer inclusion, and per-kind filters (pixel, type, shape, smartobject, fill, group, adjustment).

**PSD Layer Loader**

Loads previously-split layers from a folder (the splitter's output) without re-rasterizing. Use this when iterating on downstream nodes — skips the slow PSD parse. Range-selects via `start_index` / `end_index`, optionally loads alpha as a separate mask.

**PSD Layer Compositor**

Recomposites layers from a splitter folder back into a single image, reading positions/opacity/visibility from `_manifest.json`. Three replacement modes for swapping out a background: **single** (swap one layer by index), **replace_range** (swap a contiguous index range with one image — for messy PSDs where the "background" is multiple stacked layers), and **underlay** (paste replacement under all originals as an escape hatch). `replacement_fit` (stretch/fit/cover/center) and `range_fit` (canvas/union_bbox) control sizing. Optionally re-exports a modified `.psd` via `output_psd_path` (single mode only in v1).

**PSD Background Detect**

Scores layers from a `_manifest.json` and recommends a contiguous index range that's likely the background. Signals: name regex match (`bg|background|backdrop|sky|wall|floor` by default), full-canvas coverage, opacity + normal blend mode, bbox area ratio, bottom-bias; penalises text and adjustment layers. Outputs `bg_start`, `bg_end`, `confidence`, and a human-readable `rationale` you can wire to `easy showAnything` to see exactly which layers were picked and why. Wire `bg_start`/`bg_end` into the compositor's `replacement_index`/`replacement_end_index` and switch the compositor to `replace_range` mode for a fully-automated background swap.

**PSD Layer Names**

Lists every layer name in a `.psd` file — no rasterization, no manifest side-effects, just walks the layer tree. Use this to find the exact `target_layer_name` to feed `PSDLayerSaveAsPSD`. Optional group inclusion and group-path display.

**PSD Layer Save As PSD**

Replaces one layer's pixels in an existing `.psd` with a provided image and saves to a new path (the original is never overwritten). Locates the layer by name (recursively walks groups), preserves the original layer's name, opacity, blend mode, and visibility, and respects non-Latin layer names through the proper Unicode tagged block.

#### Recommended workflow for messy PSDs

When the "background" isn't a single clean layer, ladder through the three modes:

1. **Detect → range** — wire `PSDBackgroundDetect` to the compositor's `replacement_index`/`replacement_end_index`, set mode to `replace_range`. The detector's `rationale` output (piped to `easy showAnything`) shows which layers it picked and why, so you can sanity-check the call.
2. **Manual range** — if the detector misfires, leave the mode as `replace_range` and type the indices directly. The detector is a convenience, not a dependency.
3. **Underlay** — when you genuinely can't pin down a range, switch to `underlay`. The replacement paints under all originals and you toggle visibility on the offending opaque layers in the source PSD.

### 🎞️ Animation/Timing (2 nodes)

**Enhanced Animation Timing Processor**

Analyzes animation sequences to detect duplicate frames and replaces them with gray frames for video generation workflows. Features multiple similarity detection methods (hybrid, SSIM, histogram, perceptual), configurable preservation options for sequence first/last frames, and **keyframe alignment** that automatically inserts padding frames to ensure keyframes land on multiples of 4 (or any configurable multiple) for glitch-free video generation. Outputs include processed frames, duplicate mask, timing report, and removal indices for the companion Frame Remover node.

**Animation Frame Remover**

Removes padding frames inserted by the Enhanced Animation Timing Processor. Connect the `removal_indices` output from the processor to automatically strip the temporary padding frames after video generation, returning to the original frame count while preserving the generated content.

### 🖼️ Trent/Image (14 nodes)

**Image+Text Grid**

Creates a grid layout of images with text captions below each. Features auto-grid layout (set images_per_row to 0) that picks optimal columns via ceil(sqrt(n)), aspect-aware cell sizing based on median batch aspect ratio, and automatic centering of the last row when it has fewer images. Configure grid layout with images per row, image size, caption height, font size, padding, and background color. Note: when receiving images from a list-based node (e.g. StringListCowboy), use an ImageListToImageBatch node upstream to collect all images into a single batch before the grid. Perfect for contact sheets, comparison grids, or captioned image galleries.

**Align Stylized Frame**

Aligns AI-stylized images (Flux img2img restyles etc.) back to their original source frame. Global alignment uses differentiable affine estimation — FFT phase-correlation seeding plus Adam refinement on contrast-normalized edge maps — recovering translation, scale, and optionally rotation and anisotropic scale to sub-pixel precision, with an ECC fallback that guarantees the output is never worse than the input. Subject-preserving mode uses BiRefNet for segmentation, DWPose shoulder matching (centroid/area fallback for non-person subjects), and pastes the untouched stylized subject at the corrected position. Ghost removal and border-gap fills use **big-lama** by default (purpose-built removal model, Apache-2.0, ~196MB auto-download from GitHub, single forward pass) with **Netflix VOID** (Apache-2.0, via ComfyUI core, weights in standard model folders) selectable as a diffusion option — note VOID is a video model run on a replicated 5-frame clip for stills, is much slower, and in testing LaMa matched or beat it on single frames; VOID is the intended engine for future video-batch fills. The old `sd_inpaint` option maps to `lama` automatically (SD 1.5 backend removed). The `score_map` visualization shows per-pixel alignment residual before/after. Notes: the difference_map output is a 2x-wide side-by-side diagnostic image, not a same-size frame; with `inpaint_method=none` the inpaint_mask output excludes the pasted subject so it is safe for an external inpainting pass; batches use frame-0 geometry for all frames.

**Cherry Pick Frames**

Flexible frame selector with multiple modes for extracting specific frames from image batches. Supports first N frames, last N frames, specific indices (comma-separated like "0,5,10,75"), or every Nth frame. Dynamic outputs adjust based on your selection. Perfect for grabbing keyframes, endpoints, or evenly-spaced samples from video batches.

**Bevel/Emboss Effect**

Applies depth and dimensionality to images through configurable bevel and emboss filters. Includes adjustable angle, depth, and smoothing parameters.

**Image Batch Analyzer**

Comprehensive statistical analysis of image batches. Generates histograms, color distribution charts, and detailed reports on brightness, contrast, and color composition.

**Multi-Batch Combine**

Concatenates multiple image batches into a single output batch. Accepts up to 8 optional inputs - unconnected inputs are simply skipped. Handles dimension mismatches automatically with configurable resize modes: largest (resize all to max dimensions), first (match first batch), or custom (specify target width/height). GPU-accelerated resizing via bilinear, nearest, bicubic, or area interpolation.

**Black Bar Cinema Scope**

Adds cinematic black bars (letterbox/pillarbox) to images for widescreen aspect ratios. Supports standard presets (16:9, 2.35:1 Cinemascope, 2.39:1 Anamorphic, 2.76:1 Ultra Panavision, etc.) plus custom ratio override. GPU-accelerated.

**Image Folder Cowboy**

Directory iterator that loads images with proper natural sorting (img1 < img2 < img10). Fixes common issues with filename ordering by splitting text and numeric chunks. Features configurable index overflow handling (wrap, clamp, error) and sorted subdirectory processing.

**Easiest Green Screen**

One-click background removal and chroma key replacement using BiRefNet AI segmentation. Composites foreground over a solid color background (green, blue, aqua, white). Features edge refinement with dilate/erode/feather controls, temporal smoothing for flicker-free video batches, optional custom background images, and resolution presets (512/768/1024). All operations GPU-accelerated.

**Grab First Frame**

Returns the first frame from a batch of images. One input, one output, zero settings.

**Just Pad or Crop It**

Pad or crop an image to match a reference image's dimensions. Each axis is handled independently: axes smaller than the target are padded with configurable gray fill, axes larger are center-cropped. Outputs a binary mask (1.0 = real pixel, 0.0 = padded region). Supports center or top-left alignment.

**Multi-Load Cowboy**

Six image loaders in one node, with one shared resize. The node face is a grid of slots sitting beside the output column, so eleven outputs cost no extra height: click a slot to browse the input folder or upload, drop files straight onto a slot, drag one slot onto another to swap, and clear a slot with the X in its corner. Dropping several files at once fills the empty slots in order. Empty slots are skipped instead of raising, so a half-filled grid is a valid graph and an all-empty grid still returns a black frame plus a count of 0. Resizing follows the same fit modes as KJ's Resize Image V2 - stretch, resize, pad, pad_edge, crop and total_pixels - with crop position, pad colour and a divisible_by rounding. Outputs the filled slots as one batch (padded up to a common size when a fit mode leaves them uneven), the alpha masks with padding marked as 1.0, the count, the batch width and height, and each slot on its own IMAGE output for wiring to separate branches.

**Ref Folder Cowboy**

Loads up to six reference images from a folder (or folder/<filename_key>/) onto six fixed IMAGE outputs in natural-sort order. Empty slots output None, which optional inputs - like the MiniMax H3 ref_image sockets - treat as not connected, so all six outputs stay wired and nothing needs muting. An empty or missing folder is not an error: every slot passes None and the run continues ref-less. Also outputs the image count and the slot-order filenames. Replaced ref files bust the cache via mtime.

**Ref Preview Cowboy**

None-tolerant multi-image preview, the companion to Ref Folder Cowboy. Six optional IMAGE inputs; previews whichever slots hold images, in slot order, and silently skips None or unconnected inputs - so an empty or partial ref folder never aborts the run. Each slot is saved separately, so mixed image sizes are fine.

### 🔧 Trent/Utilities (12 nodes)

**Smart File Transfer (Auto-Rename)**

Intelligent file management with automatic conflict resolution, checksums, and organized directory structures. Safely transfers files with duplicate detection.

**Custom Filename Generator**

Creates structured filenames using templates with support for timestamps, counters, and metadata variables. Ensures consistent file naming across workflows.

**Filename Extractor**

Parses filenames to extract embedded metadata, timestamps, and structured information. Converts filenames into usable workflow data.

**JSON Multi-Line Summary**

Converts complex JSON data into human-readable multi-line summaries. Formats nested structures for display and logging.

**JSON Extractor**

Extracts specific values from JSON objects using path notation. Simplifies working with structured data in workflows.

**Number Counter**

Generates sequential numbers with configurable start, step, and padding. Essential for batch processing and frame numbering.

**Text File Line Loader**

Loads individual lines from text files by index. Useful for iterating through prompt lists or configuration files.

**File List**

Lists files in a directory with filtering options. Returns file paths for batch processing workflows.

**Create Text File**

Creates text files with custom content. Specify a file path and content to write. Automatically adds .txt extension if none provided. Creates parent directories as needed.

**Wan2.1 Frame Adjuster**

Adjusts frame amount to always satisfy Wan 4x+1 requirements by adding gray frames to the end of a batch; use a Get Frame Range from Batch node before combining video with the original amount of frames for less headaches when using Wan.

**MiniH3 Magic (Frame Adjuster)**

MiniMax H3 counterpart of the Wan2.1 Frame Adjuster. Rounds a batch up to the next valid H3 frame count (17n+5: 5, 22, 39, 56, ...) by adding gray frames to the end, and also outputs the resulting duration in seconds at H3's native 24 fps. H3 can pad up to 16 frames (~0.67 s), so trim back to the original frame count after generation.

**WSL Path Converter**

Turns a Windows path into the Linux path a ComfyUI running under WSL can actually open, so pasted paths work in Load Video (Path), Load Image From Path and friends. Handles `\\wsl.localhost\<distro>\...` and legacy `\\wsl$\...` UNC paths, drive letters (`C:\Users\...` → `/mnt/c/Users/...`, honouring a custom `[automount] root` in `/etc/wsl.conf`), `file://` URIs, and quotes from Explorer's "Copy as path". Set `direction` to `to_windows` to go the other way, or leave it on `auto` to always get the host's native form. The optional `append` input joins a file name onto a folder, and the `exists`/`kind` outputs report whether the target is a file, a dir, or missing.

### 🎭 Trent/Masks (4 nodes)

**Latent Aligned Mask**

Creates precision masks aligned to latent space dimensions. Ensures proper mask scaling for latent-based video and image processing.

**Latent Aligned Mask (Advanced)**

Extended version with additional parameters for fine-tuned mask generation including feathering, inversion, and composite operations.

**Latent Aligned Mask (Simple)**

Streamlined mask creation with minimal inputs for quick latent-aligned masks in simple workflows.

**Latent Aligned Mask (Wan)**

Specialized variant optimized for Wan video model requirements with automatic 4x+1 frame alignment.

### 🎬 Trent/Keyframes (2 nodes)

**Wan Vace Keyframe Builder**

Dynamic keyframe sequencing for Wan Vace video generation. Features interactive UI with drag-and-drop image inputs, frame-accurate positioning, automatic resizing, and synchronized mask generation. Supports up to 256 frames with customizable filler frames.

**Vace Mask AutoComping**

Composites solid gray over masked areas of input images for Wan VACE inpainting workflows. Feed in an image batch and a mask batch (e.g. from SAM3), and it outputs the original video with gray overlaid on the masked regions plus a matching clean binary mask -- saving you from manually compositing the gray-over-original setup that VACE expects. Features adjustable mask expansion (hard edge, no feather) to grow the inpaint region, and a configurable gray level (default 0.5 matches VACE filler). Handles single-mask-to-batch broadcast, automatic spatial resizing, and GPU-accelerated dilation.

### 📝 Trent/Text (3 nodes)

**Auto Style Dataset**

Generates 35 prompt strings for synthetic dataset creation. Reads prompts from an external config file and applies optional prepend/append text to each output. Perfect for batch generation of training data with consistent formatting.

**String List Cowboy**

Lassos strings together into a list with optional prefix/suffix branding. Works like Impact Pack's MakeAnyList but specialized for strings - connect any inputs and they get collected into a string list. Each string gets the prefix prepended and suffix appended. Dynamic inputs expand as you connect more values.

**Text File Cowboy**

Directory iterator for text files - the prompt-side companion to Video/Image Folder Cowboy. Loads one file selected by index (natural-sorted, with wrap/clamp/error overflow modes) or by a filename_key input: wire VideoFolderCowboy's filename output in and clip 000.mp4 loads prompts/000.txt. Outputs the file text, the bare filename, and the total file count. Edits to the file bust the cache automatically via mtime.

### 🔀 Trent/Flow (2 nodes)

**This, That, or The Other**

Parallel gating node with 3 independent input/output channels. Each input passes to its corresponding output ONLY if truthy (non-None, non-zero, non-empty). Falsy inputs block their downstream path via ExecutionBlocker. Uses lazy evaluation to avoid evaluating inputs until needed. Dynamic inputs expand as you connect (1-3 slots).

**First Valid**

Fallback chain node that outputs the FIRST truthy value. Checks inputs in priority order: first → second → third. Returns the first truthy value found, or blocks if all are falsy. Uses lazy evaluation to skip evaluating later inputs once a truthy value is found. Perfect for providing fallback values like default images, prompts, or parameters.

### 🧪 TrentNodes/Testing (1 node)

**LoRA Test Prompt Generator**

Generates 10 test prompts specifically designed to validate different types of LoRA models. Supports four LoRA categories:
- **subject_person**: Portrait/character LoRAs with varied lighting, poses, and environments
- **style**: Artistic style LoRAs across diverse subjects and scenes
- **product**: Object/product LoRAs with studio and lifestyle contexts
- **vehicle**: Car/vehicle LoRAs covering angles, lighting, and motion

Outputs 10 individual prompt strings plus a combined `all_prompts` output for easy batch processing. Includes optional quality suffix to append tags like "8k, detailed" to all prompts.

### 👁️ Trent/VLM (7 nodes)

**H3 Auto Prompt Generator**

Reads a source video plus an identity reference image with a VLM and writes a production-ready MiniMax H3 REF2VA prompt in the official six-section format. It picks keyframes on scene cuts and motion peaks, then validates and repairs the model's output, and retries once with the validator's error list. Backends: anthropic, gemini (the only one that can hear the audio track), openai, kimi, glm, qwen_api, and three local options.

**What "official format" means here.** Every rule the assembler enforces traces to MiniMax's own [`VIDEO_PROMPT_WRITING_GUIDE_ref_en.md`](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md) and `..._base_en.md`: the six lowercase sections in order, one line per reference label in `subject_definitions` and `retention_analysis`, the mandatory square-bracketed task-type prefix on `summary`, the fixed retention markers (`fully_preserved` / `partially_preserved` / `attribute_transfer` / `weak_reference` for visible content, `fully_copy` / `partially_copy` / `reference` / `weak_reference` for audio), `[Shot 1]` with no timestamp and `[Shot N] At MM:SS.mmm,` after it, and nothing at all after `non_diegetic_music`. `tests/test_h3_format.py` asserts each of these against the quoted rule.

Two things worth knowing:

- The trailing block of `No ...` sentences is **not** in the format — the word "exclusion" appears in none of MiniMax's guides. It is off by default and lives behind **`append_exclusions`**, because H3 has no negative-prompt field and some workflows lean on it. Run `--profile both_ab` in `tools/h3_prompt_dev_run.py` to A/B it.
- `non_diegetic_music: N/A` means "there is no non-diegetic music", so the length trimmer shortens a real score to its first sentence rather than blanking it.

Three controls decide how the references are read:

- **`cut_times`** — paste or wire any Cut Detective output here. The cut list becomes ground truth: keyframes land on the real shot starts, the VLM is told to write exactly those shots, and the assembler forces the `[Shot N]` times onto them instead of rescaling proportionally. A shot count that disagrees is a retry error, not a silent repair. Blank falls back to the node's own frame-difference guess.
- **`music_video`** — writes the prompt as a music video instead of a documentary scene. The audio balance inverts: `non_diegetic_music` becomes the lead section and can no longer be `N/A`, `overall_soundscape` thins to what is genuinely audible under the track, cuts are described as landing on the beat, and performance to camera becomes the action. Put the sung words in **`lyrics`** and the track in **`music_description`**. Lyrics are written as `<d>[Language] ...</d>` inside the shot where they are heard — the actual language of the words, not always English — and are stripped if the model repeats them in the audio sections, per the official guide. **`music_source`** decides whether the song reaches H3 itself: `auto` infers it from a connected `audio` input, `reuse_audio_1` declares it outright even with nothing wired, and `generate_score` has H3 invent the track. When it is reused the prompt declares `<Audio 1>` as the score with a `fully_copy` retention line and attributes the vocal to the track rather than a new `(Sx)` speaker ID. Leaving `lyrics` blank tells the model to say the mouth moves in time without intelligible words — H3 invents nonsense syllables if you ask for singing without giving it words. The mode overrides `enable_audio_prompt` when they clash, since a silent music video is a contradiction.
- **`first_frame_alignment`** — the I2V hook. H3 expects the picture-to-timeline relationship declared as the prompt's first line, and the guide fixes two sentences for it. At `alignment_time_seconds` `0.00` the node emits the I2VA form verbatim: `For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced.` Any other moment uses the L2VA form, `How the reference pictures align with the target video - <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the target video.`, which is the one the guide writes with a variable shot and mark. Because that sentence declares `<Picture 1>` to *be* the target frame, the node reverses its usual stance: the task context tells the model to use the reference's framing, background and lighting, and the assembler strips any prose still saying to ignore them. Alignment also makes the aligned picture a genuine frame anchor, which is exactly when the guide wants it to have its own `subject_definitions` line and its own `([Shot N] first frame)` retention entry — so the node asks for both, instead of the usual rule of citing an identity-only image inside `<Subject 1>`.
- **`first_frame_image`** — for a **hybrid graph** that feeds H3 a character reference *and* an injected opening frame. Connect it and it becomes `<Picture 2>`: the alignment sentence pins *that* image to the timeline and Shot 1 opens on it, while `<Picture 1>` keeps its identity-only role and no shot ever opens on it. Wire the same image your H3 encoder gets in slot 2. This matters because a character reference is often a multi-angle sheet — without this input, turning on `first_frame_alignment` tells H3 that the contact sheet *is* the opening frame. The prose repair follows the aligned tag too, so `<Picture 1> supplies identity only` stays intact in a hybrid run and is stripped in a single-picture one, which is correct in both cases.

Leave `first_frame_alignment` **off** for REF2VA character replacement, where `<Picture 1>` supplies identity only and its background must not leak into the video.

**VidScribe MiniCPM Beta**

GPU-accelerated vision-language model for describing images and video frames. Two selectable backends: MiniCPM-V 4.5 int4 (default) and Microsoft Mage-VL 4B (Jul 2026, stronger on video; ~10GB bf16, auto-downloads to models/magevl; thinking_mode is MiniCPM-only). Features:
- int4 quantization (~6-8GB VRAM)
- Smart frame sampling (auto-selects ~32 frames from longer videos)
- Auto-unload after 60s idle to free VRAM
- System prompt presets (default, detailed, concise, narrator, technical, accessible, creative)
- Three modes: single image, multi-image comparison, video frame sequence with temporal understanding
- Deep thinking mode for more thorough analysis

**Unload MiniCPM**

Manually unload MiniCPM model to immediately free VRAM. Connect any output to trigger. Useful when you need GPU memory for other operations without waiting for the 60-second auto-unload timeout.

**VRAM Gated Checkpoint Loader**

Loads a checkpoint only after receiving a VRAM-cleared signal from VidScribe MiniCPM. Ensures the large VLM model is fully unloaded before loading diffusion models.

**VRAM Gated VAE Loader**

Loads a VAE only after receiving a VRAM-cleared signal. Same sequencing pattern as the gated checkpoint loader.

**VRAM Gated Diffusion Model Loader**

Loads a UNET model only after receiving a VRAM-cleared signal. Use with FLUX or other UNET-based architectures.

**VRAM Gated LoRA Loader (Model Only)**

Loads a LoRA (model-only) after receiving a VRAM-cleared signal. Applies LoRA weights to a model with configurable strength.

### Canvas Tools (Frontend Extensions)

These are canvas-level tools that operate on the ComfyUI graph directly -- no Python backend nodes required. They register as commands with keybindings, menu entries, and selection toolbox buttons.

**Grid Paste**
Duplicate any selection of nodes, groups, reroutes, or subgraphs into an automatically-arranged grid. Select your nodes, hit **Ctrl+Shift+;**, type how many copies you want, and they appear in a clean grid at your cursor position. The grid auto-calculates a roughly-square layout (e.g. 9 copies = 3x3) with 50px padding, sizes each cell to the bounding box of your selection, and preserves all internal connections between copied nodes. Widget values, node colors, group rectangles -- everything comes along for the ride.

**Grid Paste Connected**
Same grid layout, but every copy's external inputs are wired back to the original source nodes -- the same behavior as Ctrl+Shift+V but applied in bulk. Hit **Ctrl+Shift+Alt+;** to use this mode. Perfect for scenarios like pasting 6 KSamplers that all need to connect to the same checkpoint loader, or duplicating a ControlNet processing chain where every copy should read from the same source image.

Both modes wrap the entire operation in a single undo transaction, so one Ctrl+Z reverts everything. Maximum 100 copies per operation.

**VHS Swap**
One-hotkey swap of native ComfyUI video nodes to VHS (Video Helper Suite) equivalents. Replaces LoadVideo with VHS_LoadVideo and SaveVideo with VHS_VideoCombine, automatically collapsing intermediate GetVideoComponents and CreateVideo nodes and rewiring all connections. Works on selected nodes or the entire graph. Transfers widget values (filename, fps) and reconnects IMAGE/AUDIO outputs. Requires VHS to be installed. Hotkey: **Shift+V**, also available in the TrentNodes menu.

**Wire VHS Combine**
Companion to VHS Swap that finishes the wiring. Drops in (or reuses) a `VHS_VideoInfo` node off the Load Video's `video_info` output, converts the `VHS_VideoCombine` `frame_rate` widget to an input and connects the source's `loaded_fps` into it, and sets the Combine's format to `video/h264-mp4` with `crf=13`. Selection-aware: with one VHS Load Video + one VHS Video Combine selected, those are used; otherwise it falls back to the single matching pair in the graph. Whole operation is one undo. Requires VHS to be installed. Hotkey: **Shift+Alt+V**, also available in the TrentNodes menu.

**Organize Group as Grid**
Lays out a group's child nodes in a clean left-to-right grid based on connection order. Columns are assigned by topological depth (longest path from a source node), so upstream nodes always sit to the left of their downstream targets — exactly mirroring how the wires read. Within a column, nodes are sorted by the mean y of their downstream targets (barycenter heuristic) to minimize wire crossings, with current y as a fallback for sinks and disconnected nodes. Collapsed nodes right-align inside their column so their output socket stays close to the next column instead of leaving a long horizontal gap. The group resizes to wrap the result, and the entire arrange is wrapped in a single undo transaction. Works on multi-selected groups. Hotkey: **Shift+Alt+A**, also available in the TrentNodes menu.

**Queue Selected Output Nodes**
Queues only the output nodes you have selected, plus everything upstream that feeds them, instead of the whole graph. Handy when a workflow has several save/preview branches and you only want to re-run one. Selecting a group contributes that group's output nodes, and selecting a subgraph node contributes the output nodes inside it. Muted and bypassed nodes are ignored. Honors the batch count. Hotkey: **Shift+Alt+Q**, also available in the TrentNodes menu.

The prompt is pruned on the client, the same approach rgthree uses: everything outside the selected branch is stripped before the request is sent. That matters because core's own `Comfy.QueueSelectedOutputNodes` instead sends the whole prompt with `partial_execution_targets`, so a broken or half-wired branch somewhere else in the graph can still fail validation and block the run. Queueing still goes through `app.queuePrompt`, so `control_after_generate` seeds keep advancing. Logic is covered by `node tests/queue_selected_outputs/run.mjs`.

### 🌐 Trent/API (1 node)

**FAL Kling V2V (O3 Pro)**

Calls the FAL AI Kling O3 Pro video-to-video reference API to generate new video from a reference video and text prompt. Encodes input IMAGE batch frames to mp4, uploads to FAL CDN, and returns the generated video as frames. Supports optional style reference images (@Image1, @Image2) and character/element injection (@Element1, @Element2) with frontal face + reference image pairs. Optional AUDIO input embeds audio into the uploaded video via ffmpeg muxing -- use with keep_audio=True to preserve it in the generated output. Features auto-appending of @tags for connected inputs so you can write natural prompts, plus a built-in @ autocomplete dropdown in the prompt widget that shows available tags based on which inputs are connected. Images are auto-compressed to JPEG and downscaled if needed to stay within FAL's 10 MB upload limit. Costs $0.336 per second of generated video.

### 🔊 Trent/Audio (2 nodes)

**Audio Length in Seconds**

Calculates the duration of an audio input. Returns both the rounded-up integer (always ceiling to the nearest second) and the exact float duration. Handles all ComfyUI audio formats including VideoHelperSuite LazyAudioMap.

**Transcribe Lyrics (Whisper)**

Transcribes any AUDIO input with OpenAI Whisper and returns four outputs: plain `text`, LRC-timed `lrc` lyrics, `segments_json` (start/end/text records), and the `duration` in seconds. Audio over 30 seconds uses transformers' sequential long-form decoding, so timestamps stay absolute and words are not cut at a chunk boundary.

Model choice covers large-v3 (most accurate), large-v3-turbo (much faster), medium, small and base, plus any folder dropped into `ComfyUI/models/whisper/` which appears as `local:<name>`. The model stays cached in VRAM between runs unless you turn off `keep_model_loaded`. `precision` defaults to fp16 on CUDA and fp32 on CPU; the features are always cast to the model dtype, which is what makes this work on transformers 5.x (a plain `from_pretrained` there loads the fp16 checkpoint and then crashes with "Input type (float) and bias type (c10::Half) should be the same"). `hint_prompt` biases Whisper toward names or spellings you supply — note that on clips under 30 seconds a prompt disables timestamps, an upstream transformers limitation. Logic is covered by `tests/test_transcribe_lyrics.py`.

### 🎤 Trent/LipSync (11 nodes)

Complete lip sync pipeline for non-human character animation. Converts audio to mouth shapes and composites them onto tracked positions in video frames.

**Audio To Phonemes**

Extracts phonemes from audio using Vosk speech recognition. Returns timestamped phoneme data for mouth shape mapping. Automatically downloads the required Vosk model on first use.

**Phoneme To Mouth Shapes**

Converts phoneme data to a sequence of mouth shape indices (A-H + X for silence). Maps speech sounds to the 9 standard mouth positions used in animation.

**Mouth Shape Loader**

Loads 9 mouth shape images from a folder. Expects files named A.png through H.png plus X.png (silence). Validates all shapes are present and correctly sized.

**Mouth Shape Preview**

Previews mouth shapes with their corresponding phoneme labels. Useful for verifying mouth shape assets before use.

**Mouth Shape Compositor**

Basic compositor that places mouth shapes on frames at a fixed position. Use for static characters or simple animations.

**Mouth Shape Compositor (Tracked)**

Advanced compositor with tracking support. Places mouth shapes at positions determined by either:
- **Point tracking**: Use tracked (x,y) coordinates from Point Tracker
- **Mask tracking**: Use per-frame masks from SAM3 to find mouth centroids

Features BiRefNet background removal, scaling, offset adjustment, and optional RGBA output for further compositing.

**Creature Lip Sync**

All-in-one lip sync node combining audio analysis, mouth shape selection, and compositing in a single streamlined node. Ideal for quick character animation setups.

**Point Tracker**

Robust point tracking using pyramidal Lucas-Kanade optical flow. Click a point on frame 1 and track it through the entire video. Features:
- Sub-pixel accuracy with Scharr gradients
- Multi-stage recovery (adaptive template, original template, full-frame search)
- Periodic drift validation against original template
- GPU-accelerated template matching for large search areas
- Configurable window size up to 1025px for full-frame tracking

**Point Preview**

Click-to-pick interface for selecting the initial tracking point. Click anywhere on the image to set coordinates, which pass directly to Point Tracker.

**Points To Masks**

Converts point sequences to gaussian masks for use with mask-based compositing.

**Remove Mouth Background**

Standalone background removal using BiRefNet or color keying. Returns mouth shapes with alpha channel for custom compositing workflows.

#### LipSync Workflow

1. **Audio To Phonemes** - Extract speech from audio
2. **Phoneme To Mouth Shapes** - Convert to mouth indices
3. **Mouth Shape Loader** - Load your 9 mouth images
4. **Point Preview** - Click to select tracking point
5. **Point Tracker** - Track the point through video
6. **Mouth Shape Compositor (Tracked)** - Composite mouths onto frames

## Requirements

- ComfyUI (latest version recommended)
- Python 3.10+
- opencv-python >= 4.8.0
- numpy >= 1.24.0
- pillow >= 10.0.0
- matplotlib >= 3.7.0
- colorama >= 0.4.6
- vosk >= 0.3.45 (for lip sync speech recognition)
- transformers >= 4.40.0 (for BiRefNet and MiniCPM-V)
- accelerate (for MiniCPM-V model loading)
- fal-client >= 0.4.0 (for FAL AI API nodes)
- requests >= 2.28.0 (for FAL video download)
- timm >= 1.0.0 (for CorridorKey Hiera backbone)
- einops >= 0.8.0 (for CorridorKey tensor operations)

## Features

✅ **69 professional nodes** for video, image, audio, API, VLM, flow control, and lip sync workflows
✅ **Canvas tools** - Grid Paste, VHS Swap, Wire VHS Combine, and Organize Group as Grid (topological group layout)
✅ **Organized categories** - all nodes under `Trent/` namespace
✅ **Auto-discovery** - drop nodes in `nodes/` folder and restart
✅ **Colorful startup banner** with load validation
✅ **Comprehensive error checking** on initialization
✅ **Registry published** - semantic versioning support

## Development

```bash
# Clone the repository
git clone https://github.com/TrentHunter82/TrentNodes.git
cd TrentNodes

# Install dependencies
pip install -r requirements.txt

# Add new nodes
# Just drop .py files in nodes/ folder - they auto-register!
```

## Contributing

Pull requests welcome! Please:
- Follow existing code style
- Add docstrings to new nodes
- Test thoroughly before submitting
- Update this README with new nodes

## Support

- **Issues**: [GitHub Issues](https://github.com/TrentHunter82/TrentNodes/issues)
- **Registry**: [Comfy Registry](https://registry.comfy.org/publishers/flippingsigmas)
- **ComfyUI Discord**: [Join Server](https://discord.com/invite/comfyorg)

## License

MIT License - see [LICENSE](LICENSE) for details.

## Author

**Trent** - [Trent Films](https://github.com/TrentHunter82)

---

*Made with ❤️ for the ComfyUI community*

TrentNodes

TrentNodes 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

TrentNodes

TrentNodes 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README