Discover ComfyUI Extensions & Nodes

ComfyUI-Manager itself is also a custom node.

This node pack offers various detector nodes and detailer nodes that allow you to configure a workflow that automatically enhances facial details. And provide iterative upscaler. NOTE: To use the UltralyticsDetectorProvider, you must install the ComfyUI Impact Subpack separately.

This node pack provides nodes that complement the Impact Pack, such as the UltralyticsDetectorProvider.

This extension provides various nodes to support Lora Block Weight and the Impact Pack. Provides many easily applicable regional features and applications for Variation Seed.

Nodes: ModelSamplerTonemapNoiseTest, TonemapNoiseWithRescaleCFG, ReferenceOnlySimple, RescaleClassifierFreeGuidanceTest, ModelMergeBlockNumber, ModelMergeSDXL, ModelMergeSDXLTransformers, ModelMergeSDXLDetailedTransformers.

This node enables the best performance on NVIDIA RTX™ Graphics Cards (GPUs) for Stable Diffusion by leveraging NVIDIA TensorRT.

Nodes:Stability SD3, Stability Outpainting, Stability Search and Replace, Stability Image Core, Stability Inpainting, Stability Remove Background, Stability Creative Upscale. Add API key to environment variable 'SAI_API_KEY' Alternatively you can write your API key to file 'sai_platform_key.txt' You can also use and/or override the above by entering your API key in the 'api_key_override' field of each node.

Nodes: ColorBlend, ControlLoraSave, GetImageSize. NOTE: Control-LoRA recolor example uses these nodes.

Plug-and-play ComfyUI node sets for making ControlNet hint images.

A custom node suite for Video Frame Interpolation in ComfyUI

Implementation of MDM, MotionDiffuse and ReMoDiffuse into ComfyUI.

A minimalistic implementation of [a/Robust Video Matting (RVM)](https://github.com/PeterL1n/RobustVideoMatting/) in ComfyUI

Proper implementation of ImageMagick - the famous software suite for editing and manipulating digital images to ComfyUI using [a/wandpy](https://github.com/emcconville/wand). NOTE: You need to install ImageMagick, manually.

The CLIPSeg node generates a binary mask for a given input image and text prompt. NOTE:This custom node is a forked custom node with hotfixes applied from the [a/original repository](https://github.com/biegert/ComfyUI-CLIPSeg), which is no longer maintained.

These custom nodes provides features that allow for better control over the effects of the text prompt.

Advanced CLIP Text Encode (if you need A1111 like prompt. you need this. But Cutoff node includes this feature, already.)

This extension contains 6 nodes for ComfyUI that allows for more control and flexibility over the noise.

This extension contains a tiled sampler for ComfyUI. It allows for denoising larger images by splitting it up into smaller tiles and denoising these. It tries to minimize any seams for showing up in the end result by gradually denoising all tiles one step at the time and randomizing tile positions for every step.

It provides the capability to generate CLIP from an image input, unlike unCLIP, which works in all models. (To use this extension, you need to download the required model file from **Install Models**)

A collection of ComfyUI custom nodes to help streamline workflows and reduce total node count.[w/NOTE: This node is originally created by LucianoCirino, but the [a/original repository](https://github.com/LucianoCirino/efficiency-nodes-comfyui) is no longer maintained and has been forked by a new maintainer. To use the forked version, you should uninstall the original version and **REINSTALL** this one.]

a collection of nodes to explore Vector and image manipulation

This extension offers various audio generation tools

Automate calculation depending on image sizes or something you want.

CLIPTextEncodeBLIP: This custom node provides a CLIP Encoder that is capable of receiving images as input.

A node suite for ComfyUI with many new nodes, such as image processing, text processing, and more.

Nodes: ModelMergeByPreset. Merge checkpoint models by preset

Nodes: WAS_PFN_Latent. Perlin Power Fractal Noisey Latents

Power Noise Suite contains nodes centered around latent noise input, and diffusion, as well as latent adjustments.

This custom node provides advanced settings for FreeU.

Nodes:Conditioning (Blend), Inpainting VAE Encode (WAS), VividSharpen. Experimental nodes, or other random extra helper nodes.

openAI suite, String suite, Latent Tools, Image Tools: These custom nodes provide expanded functionality for image and string processing, latent processing, as well as the ability to interface with models such as ChatGPT/DallE-2. NOTE: Currently, this extension does not support the new OpenAI API, leading to compatibility issues.

These custom nodes provides a feature to insert arbitrary inputs through wildcards in the prompt. Additionally, this tool provides features that help simplify workflows, such as VAELoaderDecoder and SimplerSample.

A node suite for ComfyUI that allows you to load image sequence and generate new image sequence with different styles or content.

A collection of post processing nodes for ComfyUI, simply download this repo and drag.

This tool provides a viewer node that allows for checking multiple outputs in a grid, similar to the X/Y Plot extension.

Nodes: Pixel Sort, Swap Color Mode, Solid Color, Glitch This, Add Text To Image, Play Sound, Prettify Prompt, Generate Noise, Flatten Colors

Provide various custom nodes for Latent, Sampling, Model, Loader, Image, Text. This is the fixed version of the original [a/ComfyUI-nodes-hnmr](https://github.com/hnmr293/ComfyUI-nodes-hnmr) by hnmr293.

This is a low-dependency node pack primarily dealing with masks. The author recommends using Impact-Pack instead (unless you specifically have trouble installing dependencies).

Nodes: Image Remove Background (rembg)

Nodes: MergeBlockWeighted

Nodes: image_layering, color_correction, model_router

Auto-MBW for ComfyUI loosely based on sdweb-auto-MBW. Nodes: auto merge block weighted

Run ComfyUI workflows on multiple local GPUs/networked machines. Nodes: Remote images, Local Remote control

Custom node to convert the lantents between SDXL and SD v1.5 directly without the VAE decoding/encoding step.

Upscaling stable diffusion latents using a small neural network.

Testbed for [a/DiT(Scalable Diffusion Models with Transformers)](https://github.com/facebookresearch/DiT). [w/None of this code is stable, expect breaking changes if for some reason you want to use this.]

This extension currently has two sets of nodes - one set for editing the contrast/color of images and another set for saving images as 16 bit PNG files.

This extension aims to add support for various random image diffusion models to ComfyUI.

GGUF Quantization support for native ComfyUI models This is currently very much WIP. These custom nodes provide support for model files stored in the GGUF format popularized by llama.cpp. While quantization wasn't feasible for regular UNET models (conv2d), transformer/DiT models such as flux seem less affected by quantization. This allows running it in much lower bits per weight variable bitrate quants on low-end GPUs.

A custom node for ComfyUI, which can select one or some of images from a batch.

the sampler introduced by [a/hallatore](https://github.com/AUTOMATIC1111/stable-diffusion-webui/discussions/8457) code extracted from [a/smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes).[w/NOTE:ComfyUI-dpmpp_2m_alt-Sampler is renamed to StableDiffusion-dpmpp_2m_alt-Sampler. Please reinstall.]

Manipulation nodes for Image, Latent

Nodes: DeepFloyd, Filter, Select, Save, Decode, Encode, Repeat, Noise, Noise

A simple local text generator for ComfyUI utilizing [a/ExLlamaV2](https://github.com/turboderp/exllamav2). [w/NOTE:Manual package installation is required.]

Image scoring nodes for ComfyUI using PickScore with a batch of images to predict which ones fit a given prompt the best.

Nodes: PoseNode, PainterNode, TranslateTextNode, TranslateCLIPTextEncodeNode, DeepTranslatorTextNode, DeepTranslatorCLIPTextEncodeNode, ArgosTranslateTextNode, ArgosTranslateCLIPTextEncodeNode, PreviewTextNode, HexToHueNode, ColorsCorrectNode, IDENode.

A ComfyUI extension allowing the interrogation of booru tags from images.

This extension provides: Auto Arrange Graph, Workflow SVG, Favicon Status, Image Feed, Latent Upscale By, Lock Nodes & Groups, Lora Subfolders, Preset Text, Show Text, Touch Support, Link Render Mode, Locking, Node Finder, Quick Nodes, Show Image On Menu, Show Text, Workflow Managements, Custom Widget Default Values

Nodes: CalculateAestheticScore, LoadAesteticModel, AesthetlcScoreSorter, ScoreToNumber. Aesthetic score for ComfyUI

This extension offers various pipe nodes, extensive XYZ plotting, fullscreen image viewer based on node history, dynamic widgets, interface customization, and more.

Nodes: Plasma Noise, Random Noise, Greyscale Noise, Pink Noise, Brown Noise, Plasma KSampler

ComfyUI custom nodes to apply various image processing techniques.

A novel weighting scheme for token vectors from CLIP. Allows a wider range of values for the weight. Inspired by Perp-Neg.

Scaled Uniform Noise for Ancestral and Stochastic samplers

Perpendicular CFG for reducing oversaturation issues with high guidance scale values.

ComfyUI nodes for the Ultimate Stable Diffusion Upscale script by Coyote-A.

Unofficial ComfyUI nodes for restart sampling based on the paper 'Restart Sampling for Improving Generative Processes' ([a/paper](https://arxiv.org/abs/2306.14878), [a/repo](https://github.com/Newbeeer/diffusion_restart_sampling))

ComfyUI nodes for the roop A1111 webui script.

ComfyUI nodes based on the paper [a/FABRIC: Personalizing Diffusion Models with Iterative Feedback](https://arxiv.org/abs/2307.10159) (Feedback via Attention-Based Reference Image Conditioning)

Modularized version of Disco Diffusion for use with ComfyUI.

A port of the openpose-editor extension for stable-diffusion-webui. NOTE: Requires [a/this ComfyUI patch](https://github.com/comfyanonymous/ComfyUI/pull/711) to work correctly

NODES: Dynamic Prompts Text Encode, Feeling Lucky Text Encode, Output String

Allor is a plugin for ComfyUI with an emphasis on transparency and performance.

NODES: Face Swap, Film Interpolation, Latent Lerp, Int To Number, Bounding Box, Crop, Uncrop, ImageBlur, Denoise, ImageCompare, RGV to HSV, HSV to RGB, Color Correct, Modulo, Deglaze Image, Smart Step, ...

Implementation of AutoGen inside ComfyUI. This repository is under development, and not everything is functioning correctly yet.

This node allows downloading models directly within ComfyUI for easier use and integration.

Custom nodes for SDXL and SD1.5 including Multi-ControlNet, LoRA, Aspect Ratio, Process Switches, and many more nodes. NOTE: Maintainer is changed to Suzie1 from RockOfFire. [w/Using an outdated version has resulted in reported issues with updates not being applied. Trying to reinstall the software is advised.]

ComfyUI extension that adds undo (and redo) functionality.

Experimental sampler node. Sampling alternates between A and B inputs until only one remains, starting with A. B steps run over a 2x2 grid, where 3/4's of the grid are copies of the original input latent. When the optional mask is used, the region outside the defined roi is copied from the original latent at the end of every step.

Given a set of lists, the node adjusts them so that when used as input to another node all the possible argument permutations are computed.

An 'opinionated' Wave Function Collapse implementation with a set of nodes for comfyui

image and latent quilting nodes for comfyui

Scheduled prompts, scheduled float/int values and wave function nodes for animations and utility. compatable with [a/framesync](https://www.framesync.xyz/) and [a/keyframe-string-generator](https://www.chigozie.co.uk/keyframe-string-generator/) for audio synced animations in Comfyui.

A ComfyUI implementation of Facebook Meta's [a/AITemplate](https://github.com/facebookincubator/AITemplate) repo for faster inference using cpp/cuda. This new repo is behind the old version but is a much more stable foundation to keep AIT online. Please be patient as the repo will eventually include the same features as before. NOTE: You can find the old AIT extension in the legacy channel.

ComfyUI node that pixelizes images.

Nodes such as CLIP Text Encode++ to achieve identical embeddings from stable-diffusion-webui for ComfyUI.

The extension enables large image drawing & upscaling with limited VRAM via the following techniques: 1.Two SOTA diffusion tiling algorithms: [a/Mixture of Diffusers](https://github.com/albarji/mixture-of-diffusers) and [a/MultiDiffusion](https://github.com/omerbt/MultiDiffusion) 2.pkuliyi2015's Tiled VAE algorithm.

ComfyUI reference implementation for [a/PhotoMaker](https://github.com/TencentARC/PhotoMaker) models. NOTE: PhotoMaker V2 is supported.

ComfyUI node for Semantic-aware Guidance based on the [a/paper](https://arxiv.org/abs/2404.05384) 'Rethinking the Spatial Inconsistency in Classifier-Free Diffusion Guidance'

NODES: ImageRewardLoader, ImageRewardScore

Custom nodes for easier use of SDXL in ComfyUI including an img2img workflow that utilizes both the base and refiner checkpoints.

A prompt-generator or prompt-improvement node for ComfyUI, utilizing the power of a language model to turn a provided text-to-image prompt into a more detailed and improved prompt.

custom node for ComfyUI to perform simple math operations

ComfyUI reference implementation for IPAdapter models. The code is mostly taken from the original IPAdapter repository and laksjdjf's implementation, all credit goes to them. I just made the extension closer to ComfyUI philosophy.

Native [a/InstantID](https://github.com/InstantID/InstantID) support for ComfyUI. This extension differs from the many already available as it doesn't use diffusers but instead implements InstantID natively and it fully integrates with ComfyUI. Please note this still could be considered beta stage, looking forward to your feedback.

This extension uses [a/DLib](http://dlib.net/) to calculate the Euclidean and Cosine distance between two faces. NOTE: Install the Shape Predictor, Face Recognition model from the Install models menu.

[a/PuLID](https://github.com/ToTheBeginning/PuLID) ComfyUI native implementation.

This is an (very) advanced and (very) experimental custom node for the ComfyUI. It allows you to iteratively change the blocks weights of Flux models and check the difference each value makes.

A set of custom nodes for creating image grids, sequences, and batches in ComfyUI.

Nodes: Prompt Agent, Prompt Agent (String). This script provides a prompt agent node for the Comfy UI stable diffusion client.

Nodes: Image URL to Text, Image to Text.

Nodes: Submit Image (Parameters), Submit Image. A collection of loaders that use a shared common online data source rather than relying on the files to be present locally.

A ComfyAI submit node to upload images to DoubTech.ai

This extension introduces QR code nodes for the Comfy UI stable diffusion client. NOTE: ComfyUI qrcode extension required.

Nodes: String, Int, Float, Short String, CLIP Text Encode (With Variables), String Format, Short String Format. This extension introduces quality of life improvements by providing variable nodes and shared global variables.

A comprehensive set of custom nodes for ComfyUI, focusing on utilities for image processing, JSON manipulation, model operations and working with object via URLs

Nodes: MSSqlTableNode, MSSqlSelectNode. This extension provides custom nodes to interact with MSSQL.

Nodes: Make Square Node, Interrogate Node, TextEncodeAIO

Provides Math Nodes for ComfyUI. Boolean Logic, Integer Arithmetic, Floating Point Arithmetic and Functions, Vec2, Vec3, and Vec4 Arithmetic and Functions

Tired of manually downloading and moving models, LoRAs, and more to the right places? Sick of scouring Civitai for that one mystical LoRA someone was using to make that cool image? Want to be share a fully reproducable workflow?

Nodes: CLIP Directional Prompt Attention Encode. Direction prompt attention tries to solve the problem of contextual words (or parts of the prompt) having an effect on much later or irrelevant parts of the prompt.

AnimateDiff integration for ComfyUI, adapts from sd-webui-animatediff. [w/You only need to download one of [a/mm_sd_v14.ckpt](https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v14.ckpt) | [a/mm_sd_v15.ckpt](https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15.ckpt). Put the model weights under %%ComfyUI/custom_nodes/comfyui-animatediff/models%%. DO NOT change model filename.]

SDXL Prompt Styler is a node that enables you to style prompts based on predefined templates stored in a JSON file.

These custom nodes provide a variety of customized prompt stylers based on [a/twri/SDXL Prompt Styler](https://github.com/twri/sdxl_prompt_styler).

This custom node provides the capability to manipulate multiple string inputs.

Face Detailer is a custom node for the 'ComfyUI' framework inspired by !After Detailer extension from auto1111, it allows you to detect faces using Mediapipe and YOLOv8n to create masks for the detected faces.

Nodes for convenient prompt editing, making many common operations prompt-controllable

Attempts to implement [a/CADS](https://arxiv.org/abs/2310.17347) for ComfyUI. Credit also to the [a/A1111 implementation](https://github.com/v0xie/sd-webui-cads/tree/main) that I used as a reference.

Nodes:MUJinjaRender, MUSimpleWildcard

An implementation of adaptive guidance for ComfyUI See [a/https://bcv-uniandes.github.io/adaptiveguidance-wp](https://bcv-uniandes.github.io/adaptiveguidance-wp)

A very barebones mostly-copypaste implementation of [a/https://github.com/xie-lab-ml/Golden-Noise-for-Diffusion-Models](https://github.com/xie-lab-ml/Golden-Noise-for-Diffusion-Models)

Nodes: P2LDGAN. This integrates P2LDGAN into ComfyUI. P2LDGAN extracts lineart from input images. [w/To use this extension, you need to download the [a/p2ldgan model](https://drive.google.com/file/d/1To4V_Btc3QhCLBWZ0PdSNgC1cbm3isHP) and save it in the %%ComfyUI/custom_nodes/comfyui-p2ldgan/checkpoints%% directory.]

Nodes: JWInteger, JWFloat, JWString, JWImageLoadRGB, JWImageResize, ...

Nodes: Random Prompts, Combinatorial Prompts, I'm Feeling Lucky, Magic Prompt, Jinja2 Templates. ComfyUI-DynamicPrompts is a custom nodes library that integrates into your existing ComfyUI Library. It provides nodes that enable the use of Dynamic Prompts in your ComfyUI.

Nodes: InpaintMediapipe. This node provides a simple interface to inpaint.

Nodes: Remove Image Background (abg). A Anime Background Remover node for comfyui, based on this hf space, works same as AGB extention in automatic1111.

Nodes: Prompt With Style, Prompt With SDXL, Resize Image for SDXL, Save Image With Prompt Data, HaldCLUT, Empty Latent Ratio Select/Custom SDXL

node color customization, custom colors, dot reroutes, link rendering options, straight lines, group freezing, node pinning, automated arrangement of nodes, copy image [w/failfast-comfyui-extensions is renamed to blibla-comfyui-extensions. Please resintall to this.]

Nodes: AstropulsePixelDetector, BackgroundRemover, ImagePadForBetterOutpaint, InpaintingPipelineLoader, Inpainting, ...

Nodes: Checkpoint Loader with Name, Save Prompt Info, Outpaint to Image, CLIP Positive-Negative, SDXL Quick Empty Latent, Empty Latent by Ratio, Time String, SDXL Steps, SDXL Resolutions ...

Nodes for scheduling ControlNet strength across timesteps and batched latents, as well as applying custom weights and attention masks.

A forked repository that actively maintains [a/AnimateDiff](https://github.com/ArtVentureX/comfyui-animatediff), created by ArtVentureX. Improved AnimateDiff integration for ComfyUI, adapts from sd-webui-animatediff. [w/Download one or more motion models from [a/Original Models](https://huggingface.co/guoyww/animatediff/tree/main) | [a/Finetuned Models](https://huggingface.co/manshoety/AD_Stabilized_Motion/tree/main). See README for additional model links and usage. Put the model weights under %%ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models%%. You are free to rename the models, but keeping original names will ease use when sharing your workflow.]

Nodes related to video workflows

The Fast and Simple 'roop-like' Face Swap Extension Node for ComfyUI, based on ReActor (ex Roop-GE) SD-WebUI Face Swap Extension

This extension collapses 'future warning' messages in your Console

Nodes:FaceSwapNode. Very basic custom node to enable face swapping in ComfyUI. (roop)

Nodes: LoadImageFromPath. Load Image From Path loads the image from the source path and does not have such problems.

One Button Prompt has a prompt generation node for beginners who have problems writing a good prompt, or advanced users who want to get inspired. It generates an entire prompt from scratch. It is random, but controlled. You simply load up the script and press generate, and let it surprise you.

QR generation within ComfyUI. Contains nodes suitable for workflows from generating basic QR images to techniques with advanced QR masking.

A set of ComfyUI nodes to quickly test generated QR codes for scannability. A companion project to ComfyQR.

This node manipulates the pixel art image in ways that it should look pixel perfect (downscales, changes palette, upscales etc.).

NODES:Eagle Image Node for PNGInfo, SDXL Resolution Presets (ws), SDXL Prompt Styler, SDXL Prompt Styler Advanced

This extension allows users to load styles from a CSV file, primarily for migration purposes from the automatic1111 Stable Diffusion web UI.

An extension to ComfyUI that introduces logic nodes and conditional rendering capabilities.

Nodes: Range(Step), Range(Num Steps), List Length, Image Overlay, Stack Images, Empty Images, Join Image Lists, Join Float Lists. This extension provides various list manipulation nodes

Nodes: Int, Float, String, Operation, Checkpoint

Nodes: Build Gif, Special CLIP Loader. It offers various manipulation capabilities for the internal operations of the prompt.

This extension provides a custom node that allows the use of [a/Matte Anything](https://github.com/hustvl/Matte-Anything) in ComfyUI.

Nodes: KepRotateImage

Nodes: TAESD VAE Decode

ComfyUI-KepOpenAI is a user-friendly node that serves as an interface to the GPT-4 with Vision (GPT-4V) API. This integration facilitates the processing of images coupled with text prompts, leveraging the capabilities of the OpenAI API to generate text completions that are contextually relevant to the provided inputs.

Nodes: Fans Styler (Max 10 Style), Fans Text Concat (Until 10 text), Fans Prompt Styler Postive (Can replace {prompt} word in your csv files), Fans Prompt Styler Negative (With sentence structure).

ComfyUI custom nodes to apply various latent travel techniques.

A set of custom nodes to perform image 2 image functions in ComfyUI.

Nodes: Empty Latent Randomizer (9 Inputs)

Nodes: NoisyLatentPerlin. This allows to create latent spaces filled with perlin-based noise that can actually be used by the samplers.

Nodes:LoadLoraWithTags. Save/Load trigger words for loras from a json and auto fetch them on civitai if they are missing.

A few nodes to mix sigmas and a custom scheduler that uses phi, then one using eval() to be able to schedule with custom formulas.

My own version 'from scratch' of a self-rescaling CFG. It isn't much but it's honest work. TLDR: set your CFG at 8 to try it. No burned images and artifacts anymore. CFG is also a bit more sensitive because it's a proportion around 8. Low scale like 4 also gives really nice results since your CFG is not the CFG anymore. Also in general even with relatively low settings it seems to improve the quality.

The main node makes your conditioning go towards similar concepts so to enrich your composition or further away so to make it more precise. It gathers similar pre-cond vectors for as long as the cosine similarity score diminishes. If it climbs back it stops. This allows to set a relative direction to similar concepts. There are examples at the end but [a/you can also check this imgur album](https://imgur.com/a/WvPd81Y) which demonstrates the capability of improving variety.

Provides the ability to set the temperature for both UNET and CLIP. For ComfyUI.

Allows to sample without generating any uncond with Stable Diffusion!

A set of nodes to prepare the noise predictions before the CFG function

A powerful anti-burn allowing much higher CFG scales for latent diffusion models (for ComfyUI)

Heuristic modification of the Heun sampler using a custom function based on normalized distances. For ComfyUI.

Nodes: Various nodes to handle SDXL Resolutions, SDXL Basic Settings, IP Adapter Settings, Revision Settings, SDXL Prompt Styler, Crop Image to Square, Crop Image to Target Size, Get Date-Time String, Resolution Multiply, Largest Integer, 5-to-1 Switches for Integer, Images, Latents, Conditioning, Model, VAE, ControlNet

ComfyUI nodes primarily for seed and filename generation

Nodes: KSampler With Refiner (Fooocus). The KSampler from [a/Fooocus](https://github.com/lllyasviel/Fooocus) as a ComfyUI node [w/NOTE: This patches basic ComfyUI behaviour - don't use together with other samplers. Or perhaps do? Other samplers might profit from those changes ... ymmv.]

A ComfyUI custom node to read LoRA tag(s) from text and load it into checkpoint model.

Nodes: Seed, Reroute, Context, Lora Loader Stack, Context Switch, Fast Muter. These custom nodes helps organize the building of complex workflows.

It provides language settings. (Contribution from users of various languages is needed due to the support for each language.)

Improve the interactive experience of using ComfyUI, such as making the loading of ComfyUI models more intuitive and making it easier to create model thumbnails

Bridge between ComfyUI and blender's ComfyUI-BlenderAI-node addon.

This project is used to enable [a/ToonCrafter](https://github.com/ToonCrafter/ToonCrafter) to be used in ComfyUI. You can use it to achieve generative keyframe animation And use it in Blender for animation rendering and prediction

Nodes: BilboX's PromptGeek Photo Prompt. This provides a convenient way to compose photorealistic prompts into ComfyUI. Post-Processing: adds various post processing effects. Bonus: Option to show a distant server shutdown menu.

All the tools you need to save images with their generation metadata on ComfyUI. Compatible with Civitai & Prompthero geninfo auto-detection. Works with png, jpeg and webp.

Nodes:Send Webp Image to Eagle. This is an extension node for ComfyUI that allows you to send generated images in webp format to Eagle. This extension node is a re-implementation of the Eagle linkage functions of the previous ComfyUI-send-Eagle node, focusing on the functions required for this node.

Nodes:SDXL Empty Latent Image. An extension node for ComfyUI that allows you to select a resolution from the pre-defined json files and output a Latent Image.

ComfyUI version of https://github.com/laksjdjf/pfg-webui. (To use this extension, you need to download the required model file from **Install Models**)

The custom nodes of laksjdjf have been integrated into the node pack of cgem156🍌. NOTE:This includes the attention couple feature.

Nodes:Apply CDTuner, Apply Negapip. This extension provides the [a/CD(Color/Detail) Tuner](https://github.com/hako-mikan/sd-webui-cd-tuner) and the [a/Negative Prompt in the Prompt](https://github.com/hako-mikan/sd-webui-negpip) features.

This extension node is intended for the use of LCM conversion for SSD-1B-anime. It does not guarantee operation with the original LCM (as it cannot load weights in the current version). To take advantage of fast generation with LCM, a node for using TAESD as a decoder is also provided. This is inspired by ComfyUI-OtherVAEs.

This is a repository for using LoRTnoC (LoRA with hint block of ControlNet) on ComfyUI. NOTE:Please place the model file in the same location as controlnet. (Is this too arbitrary?)

Nodes:CLIP Text Encode (Batch), String Input, Batch String

Nodes:Asymmetric_Tiling_KSampler.

Pause image generation when GPU temperature exceeds threshold.