Skip to content

ComfyAssets/ComfyUI-KikoTools

BranchesTags

Repository files navigation

ComfyUI-KikoTools

License Python ComfyUI Tests Code Quality

A modular collection of essential custom ComfyUI nodes missing from the standard release.

ComfyUI-KikoTools provides carefully crafted, production-ready nodes under the "ComfyAssets" category. Each tool is built with clean interfaces, thorough testing, and optimized performance for SDXL and FLUX workflows.

This project started out of frustration with keeping ComfyUI up to date and waiting for dozens of custom nodes to update—most of which I didn’t even use. After taking a hard look at my workflow, I realized I only needed one or two features from these nodes, many of which were abandoned or stuck in maintenance mode.

I tried forking, patching, and submitting merge requests, but eventually decided to create my own curated collection of tools—fully supported and maintained by me. That’s how Kiko’s Tools was born.

I’m sharing them here with the community, and I hope you find them as useful as I do.

🚀 Features

✨ Current Tools

Tool Description Category
📐 Resolution Calculator Calculate upscaled dimensions with model optimization 🖼️ Resolution
📏 Width Height Selector Preset-based dimension selection with visual swap 🖼️ Resolution
🎲 Seed History Advanced seed tracking with interactive history 🌱 Seeds
⚙️ Sampler Combo Unified sampling configuration interface 🌀 Samplers
📦 Empty Latent Batch Create empty latent batches with preset support 📦 Latents
💾 Kiko Save Image Enhanced image saving with popup viewer 💾 Images
📋 Display Text Smart text display with prompt detection 👁️ Display
🤖 Gemini Prompt Engineer AI-powered image analysis and prompt generation 🧠 Prompts
🔍 Display Any Universal debugging tool for any data type 👁️ Display
🖼️ Image to Multiple Of Adjust dimensions to multiples for compatibility 🖼️ Resolution
📉 Image Scale Down By Scale images down by a factor with quality preservation 🖼️ Resolution
🎬 Film Grain Add realistic film grain effects to images 💾 Images
🔤 Embedding Autocomplete Smart autocomplete for embeddings, LoRAs, and tags 🔧 Utils
🧹 Kiko Purge VRAM Intelligent VRAM management with detailed reporting 🛠️ Utils
📂 Local Image Loader Visual gallery browser for local media files 💾 Images

🧰 xyz-helpers Tools

Advanced parameter management tools adapted from comfyui-essentials-nodes (now in maintenance mode):

Tool Description Category
🎛️ Flux Sampler Params FLUX-optimized parameter generator with batch support 🧰 xyz-helpers
📁 LoRA Folder Batch Batch process multiple LoRAs from folders 🧰 xyz-helpers
📊 Plot Parameters Visualize parameter effects with graphs 🧰 xyz-helpers
🎯 Sampler Select Helper Intelligent sampler selection with recommendations 🧰 xyz-helpers
📅 Scheduler Select Helper Optimal scheduler selection for samplers 🧰 xyz-helpers
✍️ Text Encode Sampler Params Combined text encoding and parameter management 🧰 xyz-helpers

📐 Resolution Calculator

Calculate upscaled dimensions from image or latent inputs with precision.

  • Smart Input Handling: Works with both IMAGE and LATENT tensors
  • Model Optimized: Specific optimizations for SDXL (~1MP) and FLUX (0.2-2MP) models
  • Constraint Enforcement: Automatically ensures dimensions divisible by 8
  • Flexible Scaling: Supports scale factors from 1.0x to 8.0x with 0.1 precision
  • Aspect Ratio Preservation: Maintains original proportions during scaling

Use Cases:

  • Calculate target dimensions for upscaler nodes
  • Plan memory usage for large generations
  • Ensure ComfyUI tensor compatibility
  • Optimize batch processing workflows

Resolution Calculator Example

📏 Width Height Selector

Advanced preset-based dimension selection with visual swap button.

  • 26 Curated Presets: SDXL, FLUX, and Ultra-Wide optimized resolutions
  • Smart Categories: Organized by model type and aspect ratio
  • Visual Swap Button: Modern blue button for quick orientation changes
  • Intelligent Swapping: Preset-aware orientation switching
  • Custom Support: Manual dimension input with validation

Use Cases:

  • Quick dimension selection for different models
  • Consistent aspect ratios across workflows
  • Mobile and ultra-wide format support
  • Integration with upscaling pipelines

🎲 Seed History

Advanced seed tracking with interactive history management and UI.

  • Automatic Tracking: Monitors all seed changes with timestamps
  • Interactive History: Click any historical seed to reload instantly
  • Smart Deduplication: 500ms window prevents duplicate rapid additions
  • Persistent Storage: History survives browser sessions and ComfyUI restarts
  • Auto-Hide UI: Clean interface that hides after 2.5 seconds of inactivity
  • Visual Feedback: Toast notifications and selection highlighting

Use Cases:

  • Track promising seeds during creative exploration
  • Quickly return to successful generation parameters
  • Maintain reproducibility across sessions
  • Compare results from different seeds efficiently

![Seed History functionality is shown in various workflow examples]

⚙️ Sampler Combo

Unified sampling configuration interface combining sampler, scheduler, steps, and CFG.

  • All-in-One Interface: Single node for complete sampling configuration
  • Smart Recommendations: Optimal settings suggestions per sampler type
  • Compatibility Validation: Ensures sampler/scheduler combinations work well
  • Intelligent Defaults: Context-aware parameter recommendations
  • Range Validation: Prevents invalid parameter combinations
  • Comprehensive Tooltips: Detailed guidance for each parameter

Use Cases:

  • Simplify complex sampling workflows
  • Ensure optimal sampler/scheduler combinations
  • Reduce node clutter in workflows
  • Quick sampling parameter experimentation

📦 Empty Latent Batch

Advanced empty latent creation with preset support and batch processing capabilities.

  • Preset Integration: 26 curated resolution presets with model optimization
  • Batch Processing: Create multiple empty latents (1-64) in a single operation
  • Visual Swap Button: Interactive blue button for quick dimension swapping
  • Smart Validation: Automatic dimension sanitization for VAE compatibility
  • Memory Estimation: Built-in memory usage calculation and warnings
  • Model-Aware Presets: SDXL (~1MP), FLUX (high-res), and Ultra-wide options

Use Cases:

  • Initialize batch processing workflows efficiently
  • Create consistent latent dimensions across model types
  • Optimize memory usage with batch size planning
  • Quick preset-based latent generation for different aspect ratios

Empty Latent Batch Example

💾 Kiko Save Image

Enhanced image saving with format selection, quality control, and floating popup viewer.

  • Multiple Format Support: Save as PNG, JPEG, or WebP with format-specific optimizations
  • Advanced Quality Controls: JPEG/WebP quality (1-100), PNG compression (0-9), WebP lossless mode
  • Floating Popup Viewer: Draggable, resizable window that shows saved images immediately
  • Interactive Previews: Click any image to open in new tab, download individual images
  • Batch Selection: Multi-select images for bulk actions (open all, download all)
  • Format-Specific Settings: Quality indicators, file size display, compression info
  • Smart UI: Auto-hide/show, minimize/maximize, roll-up functionality
  • Popup Toggle: Enable/disable popup viewer per save operation

Kiko Save Image Example

📋 Display Text

Advanced text display node with intelligent formatting and enhanced user interaction.

  • Smart Prompt Detection: Automatically detects positive/negative prompt pairs and displays in split view
  • Text Wrapping: Proper word wrapping that reflows when node is resized
  • Scrollable Content: Mouse wheel scrolling for long texts with visual scroll indicators
  • Copy Functionality: Always-visible copy button with visual feedback
  • Split View Mode: Automatic detection and formatting of SDXL-style prompts
  • Responsive Design: Content adapts to node resizing with proper text reflow
  • Clean Formatting: Strips prompt labels when copying for direct use

Use Cases:

  • Display generated prompts with proper formatting
  • Compare positive and negative prompts side-by-side
  • Copy prompts without manual label removal
  • View long text content with proper wrapping
  • Debug prompt generation workflows

Display Text Example

🤖 Gemini Prompt Engineer

AI-powered image analysis using Google's Gemini to generate optimized prompts for various models.

  • Multi-Model Support: Generate prompts for FLUX, SDXL, Danbooru, and Video generation
  • Smart Analysis: Gemini analyzes composition, style, lighting, colors, and details
  • Format-Specific Output: FLUX artistic prompts, SDXL positive/negative pairs, Danbooru tags, Video motion descriptions
  • Custom System Prompts: Override templates with your own analysis instructions
  • Flexible API Key Management: Environment variable, config file, or direct input
  • Visual Status Feedback: Real-time processing indicators and error states
  • Help Integration: Built-in setup guide and documentation
  • Dynamic Model Refresh: Fetch latest Gemini models with refresh button
  • Model Caching: Persistent model list storage for offline access
  • Enhanced SDXL Prompts: Improved formatting with layered structure and quality boosters

Use Cases:

  • Reverse-engineer prompts from reference images
  • Convert artistic descriptions between different AI model formats
  • Generate consistent style descriptions across workflows
  • Create detailed scene breakdowns for complex compositions
  • Analyze and replicate lighting/mood from existing artwork
  • Access latest Gemini models including 2.0 and 2.5 versions

Gemini Prompt Example

🔍 Display Any

Universal debugging node that displays any type of input value or tensor information.

  • Universal Input Acceptance: Works with any data type (tensors, strings, numbers, lists, dicts)
  • Two Display Modes: Raw value showing string representation, or tensor shape extraction
  • Nested Structure Support: Finds tensors within complex nested data structures
  • Debugging Focus: Essential tool for understanding data flow and tensor dimensions
  • Clean Output: Formatted display directly in ComfyUI interface

Use Cases:

  • Debug tensor dimensions at any point in workflow
  • Inspect latent space data structures
  • View metadata and configuration objects
  • Track shape changes through processing nodes
  • Understand complex data types in ComfyUI

Display Any Example

🖼️ Image to Multiple Of

Adjusts image dimensions to be multiples of a specified value for model compatibility.

  • Dimension Adjustment: Ensures image dimensions are multiples of specified value (e.g., 64, 128)
  • Two Processing Methods: Center crop for minimal loss, or rescale to fit
  • Model Compatibility: Essential for models requiring specific dimension constraints
  • Flexible Multiple Values: Support from 1 to 256 with 16-step increments
  • Preserves Quality: Smart processing maintains image quality

Use Cases:

  • Prepare images for VAE encoding (multiple of 8 requirement)
  • Ensure compatibility with specific model architectures
  • Standardize dimensions across image batches
  • Fix dimension errors in complex workflows
  • Optimize for tiled processing requirements

Image to Multiple Of Example

📉 Image Scale Down By

Efficiently scale images down by a specified factor with quality preservation.

  • Proportional Scaling: Reduces both width and height by the same factor
  • Quality Preservation: Uses bilinear interpolation with antialiasing
  • Batch Support: Process multiple images simultaneously
  • Memory Efficient: Optimized for large image batches
  • Flexible Factor: Scale from 0.01x to 1.0x with 0.01 precision

Use Cases:

  • Create thumbnails or preview images
  • Reduce memory usage for large workflows
  • Generate image pyramids for multi-scale processing
  • Quick downsampling for performance optimization
  • Prepare images for web display or transmission

🎬 Film Grain

Add realistic analog film grain effects to generated images.

  • Realistic Grain Simulation: Mimics actual film photography characteristics
  • Grain Size Control: Fine to coarse grain patterns (0.25x to 2.0x)
  • Intensity Adjustment: Variable strength from subtle to pronounced (0-10)
  • Color Saturation: Monochrome to full color grain (0-2)
  • Shadow Lifting (Toe): Film-like shadow response curves
  • Red Multiplier: Adjust red channel independently for vintage looks
  • Alpha Preservation: Maintains transparency when present
  • ITU-R BT.709 Color Space: Professional color handling

Use Cases:

  • Add vintage film aesthetic to AI-generated images
  • Create cinematic looks with authentic grain patterns
  • Simulate different film stocks (35mm, 16mm, etc.)
  • Add texture to overly smooth AI renders
  • Match grain from reference photography

🎛️ Flux Sampler Params

FLUX-optimized parameter generator with intelligent batch processing capabilities.

  • FLUX-Specific Tuning: Optimized guidance, shift values, and step counts for FLUX models
  • Batch Parameter Testing: Generate multiple parameter sets for comparative analysis
  • LoRA Integration: Seamlessly combine with LoRA Folder Batch for comprehensive testing
  • Smart Defaults: Pre-configured optimal settings based on extensive FLUX testing
  • Range Syntax Support: Use start...end+step notation for parameter sweeps

Use Cases:

  • Test different guidance and shift value combinations
  • Batch process with varying parameters
  • Optimize FLUX generation quality
  • Integrate with LoRA testing workflows

📁 LoRA Folder Batch

Automated batch processing for multiple LoRA models from folders.

  • Automatic Scanning: Discovers all .safetensors files in specified folders
  • Natural Epoch Sorting: Intelligently sorts training epochs (epoch_004, epoch_020, etc.)
  • Pattern Filtering: Include/exclude LoRAs using powerful regex patterns
  • Flexible Strength Control: Single, multiple, or range-based strength values
  • Batch Modes: Sequential or combinatorial strength application
  • Epoch Detection: Automatically extracts epoch numbers from filenames

Use Cases:

  • Test all epochs from a training run
  • Compare different LoRA versions
  • Evaluate strength variations
  • Batch process style transfers

LoRA Folder Batch Example

📊 Plot Parameters

Visual analysis tool for understanding parameter relationships and effects.

  • Multiple Plot Types: Line, bar, scatter, and heatmap visualizations
  • Parameter Correlation: Analyze relationships between settings and quality
  • Statistical Analysis: Calculate means, deviations, and trends
  • Export Capabilities: Save plots as images or CSV data
  • Real-time Updates: Dynamic graph generation during workflow execution

Use Cases:

  • Visualize parameter impact on quality
  • Compare batch generation results
  • Analyze optimal parameter ranges
  • Document generation experiments

🎯 Sampler Select Helper

Intelligent sampler selection with model-aware recommendations.

  • Model Detection: Automatic identification of SDXL, SD1.5, or FLUX models
  • Quality Presets: Fast, balanced, quality, and extreme presets
  • Compatibility Checking: Ensures optimal sampler-scheduler pairs
  • Performance Profiles: Pre-configured settings for different use cases
  • Dynamic Discovery: Adapts to newly available samplers

Use Cases:

  • Automatic optimal sampler selection
  • Quick quality vs speed adjustments
  • Model-specific optimization
  • A/B testing different samplers

📅 Scheduler Select Helper

Optimal scheduler selection based on sampler and model requirements.

  • Sampler-Aware: Recommends best schedulers for each sampler
  • Noise Schedule Visualization: Preview and compare schedule curves
  • Model Optimization: Specific tuning for SDXL, SD1.5, and FLUX
  • Schedule Types: Smooth, sharp, linear, and custom curves
  • Beta Schedule Support: Advanced control with custom beta values

Use Cases:

  • Find optimal scheduler for your sampler
  • Visualize noise reduction curves
  • Compare different schedule types
  • Fine-tune generation behavior

✍️ Text Encode Sampler Params

Unified interface for text encoding and sampler parameter management.

  • All-in-One Node: Combine prompt encoding with sampling configuration
  • Template System: Pre-configured settings for portraits, landscapes, etc.
  • Prompt Syntax Support: Wildcards, emphasis, and alternation
  • Batch Processing: Handle multiple prompts efficiently
  • Model-Aware Encoding: Optimize for different text encoders

Use Cases:

  • Streamline text-to-image workflows
  • Apply consistent settings across prompts
  • Quick template-based generation
  • Batch prompt processing

📂 Local Image Loader

Visual gallery browser for loading local images, videos, and audio files directly into ComfyUI workflows.

  • Visual Gallery Interface: Browse files with thumbnail previews in a masonry layout
  • Multi-Media Support: Load images (JPG, PNG, GIF, WebP), videos (MP4, WebM, MOV), and audio files (MP3, WAV, OGG, FLAC)
  • Quick Navigation: Navigate folders with breadcrumb path and parent directory button
  • Responsive Layout: Automatically adjusts thumbnail grid to available space
  • Metadata Extraction: Reads embedded prompt and workflow data from generated images
  • Saved Paths: Remember frequently used directories for quick access
  • Double-Click Preview: Open full-size media in new browser tab
  • Smart Sorting: Sort by name, date, or file size in ascending or descending order
  • Pagination Support: Efficiently browse large directories with page controls

Use Cases:

  • Load reference images from local folders for img2img workflows
  • Browse and select from collections of generated images
  • Quickly access frequently used asset directories
  • Extract prompts and settings from previously generated images
  • Preview media files before loading into workflow

🔤 Embedding Autocomplete

Intelligent autocomplete for embeddings, LoRAs, and custom tags in text prompts.

Embedding Autocomplete LoRA Autocomplete Tag Autocomplete

This feature is an enhanced fork of the autocomplete functionality from ComfyUI-Custom-Scripts by pythongosssss. We've modernized the codebase, fixed existing bugs, and added robust security features.

Key Features:

  • Smart Triggers: Type embedding: for embeddings, <lora: for LoRAs, or just start typing for tags
  • Custom Word Lists: Load tag databases (like Danbooru tags) from any URL
  • Security First: Comprehensive input validation prevents code injection and XSS attacks
  • Flexible Settings: Customize triggers, auto-insert commas, replace underscores, and more
  • Performance Optimized: Handles 100,000+ tags smoothly with frequency-based sorting
  • Visual Polish: Clean UI with proper scrolling, keyboard navigation, and type indicators

Settings Include:

  • Enable/disable autocomplete for embeddings, LoRAs, and custom tags
  • Configurable trigger phrases (e.g., emb:, lora:, custom shortcuts)
  • Auto-insert comma after completion
  • Replace underscores with spaces in tags
  • Choose insertion keys (Tab, Enter, or both)
  • Load custom word lists from URLs with security validation

Security Features:

  • Validates all loaded content to prevent script injection
  • Blocks dangerous patterns (eval, innerHTML, script tags, etc.)
  • Safe character whitelist for tags
  • File size limits to prevent memory exhaustion
  • Clear error messages for rejected content

Credits:

  • Original autocomplete concept by pythongosssss
  • Enhanced and modernized by KikoTools team

🧹 Kiko Purge VRAM

Intelligent GPU memory management with threshold-based triggering and detailed reporting.

Key Features:

  • 4 Purge Modes:
    • soft: Basic garbage collection and cache clearing
    • aggressive: Multiple GC passes with full CUDA cache clearing
    • models_only: Unload all models and clear model cache
    • cache_only: Clear CUDA cache without garbage collection
  • Smart Thresholds: Only purge when memory usage exceeds specified MB limit
  • Detailed Reporting: Shows before/after memory usage, freed MB, and timing
  • Passthrough Design: Acts as workflow checkpoint without disrupting data flow
  • CPU Fallback: Gracefully handles non-CUDA environments

Use Cases:

  • Free memory between heavy processing stages
  • Prevent OOM errors in complex workflows
  • Debug memory usage patterns
  • Optimize multi-model workflows
  • Clean up after batch processing

Parameters:

  • anything: Any input (passed through unchanged)
  • mode: Purge strategy selection
  • report_memory: Generate detailed memory statistics
  • memory_threshold_mb: Only purge if usage exceeds (0 = always purge)

Example Output:

Memory usage (5000.0 MB) exceeds threshold (4000 MB)

Memory Purge Report
-------------------
Mode: soft
Memory Freed: 2500.0 MB
Before: 5000.0 MB used (62.5%)
After: 2500.0 MB used (31.3%)
Time: 150.0ms

💾 Kiko Save Image Features

Use Cases:

  • Quick preview and management of saved images without file browser navigation
  • Compare multiple format outputs side-by-side (PNG vs JPEG vs WebP)
  • Batch download or open selected images efficiently
  • Monitor file sizes and compression effectiveness in real-time
  • Streamlined workflow for iterative image generation and saving

Why Better Than Standard Save Image:

  • Immediate Visual Feedback: See your saved images instantly without opening file explorer
  • Multi-Format Flexibility: Choose optimal format for your use case (PNG for quality, JPEG for size, WebP for modern efficiency)
  • Advanced Compression Control: Fine-tune file sizes with format-specific quality settings
  • Batch Operations: Handle multiple images efficiently with selection and bulk actions
  • Modern UI: Floating, draggable interface that doesn't interrupt your workflow
  • Smart Memory Usage: File size indicators help optimize storage and sharing
  • One-Click Access: Direct image opening in browser tabs for quick sharing or review

🔧 Architecture Highlights

  • Modular Design: Each tool is self-contained and independently testable
  • Test-Driven Development: 100% test coverage with comprehensive unit tests
  • Clean Interfaces: Standardized input/output patterns across all tools
  • Separation of Concerns: Clear distinction between logic, UI, and integration layers
  • SOLID Principles: Extensible architecture following software engineering best practices

📦 Installation

ComfyUI Manager (Recommended)

  1. Open ComfyUI Manager
  2. Search for "ComfyUI-KikoTools"
  3. Click Install
  4. Restart ComfyUI

Manual Installation

cd ComfyUI/custom_nodes/
git clone https://github.com/ComfyAssets/ComfyUI-KikoTools.git
cd ComfyUI-KikoTools
pip install -r requirements-dev.txt

Restart ComfyUI and look for ComfyAssets nodes in the node browser.

🎯 Quick Start

Resolution Calculator Example

Image Loader → Resolution Calculator → Upscaler
             ↘ scale_factor: 1.5    ↗

Input: 832×1216 (SDXL portrait format) Scale: 1.5x Output: 1248×1824 (ready for upscaling)

Width Height Selector Example

Width Height Selector → EmptyLatentImage → Model
preset: "1920×1080"   ↘ 1920×1080      ↗
[swap button]

Preset: FLUX HD (1920×1080) Output: 1920×1080 (16:9 cinematic) Swap Button: Click to get 1080×1920 (9:16 portrait)

Seed History Example

Seed History → KSampler → VAE Decode → Save Image
🎲 12345    ↘ seed    ↗
[History UI: 54321, 99999, 11111...]

Current Seed: 12345 History: Auto-tracked previous seeds with timestamps Interaction: Click any historical seed to reload instantly

Sampler Combo Example

Sampler Combo → KSampler → VAE Decode → Save Image
⚙️ All Settings ↘ sampler/scheduler/steps/cfg ↗

Configuration: euler, normal, 20 steps, CFG 7.0 Output: Complete sampling configuration in one node Smart Features: Recommendations and compatibility validation

Empty Latent Batch Example

Empty Latent Batch → KSampler → VAE Decode → Kiko Save Image
📦 preset: "1024×1024" ↘ batch latents ↗                ↘ popup viewer ↗
   batch_size: 4
   [swap button]

Preset: SDXL Square (1024×1024) Batch Size: 4 empty latents Output: 4×4×128×128 latent tensor ready for sampling Swap Button: Click to switch to any available swapped preset

Kiko Save Image Example

Generate Image → Kiko Save Image → Floating Popup Viewer
📷 output       ↘ format: WEBP   ↘ draggable window ↗
                  quality: 85
                  [popup: enabled]

Format: WebP (efficient compression, modern format) Quality: 85% (balanced size/quality) Popup Viewer: Floating, draggable window with saved images Features: Click images to open in new tabs, download individual files, batch selection Advantages: Immediate preview without file explorer, multi-format comparison, advanced quality controls

Display Text Example

Gemini Prompt → Display Text → Copy to Clipboard
📋 SDXL prompt ↘ auto-split  ↘ [📋 Positive] [📋 Negative]
                view          → formatted display

Input: Text with "Positive prompt:" and "Negative prompt:" sections Output: Split view with individual copy buttons Features: Text wrapping, scrolling, responsive resizing Smart Detection: Automatically formats SDXL-style prompts

Gemini Prompt Engineer Example

Load Image → Gemini Prompt → Display Text → Text Generation Model
🖼️ reference ↘ type: SDXL   ↘ split view  ↘ "detailed portrait..."
               [Refresh Models]             → SDXL model

Input: Reference image for style analysis Prompt Type: SDXL (positive/negative pairs with layered structure) Model Selection: Dynamic list with latest Gemini models (2.0, 2.5) Output: Optimized prompts following community best practices API: Requires Gemini API key (free tier available) Refresh: Click button to fetch latest available models

Display Any Example

Any Node → Display Any → Debug Output
🔍 tensor  ↘ mode: shape ↘ "[[1, 3, 512, 512]]"

Input: Any data type (image, latent, config, etc.) Mode: "raw value" or "tensor shape" Output: Formatted display of value or tensor dimensions Use Case: Debug workflows, inspect data structures

Image to Multiple Of Example

Load Image → Image to Multiple Of → VAE Encode → KSampler
🖼️ 513×769  ↘ multiple: 64    ↘ 512×768     → latent
              method: crop

Input: Image with arbitrary dimensions Multiple Of: 64 (common for VAE compatibility) Method: "center crop" or "rescale" Output: Adjusted image with compatible dimensions

Common Workflows

SDXL Portrait Upscaling 
{
  "workflow": "Load SDXL portrait → Calculate 1.5x dimensions → Feed to upscaler",
  "input_resolution": "832×1216",
  "scale_factor": 1.5,
  "output_resolution": "1248×1824",
  "memory_efficient": true
}
FLUX Batch Processing 
{
  "workflow": "Generate latents → Calculate target size → Batch upscale",
  "input_resolution": "1024×1024",
  "scale_factor": 2.0,
  "output_resolution": "2048×2048",
  "batch_optimized": true
}
LoRA Testing with xyz-helpers 
{
  "workflow": "Scan LoRA folder → Apply strength ranges → Generate grid → Plot parameters",
  "strength_range": "0.9...1.2+0.1",
  "batch_mode": "combinatorial",
  "features": ["automatic epoch sorting", "parameter visualization", "batch generation"]
}

Example workflow available: xyz_helpers_lora_testing.json

📚 Documentation

Available Tools

Tool Description Status Documentation
Resolution Calculator Calculate upscaled dimensions with model optimization ✅ Complete Docs
Width Height Selector Preset-based dimension selection with 26 curated options ✅ Complete Docs
Seed History Advanced seed tracking with interactive history management ✅ Complete Docs
Sampler Combo Unified sampling configuration with smart recommendations ✅ Complete Docs
Empty Latent Batch Create empty latent batches with preset support ✅ Complete Docs
Kiko Save Image Enhanced image saving with popup viewer and multi-format support ✅ Complete Docs
Display Text Advanced text display with smart prompt detection and split view ✅ Complete Docs
Gemini Prompt Engineer AI-powered image analysis with dynamic model refresh ✅ Complete Docs
Display Any Universal debugging tool for any data type or tensor shapes ✅ Complete Docs
Image to Multiple Of Adjust image dimensions to multiples for model compatibility ✅ Complete Docs
Image Scale Down By Efficiently scale images down by a specified factor ✅ Complete Docs
Film Grain Add realistic analog film grain effects to images ✅ Complete Docs
Flux Sampler Params FLUX-optimized parameter generator with batch support ✅ Complete Docs
LoRA Folder Batch Batch process multiple LoRAs from folders ✅ Complete Docs
Plot Parameters Visualize parameter effects with graphs ✅ Complete Docs
Sampler Select Helper Intelligent sampler selection with recommendations ✅ Complete Docs
Scheduler Select Helper Optimal scheduler selection for samplers ✅ Complete Docs
Text Encode Sampler Params Combined text encoding and parameter management ✅ Complete Docs
Batch Image Processor Process multiple images with consistent settings 🚧 Planned Coming Soon
Advanced Prompt Utilities Enhanced prompt manipulation and generation 🚧 Planned Coming Soon

Technical Specifications

Resolution Calculator

Inputs:

  • scale_factor (FLOAT): 1.0-8.0, default 2.0
  • image (IMAGE, optional): Input image tensor
  • latent (LATENT, optional): Input latent tensor

Outputs:

  • width (INT): Calculated target width
  • height (INT): Calculated target height

Constraints:

  • All outputs divisible by 8 (ComfyUI requirement)
  • Preserves aspect ratio
  • Validates input tensors
  • Graceful error handling

Width Height Selector

Inputs:

  • preset (DROPDOWN): 26 preset options + custom
  • width (INT): 64-8192, step 8, default 1024
  • height (INT): 64-8192, step 8, default 1024

Outputs:

  • width (INT): Selected or calculated width
  • height (INT): Selected or calculated height

UI Features:

  • Visual blue swap button in bottom-right corner
  • Intelligent preset switching when swapping
  • Modern hover effects and cursor feedback

Preset Categories:

  • SDXL Presets (9): 1024×1024 to 1536×640 (~1MP optimized)
  • FLUX Presets (8): 1920×1080 to 1152×1728 (high resolution)
  • Ultra-Wide (8): 2560×1080 to 768×2304 (modern ratios)

Seed History

Inputs:

  • seed (INT): 0 to 18,446,744,073,709,551,615, default 12345

Outputs:

  • seed (INT): Validated and processed seed value

UI Features:

  • Interactive history display with timestamps
  • Generate random seed button (🎲 Generate)
  • Clear history button (🗑️ Clear)
  • Auto-hide after 2.5 seconds of inactivity
  • Click-to-restore hidden history

History Management:

  • Maximum 10 entries for optimal performance
  • Smart deduplication with 500ms window
  • Persistent localStorage storage
  • Newest entries displayed first
  • Human-readable time formatting (5m ago, 2h ago)

Sampler Combo

Inputs:

  • sampler_name (DROPDOWN): Available ComfyUI samplers (euler, dpmpp_2m, etc.)
  • scheduler (DROPDOWN): Available schedulers (normal, karras, exponential, etc.)
  • steps (INT): 1-1000, default 20
  • cfg (FLOAT): 0.0-30.0, default 7.0

Outputs:

  • sampler_name (STRING): Selected sampler algorithm
  • scheduler (STRING): Selected scheduler algorithm
  • steps (INT): Validated step count
  • cfg (FLOAT): Validated CFG scale

Features:

  • Smart parameter validation and sanitization
  • Sampler-specific recommendations for optimal settings
  • Compatibility checking between samplers and schedulers
  • Graceful error handling with safe defaults
  • Comprehensive tooltips for user guidance

Empty Latent Batch

Inputs:

  • preset (DROPDOWN): 26 preset options + custom with formatted metadata display
  • width (INT): 64-8192, step 8, default 1024
  • height (INT): 64-8192, step 8, default 1024
  • batch_size (INT): 1-64, default 1

Outputs:

  • latent (LATENT): Batch of empty latent tensors in ComfyUI format
  • width (INT): Final sanitized width (divisible by 8)
  • height (INT): Final sanitized height (divisible by 8)

UI Features:

  • Visual blue swap button with hover and click feedback
  • Intelligent preset switching when swapping dimensions
  • Memory usage estimation and warnings for large batches
  • Auto-update width/height widgets when presets change

Batch Processing:

  • Creates tensors with shape: [batch_size, 4, height//8, width//8]
  • Efficient memory allocation with torch.zeros
  • Validates batch size limits (1-64) with performance warnings
  • Compatible with all ComfyUI latent processing nodes

Preset Integration:

  • Full access to 26 curated resolution presets from Width Height Selector
  • Model-aware categorization (SDXL, FLUX, Ultra-wide)
  • Formatted display with aspect ratio and megapixel information
  • Intelligent fallback to custom dimensions for invalid presets

Kiko Save Image

Inputs:

  • images (IMAGE): Batch of images to save
  • filename_prefix (STRING): Prefix for saved filenames, default "KikoSave"
  • format (DROPDOWN): Output format (PNG, JPEG, WEBP), default PNG
  • quality (INT): JPEG/WebP quality (1-100), default 90
  • png_compress_level (INT): PNG compression level (0-9), default 4
  • webp_lossless (BOOLEAN): Use lossless WebP compression, default False
  • popup (BOOLEAN): Enable popup viewer window, default True

Outputs:

  • UI: Enhanced image preview data with popup viewer functionality

UI Features:

  • Floating, draggable popup window showing saved images immediately
  • Interactive image grid with click-to-open functionality
  • Individual image download buttons with format-specific quality indicators
  • Batch selection with multi-select checkboxes for bulk operations
  • Window controls: minimize, maximize, roll-up, close, and dragging
  • Auto-hide/show behavior with smart positioning

Format Support:

  • PNG: Lossless compression with metadata preservation, configurable compression levels
  • JPEG: Quality-controlled lossy compression with automatic transparency handling
  • WebP: Modern format with both lossy and lossless modes, superior compression ratios

Advanced Features:

  • File size monitoring and display for optimization feedback
  • Format-specific quality indicators (PNG compression level, JPEG/WebP quality percentage)
  • Smart filename sanitization with timestamp-based uniqueness
  • Persistent popup viewer across multiple save operations
  • Toggle button integration in node UI for manual viewer control

🛠️ Development

Prerequisites

  • Python 3.8+
  • ComfyUI installation
  • PyTorch 2.0+

Development Setup

# Clone the repository
git clone https://github.com/ComfyAssets/ComfyUI-KikoTools.git
cd ComfyUI-KikoTools

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install development dependencies
pip install -r requirements-dev.txt

# Install pre-commit hooks
pre-commit install

# Run tests
python -c "
import sys, os
sys.path.insert(0, os.getcwd())
from kikotools.tools.resolution_calculator.node import ResolutionCalculatorNode
import torch

# Quick test
node = ResolutionCalculatorNode()
result = node.calculate_resolution(2.0, image=torch.randn(1, 512, 512, 3))
print(f'✅ Development setup successful! Test result: {result[0]}x{result[1]}')
"

Code Quality

We maintain high code quality standards with automated pre-commit hooks:

Pre-commit Hooks

Our pre-commit configuration automatically runs:

  • Black: Code formatting (127 char line length)
  • Flake8: Linting and style checks
  • Bandit: Security vulnerability scanning
  • detect-secrets: Prevents accidental secret commits
  • File checks: trailing whitespace, YAML validation, merge conflicts
# Run all pre-commit hooks manually
pre-commit run --all-files

# Update hooks to latest versions
pre-commit autoupdate

Manual Code Quality Checks

# Format code
black .

# Lint code
flake8 .

# Type checking
mypy .

# Run all quality checks
make quality-check  # If Makefile exists

Testing Philosophy

Following Test-Driven Development (TDD):

  1. Write Tests First: Define expected behavior before implementation
  2. Red-Green-Refactor: Fail → Pass → Improve cycle
  3. Comprehensive Coverage: Unit, integration, and scenario testing
  4. Real-World Validation: Test with actual ComfyUI workflows
# Test structure
tests/
├── unit/                    # Individual component tests
├── integration/            # ComfyUI workflow tests
└── fixtures/              # Test data and workflows

Adding New Tools

  1. Plan: Define tool purpose, inputs, outputs in plan.md
  2. Test: Write comprehensive tests following TDD
  3. Implement: Build tool logic with proper validation
  4. Integrate: Create ComfyUI node interface
  5. Document: Add usage examples and workflows
  6. Validate: Test in real ComfyUI environment

See our Contributing Guide for detailed instructions.

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Development Principles

  • KISS: Keep It Simple, Stupid
  • Separation of Concerns: Clear module boundaries
  • DRY: Don't Repeat Yourself
  • SOLID: Object-oriented design principles
  • TDD: Test-driven development

Reporting Issues

Please use GitHub Issues with:

  • ComfyUI version
  • Tool/node name
  • Expected vs actual behavior
  • Minimal reproduction steps
  • Error logs if applicable

📄 License

MIT License - see LICENSE file for details.

🏷️ Tags

comfyui custom-nodes image-processing ai-tools sdxl flux upscaling resolution batch-processing python pytorch

🔗 Links

📈 Stats

  • Nodes: 19 (13 core tools + 6 xyz-helpers)
  • Features: Embedding Autocomplete (settings-based, not a node)
  • Categories: 9 emoji-based categories for better organization
  • Format Support: 3 (PNG, JPEG, WebP with advanced controls)
  • Presets: 26 curated resolution presets
  • Interactive Features: 8+ (swap buttons, history UI, popup viewers, parameter visualization)
  • AI Integration: Gemini API with 40+ model support
  • Test Coverage: 100% (300+ comprehensive tests)
  • Python Version: 3.8+
  • ComfyUI Compatibility: Latest
  • Dependencies: Minimal (PyTorch, NumPy, Pillow, google-generativeai for Gemini)

🙏 Attribution

xyz-helpers Tools

The xyz-helpers collection was adapted from comfyui-essentials-nodes by cubiq. The original project is in maintenance-only mode, and we've adopted these essential tools to ensure continued support and compatibility with modern ComfyUI workflows. We're grateful for cubiq's original work and contributions to the ComfyUI community.

The following tools are based on comfyui-essentials-nodes:

  • Flux Sampler Params
  • LoRA Folder Batch
  • Plot Parameters
  • Sampler Select Helper
  • Scheduler Select Helper
  • Text Encode Sampler Params

All adaptations maintain compatibility while adding new features and optimizations for the ComfyAssets ecosystem.

Made with ❤️ for the ComfyUI community

⭐ Star this repo • 🐛 Report Bug • 💡 Request Feature

About

Simple tools for ComfyUI

Resources

Readme

License

MIT license

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity
Custom properties

Stars

4 stars

Watchers

1 watching

Forks

1 fork
Report repository

Releases

No releases published

Packages

No packages published

Contributors 3

  •  
  •  
  •  

Languages