WAS Node Suite v3

Mixing two latents is not the same as mixing two images

Caption or interrogate an image in ComfyUI

Load the captioning model that reads your image

A VAE encode that ships its output inside the workflow file

See what your logic chain actually decided

Paste a processed crop back without a visible seam

Paste a cropped edit back in, seamlessly

Crop an image to a computed bounding box

Crop to whatever your mask covers

Bundle model, clip, VAE and conditioning into one wire

The standard loader, plus a filename you can actually use

A checkpoint loader that also hands you the model name

Pick between two CLIP inputs with a boolean

Mask a whole folder of images with one text prompt

Describe what you want masked, in plain English

The model behind WAS's text-prompted masking

A prompt schedule for KSampler Sequence

A drop-in text encoder that also rolls the dice

Eased prompt schedules for KSampler Sequence v2

One checkbox instead of two workflows

Mixing two prompts into one without re-encoding

Toggle between two prompts in one graph

Hold one value in one place

Toggle between two ControlNet models with one boolean

The batch version of a conversion you need constantly

Turn a folder of outputs into one contact sheet

Tile a batch into one contact sheet

Crossfade two images into a GIF

Crossfade a folder of images into a GIF/APNG

Turn a folder of frames into a video (Windows, experimental)

Print whatever's flowing through a wire to the console

Catch a bad number before it becomes a bad seed

The debug tap for WAS's dictionary tools

Pull a HuggingFace diffusers model straight into your graph

Load a HuggingFace diffusers model you've already downloaded

Turn a picked color into numbers WAS's other color nodes can use

Turn computed color math back into something you can actually use

A histogram, wired straight into your graph

Read a picture's shape and branch a workflow on it

Merge multiple image batches into one

Make a solid-color image in ComfyUI

Fade one image into another by opacity, no mask needed

Composite two images using a mask as the seam

Photoshop blend modes inside ComfyUI

That soft glow around bright highlights, straight from game/photo post-processing

The bounding box behind WAS's crop-and-paste-back pipeline

Print your crop coordinates so you're not guessing

An edge map without installing a second pack

The RGB-split lens effect for a sci-fi/VHS look

Match a whole batch to one frame's look — flicker-free

Extract a palette from an image in ComfyUI

Crop to exact pixel coordinates

Crop a perfect square around a center point

Push pixels around using a second image as a map

The hyper-contrast portrait look in one node

A quick outline pass without reaching for Canny

Fake a shallow depth of field on a flat AI image

The post-process that makes AI images look shot, not rendered

Brightness/contrast/saturation in one node

Mirror an image horizontally or vertically

Build a custom gradient image in ComfyUI

Pull the fine detail out of an image, Photoshop-sharpen style

Pull a recently-loaded image back out of history

Flip between two images with a boolean

Contrast and tone control in ComfyUI

Load an image from any path or URL, not just ComfyUI's input folder

Deconvolution sharpening, not a plain unsharp mask

Smooth out surface noise without melting your edges

Rebuild an image from its red, green and blue

CRT scanlines and signal-glitch looks in one node

Split an image into rippling RGB waves

Add breathing room around an image (and get it back cleanly)

Put your edited patch back exactly where it came from

Paste a crop at custom coordinates in ComfyUI

Stitch a fixed-up face crop back into the original image

Procedural noise textures without a diffusion model

Layered Perlin noise for richer procedural textures

Turn a render into pixel art

Procedural white/pink/blue noise textures, not the diffusion kind

One-node background removal with u2net

The threshold cutter, not an AI matte

Swap one color for another in ComfyUI

Plain, predictable resizing (no upscale model)

Turn an image without cropping the corners off

Shift every color in an image around the color wheel

The save node with formats, paths, and filename tokens

Make an image tile without visible seams

Pull one RGB channel out as its own image

Isolate one color, black out everything else

Lift shadows, tame highlights in ComfyUI

Read an image's width and height as numbers

Fake 3D shading from a flat image and a depth map

A game-engine lighting trick faked from a flat 2D image

Glue two images together with a feathered seam

WAS's node for converting a batch of images to grayscale

Fix RGBA/mode mismatches in ComfyUI

Instagram-style presets for ComfyUI, via Pilgram

Turn an image into hard black-and-white for masks and stencils

Split one image into a batch of tiles

Turn a picture into a mask for inpainting

Turn a real photo into noise you can seed a diffusion with

Turn a picture into a repeatable seed number

Flip an image across its diagonal, not its axis

Cellular noise, not the smooth Perlin kind

Pad or shrink a bounding box before you crop

Pad a number with leading zeros for filenames

Automated hi-res-fix loops in one node

Looping KSampler passes for prompt-progression generations

Sine-modulated denoise and seed keying for prompt progression

The normal KSampler, but seed is a wire you can plug into

Merge two latents into one batch before the expensive part

Route between two latents with a boolean

Add noise back into a latent in ComfyUI

Read a latent's width and height as usable numbers

Scale a latent by a multiplier in ComfyUI

Step through a folder one image per run

Read a whole text file into your graph

WAS's own 1-or-0 switch, from before ComfyUI had native booleans

A true/false source for ComfyUI logic

WAS's boolean AND gate for its own 1/0 logic system

WAS's boolean OR gate for its own 1/0 logic system

WAS's 'exactly one but not both' logic gate

Flip a WAS boolean without wiring two extra gates

Toggle between two LoRAs in ComfyUI

WAS's version of the standard LoRA loader

Grab the mask blob closest to a size you pick

Stack separate masks into one batched MASK

Pull one mask out of a batch

Isolate the brightest band of a graded mask

Crop straight to a mask's biggest blob

Crop straight to a mask's smallest blob

Crop to the masked area and get crop_data to paste it back

Grow a mask's edges outward so inpaints don't leave a seam

Keep only the largest blob in a messy mask

Shrink a mask's edges inward

Close the gaps a segmentation mask left behind

Pull out the darkest band of a graded mask

Blur a mask's edges so composites don't seam

Flip a mask, flip what it means

Keep only the smallest blob in a mask

Paste a cropped mask region back where it came from

A rectangular mask defined by percentages, not pixels

A rectangular mask defined in exact pixels

Merge two masks into one

Flatten a batch of masks into one

Merge several masks into one

Soften jagged mask edges in ComfyUI

Cut one mask out of another in ComfyUI

Clamp a soft mask into a clean black-and-white one

The OG depth map node, and when it's still the right call

Load the depth model that feeds WAS's SSAO and depth nodes

Flip between two checkpoints with a boolean

The stateful counter that remembers between runs

Compare two numbers to drive logic in ComfyUI

Pick between two numbers with a boolean

Snap a number to a valid latent size before it breaks your run

Do math on numbers inside your graph

The constant π, ready-wired, no typos

Coerce a WAS number into a strict FLOAT

Coerce a WAS number into a whole number

Hand a KSampler a seed by wire, not by widget

Turn a number into text you can save, print, or splice into a filename

Pull A1111 styles into ComfyUI

Bring your A1111 style presets into ComfyUI

A general-purpose dice roll for your graph

Point at an object and let Segment Anything mask it

Load Segment Anything for targeted masking

The config node behind WAS's Segment Anything pipeline

Merge multiple SAM point sets into one request

Write a string to disk from ComfyUI

A seed you can wire into multiple nodes in ComfyUI

Bridge a plain STRING into WAS's text tooling

Pull one image out of a batch by index

Define your own [token] for filenames, driven by graph inputs

Define your own [tokens] for filenames and saved text

Check if two strings match, and how closely

Glue prompt fragments together with a delimiter

Does this string hold that substring?

Turn formatted text into a dictionary object

Pull one value out of a dictionary as a string

See what's actually inside a WAS dictionary

The node that starts WAS's whole dictionary family

Dump a dictionary back out as plain text

Merge two WAS dictionaries into one

Reopen a text file you loaded before

Turn a substring check into a boolean you can branch on

Swap a substring in your prompt mid-graph

Templated prompts with random fills

Find/replace terms wired in, not typed

Toggle between two text inputs in ComfyUI

Bundle multiple strings into one list output

Merge two text lists into one, in order

Flatten a list of strings into one block of text

Feed prompts from a text file, one per run

A resizable text box you can wire anywhere

A text box that won't mangle your syntax

Port Automatic1111-style embedding references into ComfyUI syntax

Expand WAS's own wildcard word bank in any text

Stamp live values into any string

Pick a random line of text each run

Reorder your prompt's tags without changing what's in it

Alphabetize a list of lines inside the graph

A one-line reusable text constant for your graph

Chop a string down to size, from either end

Turn a text wire into a sampler-ready prompt

The cheapest way to see what your prompt actually became

Parse a string into a number you can actually math with

The WAS node that bridges its old text output to a real STRING socket

Loading image-conditioned SD checkpoints, plus a name string

Load an ESRGAN model and get its name too

Pick between two upscale models with a boolean toggle

The core inpaint encode, plus a mask-offset knob

Flip between two VAEs with a boolean

Pull a video apart into individual frames

The Photoshop high-pass sharpen trick as a ComfyUI node

The fine-tunable version of the high-pass sharpen trick

A latent upscale that dodges ringing at edges

26 masks, one settings drawer, and why nothing happens when you run it

Stop starting every image from the same random static

Texture pushed into the latent while the sampler is still running

The curve that decides when the affine hits hard, drawn where you can see it

Muting a branch just falls through

The node that stops a branch from running at all

Pick one of many inputs with a number

The boring A/B valve that handles any type

Ask 'did that stage actually produce anything?'

Color grading inside the graph instead of round-tripping to Resolve

Per-block LoRA strength for WAN, Qwen, Flux and friends

Reuse a whole saved graph as a single node

How long is the music, and is it even loud enough?

All, any, none, exactly one, or majority

Turn a detector's 'everything' into a shortlist

Get detector regions into WAS's crop & mask nodes

Send WAS-measured regions back to ComfyUI core

Close the crop-and-paste loop

A measured region becomes a mask you can work with

Open a rectangle into x, y, width, height

One wire for model, clip, vae, conditioning — and extras

Ken Burns effects with a keyframed JSON spec

The unglamorous padding node that makes batches stack

A colorist's exposure scope, inside ComfyUI

Gather a fan-out back onto one wire

Build one grade out of two, apply it once

Drive one node's dropdown from another

The any-type output inspector that renders almost everything

The '10 > 9' node that doesn't sort your text wrong

If / else if / else, the legible way

The DOC is a zip full of HTML — this puts the markup on a string

Documents are formatted; prompts are not — strip the markup, keep the shape

Crop windows and bounds rows are different units — convert between them here

A crop window, opened up into plain pixel numbers

Bend a curve by hand, then drive a denoise ramp or camera move with it

The affine for people who already build their own sampler stack

Put a folder on the wire so a loop can eat it one file at a time

Look at what's on any wire without breaking the chain

Save a raw you can actually grade — write DNG from linear light

See what a bounds row actually points at — and get the region as a mask

Invent frames between frames with motion, not crossfades

The half of EMA-VFI you always forget — the weights loader

The node that stops a branch from running at all, not just from being used

Bring a 32-bit plate back into ComfyUI at its real brightness

Ship a plate to Nuke or Resolve — EXR with the headroom intact

Mute or bypass whole groups from one node — no marquee selection required

Close the loop, carry the state, and know why it stopped

An actual loop — repeat a slice of the graph N times

Out of VRAM on the last stage? Free memory partway through the run

Put the light back into a blown highlight

Decode past white — keep the values VAE Decode throws away

The one-click contrast fix — levels that measure themselves

The image batching node that stops yelling at you about sizes

Grab the last frame, drop the duplicate

Pad a short clip out to exactly 81 frames

Play a clip backwards, or make it a seamless ping-pong loop

Cut a batch of frames at exactly the right spot

A film grade in one node

An A/B slider for pitting two images against each other

Lay one image on another exactly where you want it — with a mask

Crop to exactly what a mask marks — and get told how to paste it back

Find a face, square-crop it, and know where to put it back

A face crop that tells you how sure it is

Crop by the numbers — no dragging, no guessing

Photoshop curves you drag right on the node

Kill the banding in a sky before you grade it

Motion blur with a direction — or a spin, or a zoom

Burn captions, watermarks and timestamps onto frames

Thin a long clip down to the frames that matter

Keep the steady, take the sharp

Recolor an image by its brightness

Edge-preserving blur that doesn't halo

Barrel, pincushion, and chromatic aberration in one bend

Turn a hard mask into a matte that keeps the hair

Outpaint padding and the mask that goes with it

Posterize, colourise, and screen-print your renders

Pin your corners, get the perspective for free

A preview that knows when your image is linear light

Measure a render before you trust it

Even out flicker across a batch of frames

Split an image into four quadrants, each on its own wire

Cut a picture into tiles, one output each

Scramble an image into tiles and reassemble it

Roll those >1.0 highlights down before they hit an 8-bit save

Darken corners, or lift them

Take the colour cast out by guessing the light

The affine sampler to try first (one node, no plumbing)

The one dial that runs the whole WAS Affine pack

A high-pass sharpen that runs before you decode

The two numbers SPEED Sampler schedules by

Cap a latent at a longest side, in latent space

Know whether that latent is broken before you decode it

Latent upscaling that protects edges instead of smearing them

Put a layer where you mean it, by naming a corner

Give a title or badge a physical edge without any 3D

Copy a layer and nudge the copy — start of every drop shadow

Change one thing about a layer, leave the rest alone

Scale a layer to cover, fit, or match another

That halo behind cut-outs and titles, without leaving ComfyUI

The only way to cut a layer to shape once it's in the stack

Reshuffle your stack without rebuilding it

Fill a cut-out with flat colour or a gradient, clipped to its shape

Thin a stack down before it flattens

The way back into a stack

Position your stack by hand, in JSON, without flattening

Keep your composite at the size it's supposed to be

Keep only the layers that match

Turn frames into a stack, each in its own place

Cast a shadow off a cut-out without leaving the stack

Read your whole stack out as numbers and names

Get a layered PSD into ComfyUI without flattening it first

Flatten a run of layers with all their settings baked in

Hand the composite over with the layers still inside

Take a stack apart so you can filter it

An outline that follows the subject, not its box

Cut the empty band off a cut-out so effects stop wasting radius on it

The two nodes that make your EXR saves physically honest

Open .wasdoc, .docx and .odt into your graph

Read a whole archive of documents as one flow

A numbered folder of frames, loaded as one batch

The zip you never have to unzip

Build or load a color-grading LUT without leaving ComfyUI

Batch-prompt from captions locked inside a zip

Prompts without a picker

A clip becomes frames, audio, and metadata in one pull

Same loader, but the clip can live on the internet

The if/else your graphs have been missing

See inside your loop without sprinkling debug nodes

Bottle a look, pour it on anything

Soften a mask's edges the controlled way

Push a mask around without wrecking its soft edges

Make a sloppy mask actually hug the subject

The node that catches when your detector found nothing

Turn a mask into a crop window

Twenty-six model slots, and only the one you pick loads

Read a model like a label before you render

An A/B switch for anything a loader answers

Back up your word pantry — or hand it to a friend

Someone sent you a pantry file — here's how you take it in

The pantry browser behind your __wildcard__ prompts

Make the __wildcard__ pantry your own, one term at a time

The easing node behind smooth camera moves

A real calculator node, no Python sandbox required

Read a whole list of numbers back — mean, min, max, and why it matters

The node that makes ComfyUI run a graph once per number

Skip renders that already exist

Stop the run mid-graph, inspect, tweak, and resume — without losing a thing

Stack 26 LoRAs in one node, each with its own switch and strength

Bake several LoRAs into one file instead of stacking loaders

The tuning knobs behind WAS Power LoRA Merger

Depth, pose, edges, or what a ControlNet needs

Expand wildcards, groups and variables before the prompt hits the encoder

Save a prompt pair by name so you stop retyping your best negative

Back up your style library, or hand it to someone on an A1111 setup

Bring a style library in — including your old A1111 styles.csv

Tidy a prompt's tags — dedupe, sort, cap — without mangling emphasis

Load a BiRefNet cutout model once and feed every Remove Background node

Pick an aspect, get clean pixel sizes

A rich text editor drawn on the node that hands you clean HTML

Save a document to disk — from .wasdoc to .pdf, from one node

Export a ComfyUI-built color grade to a standard .cube file

Save video with an audio track — the option core ComfyUI's node lacks

Bundle a workflow's output into an archive and know where it went

The node that slows your workflow down on purpose

Most of the image, most of the steps, at half the price

The starting noise that decides how much scene your video gets

Pick one picture from a stack by number

The A/B valve for images, masks and latents

Unpick a dictionary onto parallel wires

Pull one entry out of a list by position

Count your list before you loop over it

Cut a range out of a list, both ends included

Read a list as numbers and let the graph fan out

The bridge between lists and everything else

Turn one big string into a list of pieces

Drive a dropdown from a wire instead of your mouse

Build a real document on the wire, metadata and all

Make your Three.js object spin, bob and breathe — no JavaScript required

The effect that puts the smooth edges back (put it last)

The render-settings node your whole scene funnels into

Soft shadows and window highlights, no path tracing needed

The flat, unlit surface for UI panels and clean textures

Making bright things glow so emissives actually look lit

The unit cube your first 3D scene starts from

Ship your whole 3D scene as a webpage anyone can open

Any Three.js shape the pack forgot, in one line of JS

Toon, matcap and every other shader, via a return statement

A hundred instanced meshes, or anything wiring can't say

Per-frame JavaScript when an animation node isn't enough

A cone is just one number set to zero

Real lens blur on a 3D render, tuned in scene units

The thing metal and glass reflect (yes, you need one)

The ground plane that tells you where the camera is

How you get more than one object into a scene

Pull one named shape out of a Script Module

Hand out module-built surfaces without the code sprawl

Pull pre-built rigs and objects out of a Script Module

Nothing renders until you add one

Drop a real 3D model into your ComfyUI scene

Stack two materials under one mask

The node that actually puts your object in the scene

Blueprint view, no vanishing lines

Physically-correct renders, one bouncing photon at a time

Clean-up-in-place preview before you commit to the slow render

Point the camera, tell it where to look

Glass, car paint and soap bubbles without a texture artist

The flat rectangle that carries your textures

Make that rigged character actually walk

Turn the 3D scene into an image batch ComfyUI can use

The container that decides what's drawn and what's behind it

Write JavaScript for your scene, share it across nodes

Hand-rolled GLSL, right inside the graph

Spheres, domes and partial shells

The workhorse PBR surface — start here

Turn a ComfyUI image into a material texture

Grab a texture straight from the internet

Donuts, hoops and horseshoes

Point a camera at a moving object and stop hand-keying it

Put the same mesh in three places at once

The 3D preview that lives right on the node

Run any upscale model on huge images without OOMing

Turn anything into a true or false

One wire to feed the arithmetic chain

Read what's really on a wire

Drag a divider across two renders and actually see what changed

Keep the frames you actually want

Measure a clip without decoding a single frame

Open the figures a video load measured

Read everything a document says about itself

Where a ComfyUI while loop actually decides to stop

Loop until the graph says stop

Steal any node's widget value into text

A face detector you never have to download

Build a zip one render at a time, on the wire

Unpack a zip to a folder, then process each file

Trim a zip to just the entries you want

Peek inside a zip without unpacking a thing

Zip up the files your run just made

Build an animation one generated frame at a time

Stream frames to a video file as you generate them