was-node-suite-comfyui
WAS-NS v3 Reborn; Tools for image processing, filters, masking, text, logic, numbers, latents, files, 3D scenes, and animation.
Nodes (506)
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
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 drop-in text encoder that also rolls the dice
One checkbox instead of two workflows
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)
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
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
Flip between two VAEs with a boolean
Pull a video apart into individual frames
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?'
Reuse a whole saved graph as a single node
Stop guessing where the drop is
How long is the music, and is it even loud enough?
The workflow that carries its own starting image
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
The unglamorous padding node that makes batches stack
Prompt schedules you type by hand
The prompt list without hand-typed frame numbers
Put the sampler's noise where the picture isn't finished yet
Gather a fan-out back onto one wire
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
One subject that's genuinely between two prompts
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
The node that tells you what's actually on that wire
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
An empty video latent with the soundtrack already in it
The node that stops a branch from running at all, not just from being used
One Switchboard for Every Branch You Keep Turning Off by Hand
Bring a 32-bit plate back into ComfyUI at its real brightness
Ship a plate to Nuke or Resolve — EXR with the headroom intact
Your Text Encoder Is Already an LLM. Use It.
Mute or bypass whole groups from one node — no marquee selection required
The same latent, without the preview tax
Every frame encoded at once, no dead cores
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
Drive every segment of an extend loop from one control video
Decoding a 60-second MiniMax H3 run without eating your RAM
Putting the pieces back on the clock
Give fast motion more frames to live in
Joining the segment back onto the clip without a seam
Opening the next segment of a long H3 take
Fix scene 7 and restart the loop at scene 7
One node, long clips on the card you already own
Let a language model pick your cuts
A language model that knows H3's prompt dialect
Put the repaired stretch back without disturbing a single other frame
Redraw one bad stretch of a finished clip
A checkpoint for a video, not a video you can only watch
One idea in, a whole shot list out
One music bed under a video that was stitched together from scenes
Refine a whole clip in one pass, in pieces
The version with the anchor dial
Make any sampler fit a long H3 clip in your VRAM
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
Erode, dilate, and the shape operators you'll actually use
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
The palette step your pixel art was missing
Measure a render before you trust it
Even out flicker across a batch of frames
Cut a picture into tiles, one output each
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 file that turns the sound half into actual sound
Start the clip on a picture, keep the sound
Two prompt boxes, because this model writes dialogue too
The affine sampler to try first (one node, no plumbing)
A sampler that carries each frame into the next
Keyframe-driven, with the anti-stall knobs
The one dial that runs the whole WAS Affine pack
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
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
Batch-prompt from captions locked inside a zip
Prompts without a picker
A clip becomes frames, audio, and metadata in one pull
Your clip is still there after the restart
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
Casting a scene with a file, a frame number and one wire
One clip at a time, out of a prompt bundle
Write a whole multi-shot video as rows of prompts
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
Blocky where it's flat, smooth where it isn't
A film look in one node, and why a LUT beats a re-gen
Turn one down without turning it off
A parallax camera move over one still
The scope that tells you why your grade went wrong
Dial a look back, or stack two grades into one table
Cut a frame into four, on four wires
A scrambled picture with a seed, and one sharp edge case
Sharpening a latent without the embossed look
Smooth the edges, leave the flat bits alone
Get a film look without opening a grading app
Bake your LoRA stack into one file
The dial box behind a merge
Grade in ComfyUI, finish in Resolve
4x a 4K frame on a 12GB card
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
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
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
Turn anything into a true or false
One wire to feed the arithmetic chain
Read what's really on a wire
Grow the mask before the sampler sees it
Stop holding a 400-frame render in RAM
Proof that a tripod looks fake
Drag a divider across two renders and actually see what changed
The glitch that made 2009 look like this
Keep the frames you actually want
Measure a clip without decoding a single frame
Open the figures a video load measured
Measure the movement once, reuse it everywhere
The blur your video model forgot to render
Isolate what moves, ignore the camera
SEA-RAFT weights when texture matching isn't enough
Light trails without the after-effects
9:16 without cropping the actor's face off
Slow motion with frames that were never there
Find the loop hiding in your clip
Let the clip tell you where its cuts are
Fix the wobble, keep the move
Stop per-frame effects from flickering
Upscale a clip without the wallpaper crawling
Read everything a document says about itself
Detail that doesn't look like a filter
The same idea, with halo control and video in mind
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
WAS Node Suite v3 
<img src="was-node-suite-v3.png" width="600">
WAS Node Suite has been going since 2023 on Civitai and on GitHub, and was among the first packs to put hundreds of nodes into users' hands. WAS-NS has over a million downloads, and is used by thousands of users daily. It has been MIT since the first commit: use it, change it, teach with it, or run it in paid services.
The pack contains 513 nodes for ComfyUI, across images, filters and colour, masking, text and prompts, logic and flow, numbers, latents and sampling, files, animation and video.
See NODES.md for reference.
Consider donating to the project to help me afford caffeine.
Installation
ComfyUI Manager, search for WAS Node Suite v3 and install. This is the recommended route.
Manually, clone into custom_nodes:
cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui.git
Requires ComfyUI 0.14.0 or newer and Python 3.10+.
That is the whole install. Nothing is installed, downloaded or built, now or on any later start. The pack never runs pip on its own.
The first start takes a second or two longer than the rest. Your config.yaml, the state
database and the wildcard, LUT and view-extension folders are written under
<ComfyUI user dir>/was-node-suite/, and python compiles the pack to bytecode. An update
recompiles, so it happens once more each time you pull.
One optional group wants packages and ships off: document_export, which lets Save DOC
write .docx, .odt and .pdf.
# portable ComfyUI, from the ComfyUI_windows_portable directory
python_embeded\python.exe -m pip install -r ComfyUI\custom_nodes\was-node-suite-comfyui\requirements\document_export.txt
Then set document_export: true under features: in config.yaml.
docs/CONFIG.md has every group, what it needs and what it gates.
What changed since v2
513 nodes across a package of source files. The pack itself needs no packages, and nothing is
fetched from a git URL. What it bundles ships in the repository with its licence beside it,
listed in docs/THIRD_PARTY.md.
| | v2 | v3 |
|---|---|---|
| Nodes | 220 | 513 |
| Default packages installed | 20 | 0 |
| Installed from a git URL | 3 | 0 |
| Third-party carried in the repository | SAM and BLIP, 75 files of python | 143 files: browser libraries, fonts, eight face cascades, three sets of weights and two networks, each with its licence |
| Optional node groups | none | 22 keys in config.yaml, 8 of them off out of the box. Per-node disable group. |
213 of the 220 node ids are unchanged. Four are retired onto replacements, three are removed outright, and the section below says what opens in their place. Face detection, gradient maps, background removal, frame interpolation, seamless textures, colour matching, levels, palettes, masks and deconvolution all run on torch, on ComfyUI's own device, so OpenCV, numba, rembg, timm, scipy, scikit-image, scikit-learn and matplotlib are not installed. Everything else a node reaches for either ships with ComfyUI or belongs to an optional group.
299 new nodes
| Area | New | Area | New | |---|--:|---|--:| | Three.js scenes | 43 | HDR and linear light | 9 | | Files, archives and documents | 28 | Affine sampling | 7 | | Logic and flow | 26 | Everything else | 164 | | Layers | 22 | | | | Bounds | 10 | | |
What each area does: FEATURES.md.
Opening a workflow saved before v3
No node id is renamed. Two nodes are now a different node under the same menu name, two ids are gone and another node does the job of each, and ComfyUI offers to swap all four in. Five ids are removed with nothing in their place. Widgets, slot counts, three menu labels and four results changed, and a workflow saved before v3 is carried across as it loads.
Four retired ids. Each one opens listed in ComfyUI's missing-node dialog. Tick it, press the replace button, and the node comes back in place. Leave the dialog and it stays missing. The old name still finds its replacement in the Add Node search.
| Saved as | Comes back as | With |
|---|---|---|
| Image Crop Face | the same name, on a replacement running the same eight cascades | wiring, crop padding, cascade choice, flip setting |
| Image Gradient Map | the same name, on a replacement running the same gradients | wiring and settings |
| Load Lora | Lora Loader (Advanced), same five inputs and three outputs | model and CLIP wired, all three outputs wired, LoRA choice, both strengths |
| Number to Text | Number to String, same NUMBER, INT and FLOAT input, same STRING output | both wires. Neither node has a widget, so nothing is retyped |
The two face and gradient nodes ran through OpenCV, which the pack no longer installs. Their replacements run on ComfyUI's own device and need nothing installed.
Five removed ids. Each opens as a red box where it stood, with its links dropped. There is no replacement for any of them; delete the node.
| Saved as | What it did | What to do |
|---|---|---|
| Image Send HTTP | Posted an image batch to an address | Write the batch with Image Save |
| Text Random Prompt | Read a prompt from lexica.art | Write the prompt, or use Prompt Library |
| True Random.org Number Generator | Drew a seed from RANDOM.ORG | Use Random Number or Seed |
| WASDownloadImage | Read an image from a web address | Save the file, then use Load Image |
| WASNoodleSoupPantryRefresh | Downloaded the Noodle Soup pantry | Nothing. The pantry ships with the pack and seeds the database on first start |
The pack now makes no outbound request of its own from any node.
Widgets and slots, carried across for you. Thirty-six dropdowns reading true and false
are now checkboxes, and fourteen nodes that stopped at four to eight slots now declare
twenty-four or twenty-six, drawing one empty slot below the last one filled. Saved settings are
read back onto the new widgets and everything wired stays wired. The three batchers each gain a
count output below the one they had. Image Save's prefix_as_filename is now
overwrite_mode, ticked where it read true.
Three Custom Material takes a module file. Its javascript box is gone. The node now picks
a .js or .txt module from ComfyUI's input folder or a folder under paths.allow_read, and
the module's header names the textures it wants, which the node's slots then read as. A body
typed into an older workflow is dropped rather than read onto the menu, so open one, put the
body in a file and pick it. Code no longer travels inside a workflow, so a graph from someone
else cannot bring javascript with it. docs/CONFIG.md has the setting
that permits a module to run at all.
Three renamed labels. KSampler is now KSampler (Seed Socket), Seed is
Seed (Number Outputs) and Save Video is Save Video (Advanced), so none shares a name with
a core ComfyUI node. Only the label changed, and the old names still find them in search.
Four changed results.
| Node | What changed | What to do |
|---|---|---|
| Image Blending Mode | 26 blend modes instead of 14, in linear light on the GPU, keeping values above white. add now adds the two layers rather than painting image_b over image_a | A graph using add comes out brighter. Switch it to normal for what it did before |
| Image Style Filter | 37 looks, every graded one finished with a halation. The 26 period looks keep the colour their name has always meant | Nothing. A saved workflow opens on the same style |
| Mask Erode Region | Holds the frame edge instead of treating outside the frame as unset | A mask that touched an edge comes out wider. One with a clear margin is unchanged |
| Image SSAO (Ambient Occlusion) | Traces rays across the map as real relief instead of averaging neighbouring pixels, so the shading follows the surface and no longer reacts to the image's own colour. The depth_images input is now height_maps, tile_size is gone, and height_scale, ray_count, step_count and angle_bias set the relief and the tracing. The whole body is float now, so linear light above 1.0 is shaded rather than clipped, and a precision widget writes 8, 16 or 32 bit for EXR Save | Re-wire the depth map into height_maps, which opens unconnected. The other settings are read back onto the new widgets. Highlight masking now starts off, so the node shades as soon as it is dropped, and strength at 0 leaves the image untouched rather than black |
Nodes
513 nodes across 48 categories. NODES.md carries every input, output and
tooltip, and groups them by the config.yaml switch that gates them:
feature gates.
28 are deprecated, which ComfyUI marks in the Add Node menu, and each names its
replacement. They sit in the nine legacy groups in config.yaml, four of which start off:
docs/CONFIG.md.
Features
FEATURES.md covers what the pack does, by area: masking, layers, bounds,
filters and optics, transforms, colour and LUTs, HDR, instruments, logic and flow, numbers,
text and dictionaries, prompt terminology and styles, files and archives, animation, models
and LoRA, the affine transform, noise shaping, Kandinsky 6 video with sound, video comparison,
execution gating, the Content Viewer, Three.js scenes and graph plumbing.
Model weights
Nothing is downloaded unless you ask for it. features.network is false out of the box, so a node needing weights it cannot find says so and names the key rather than reaching for the network, and Three Texture URL takes only data: addresses and the pack's own assets.
Let it download. Set network: true under features: in config.yaml.
See docs/MODELS.md for more information.
Configuration
Written for you on first start at <ComfyUI user dir>/was-node-suite/config.yaml, as a copy of
config.example.yaml with every key at its default and the comment that
explains it. Edit it there as it will survive updates.
docs/CONFIG.md
Third-party code in the pack
The suite is MIT, see LICENSE. It bundles 143 third-party files: three.js and
three-gpu-pathtracer, HugeRTE, Prism.js, KaTeX and Mermaid, the EMA-VFI and Kandinsky 6 networks,
the DejaVu and Liberation fonts, eight face cascades and three sets of weights. Each keeps its own licence text
in the folder it ships in, and none of it is ever fetched. Every licence permits redistribution.
Versions, copyright lines, which licence covers what and a byte-level account of every bundled
copy: docs/THIRD_PARTY.md.
The software licences place no conditions on what you make with the suite: documents, captions and images you produce are yours. Open RAIL++-M, covering one 8 KB embedding, is the exception. It claims no rights in output but its use restrictions reach any use of that output, including the intrinsic maps Power Preprocessor answers with.
Security
Outbound requests are off out of the box, nothing starts a process or installs a package, and a
node input naming a file is resolved against an allowlist before the filesystem is touched.
What the pack does and does not do, and how to report a vulnerability:
SECURITY.md.
Contributing
Bug reports and feature requests are welcome as issues. For a change to a node, open an issue first, so its inputs and outputs are settled before the code is written. See docs/CONTRIBUTING.md.