ChaiNNer Universal Toolkit: Complete Guide for AI Image Processing

I generated 300 images for a client project and then they asked for all of them upscaled to 4K, converted to JPEG, watermarked, and slightly sharpened. I started doing it manually in Photoshop. Got through 15 images in an hour and realized at that pace I'd need 20 hours of clicking the same buttons over and over.

There had to be a better way. Found ChaiNNer, spent 2 hours learning the interface and building a workflow, then let it run overnight. Woke up to 300 perfectly processed images. What would've taken me days of tedious work finished while I slept.

Understanding ChaiNNer transforms image processing from a bottleneck into a solved problem. The initial learning curve pays dividends immediately when you realize you can process entire folders of images overnight while you sleep, applying sophisticated operations that would take weeks by hand.

Quick Answer: ChaiNNer is a free, cross-platform node-based image processing application that excels at batch operations like upscaling, format conversion, color correction, and automation. Install it from GitHub, create processing workflows by connecting nodes visually (similar to ComfyUI), load AI upscaling models like RealESRGAN or ESRGAN, set up batch processing with folder iterator nodes, and execute workflows on hundreds or thousands of images automatically. It's ideal for post-processing AI-generated images, preparing images for printing, converting formats in bulk, and automating repetitive image editing tasks.

What Is ChaiNNer and Why Should You Use It?

ChaiNNer is a node-based image processing application that brings programming-level automation capabilities to image editing without requiring actual coding. If you've used ComfyUI, the node-based interface will feel immediately familiar. If you haven't, think of it as connecting building blocks where each block performs a specific operation on your images.

The Core Philosophy:

ChaiNNer was created to solve a fundamental problem in AI image workflows. You generate hundreds of images that all need similar processing - upscaling, sharpening, format conversion, watermarking. Traditional image editors force you to process each image individually or use limited batch functions that don't handle complex operations well.

ChaiNNer inverts this paradigm. You design your processing workflow once using nodes, then apply it to as many images as needed with complete automation. The workflow is visual and reusable, meaning you can save effective processing chains and apply them across different projects.

What Makes It Different:

Tool	Approach	Strengths	Limitations	Best For
Photoshop Actions	Recorded steps	Familiar to PS users	Limited logic, single-threaded	Simple repetitive tasks
ImageMagick	Command-line scripting	Powerful, scriptable	Steep learning curve	Programmers
Bulk Image Editors	GUI batch tools	Easy to use	Limited operations	Simple conversions
ChaiNNer	Node-based workflows	Visual, powerful, flexible	Learning curve	Complex automation

Key Capabilities:

AI Model Integration: ChaiNNer natively supports multiple AI upscaling models including ESRGAN variants, RealESRGAN, SwinIR, and others. Load models, apply them to images, chain multiple models together for enhanced results.

Batch Processing: Process entire folders of images with iteration logic. Apply the same workflow to 10 images or 10,000 images with equal ease.

Format Conversion: Convert between formats (PNG, JPEG, WEBP, TIFF) with full control over quality settings, compression, and metadata.

Image Manipulation: Resize, crop, rotate, flip, adjust colors, apply filters, sharpen, blur, and dozens of other operations through visual nodes.

Conditional Logic: Include if/then logic in workflows. Process images differently based on their dimensions, file size, or other properties.

Model Chaining: Apply multiple AI models in sequence. Upscale with RealESRGAN, then sharpen with SwinIR, then adjust colors - all in one workflow.

Who Benefits Most:

AI image generators who produce hundreds of outputs that need consistent post-processing. Upscale all your Stable Diffusion outputs, convert to specific formats, apply sharpening.

Photographers with large collections needing batch operations beyond what Lightroom provides. Complex multi-step processing that would take hours manually.

Content creators preparing images for different platforms. Resize for Instagram, Twitter, website, and print from a single source, all automated.

ComfyUI power users who want to separate generation from post-processing. Generate in ComfyUI, process in ChaiNNer, keeping workflows modular and manageable.

Digital archivists converting or processing large image collections. Format standardization, quality enhancement, organization.

Why Not Just Use ComfyUI?

ComfyUI can do image processing, but it's designed primarily for generation. ChaiNNer is purpose-built for processing existing images, making it more efficient for post-generation workflows. The tool selection, node library, and optimization all focus on processing rather than generation.

Many users run both - ComfyUI for creation, ChaiNNer for processing. This separation keeps workflows focused and often performs better than trying to do everything in one tool.

For users working with AI-generated images who need professional post-processing, ChaiNNer fills a critical gap between generation and final output. While platforms like Apatero.com offer integrated post-processing within the generation environment, ChaiNNer provides unlimited flexibility for custom workflows.

Understanding basic image processing concepts helps maximize ChaiNNer's capabilities. Our AI image upscaling comparison covers the upscaling models that ChaiNNer uses extensively.

How Do You Install and Set Up ChaiNNer?

ChaiNNer installation is straightforward compared to many AI tools, with official releases for Windows, Mac, and Linux. The process differs slightly by platform but follows the same basic pattern.

System Requirements:

Component	Minimum	Recommended	Notes
OS	Windows 10, macOS 11, Ubuntu 20.04	Latest versions	Cross-platform
RAM	8GB	16GB+	More for large images
Storage	2GB	10GB+	Models require space
GPU	Optional	NVIDIA with CUDA	CPU works but slower
Python	Not required	Not required	Self-contained

Windows Installation:

1. Visit the ChaiNNer GitHub releases page at github.com/chaiNNer-org/chaiNNer/releases
2. Download the latest Windows installer (ChaiNNer-win.exe)
3. Run the installer and follow prompts
4. ChaiNNer installs with all dependencies included
5. Launch from Start Menu or desktop shortcut

No Python installation required - ChaiNNer bundles everything needed. This is a major advantage over many AI tools that require complex Python environment setup.

macOS Installation:

1. Download ChaiNNer-mac.dmg from GitHub releases
2. Open the DMG file
3. Drag ChaiNNer to Applications folder
4. First launch requires right-click > Open due to security settings
5. Grant necessary permissions when prompted

For Apple Silicon Macs (M1, M2, M3, M4), use the ARM version for better performance. Intel Macs use the x86 version.

Linux Installation:

1. Download ChaiNNer-linux.AppImage from releases
2. Make executable: chmod +x ChaiNNer-linux.AppImage
3. Run: ./ChaiNNer-linux.AppImage
4. Install system dependencies if prompted (varies by distro)

AppImage format means no installation needed - just download and run. Some distributions may require installing FUSE for AppImage support.

First Launch Configuration:

When you first open ChaiNNer, configure these settings:

Backend Selection:

• PyTorch (NVIDIA GPUs): Best for AI model processing
• NCNN (any GPU including AMD/Intel): Broader compatibility
• ONNX (CPU or GPU): Universal but sometimes slower

If you have an NVIDIA GPU with CUDA, select PyTorch for best performance. AMD or Intel GPU users should try NCNN. CPU-only systems can use any backend but will be slower.

GPU Acceleration:

Navigate to Settings (gear icon) and configure GPU:

• Enable GPU acceleration if you have compatible hardware
• Select which GPU to use if you have multiple
• Set VRAM limit if needed (prevents crashes on low-VRAM systems)

Model Download Location:

ChaiNNer needs AI models to perform upscaling and other operations:

1. Create a folder for models (e.g., Documents/ChaiNNer-Models)
2. Configure ChaiNNer to look in this folder
3. Download models from the Model Database

Essential Models to Download:

Start with these models for common tasks:

For Photo Upscaling:

• RealESRGAN_x4plus (general-purpose 4x upscale)
• RealESR-general-x4v3 (photo restoration)

For AI-Generated Art:

• RealESRGAN_x4plus_anime_6B (anime/illustration)
• 4x-UltraSharp (sharp details for AI art)

For Faces:

• GFPGAN (face restoration and enhancement)
• CodeFormer (alternative face enhancer)

Download models from:

• OpenModelDB (models.chaiNNer.app)
• Official model repositories on GitHub
• Community sharing on Reddit r/ChaiNNer

Models are typically .pth or .onnx files ranging from 10MB to 100MB each.

Installing Models:

1. Download model file
2. Place in your models folder
3. In ChaiNNer, use "Load Model" node
4. Browse to model file or folder
5. ChaiNNer auto-detects compatible models

Interface Overview:

ChaiNNer's interface has several key areas:

Node Menu (left side): Browse available nodes organized by category - Image, PyTorch, NCNN, Utility, etc.

Workflow Canvas (center): Drag nodes here and connect them to build workflows.

Node Properties (right side): Configure selected node's settings.

Menu Bar (top): File operations, settings, help.

Creating Your First Simple Workflow:

Let's build a basic workflow to understand the interface:

1. Drag "Load Image" node from Image category to canvas
2. Drag "Save Image" node to canvas
3. Connect the image output (right side of Load) to image input (left side of Save)
4. Click Load Image node and browse to a test image
5. Click Save Image node and set output path
6. Click Run (play button) to execute workflow

This simple workflow loads an image and saves it - not useful yet, but demonstrates the basic node connection concept.

Troubleshooting Installation Issues:

ChaiNNer won't launch:

• Check system requirements met
• Update graphics drivers
• Try running as administrator (Windows)
• Check error logs in AppData/ChaiNNer (Windows) or ~/Library/Application Support/ChaiNNer (Mac)

GPU not detected:

• Verify CUDA installation (NVIDIA)
• Update GPU drivers
• Check GPU compatibility with selected backend
• Fall back to CPU if GPU issues persist

Models won't load:

• Verify model file isn't corrupted (re-download)
• Check file extension matches backend (.pth for PyTorch, .onnx for ONNX)
• Ensure model is compatible with selected backend
• Check ChaiNNer console for error messages

Performance is very slow:

• Enable GPU acceleration if available
• Reduce batch size for large images
• Close other GPU-using applications
• Consider lower resolution processing then upscale

For users experienced with ComfyUI, the ChaiNNer interface will feel immediately comfortable. The node-based paradigm is nearly identical, though node types and purposes differ. Our ComfyUI basics guide covers node workflow concepts that transfer directly to ChaiNNer.

While Apatero.com handles image processing internally without requiring separate tools, understanding ChaiNNer provides powerful post-processing capabilities for images generated anywhere, including downloaded outputs from web platforms.

How Do Node-Based Workflows Function in ChaiNNer?

Node-based workflows in ChaiNNer follow similar principles to ComfyUI but focus on processing rather than generation. Understanding the node system unlocks ChaiNNer's full potential for creating sophisticated, reusable processing pipelines.

Node Anatomy:

Every ChaiNNer node has three components:

Inputs (left side): Data flowing into the node. Can be images, numbers, text, or other data types. Required inputs show a colored dot, optional inputs are dimmed.

The node body: Contains the operation name and configurable parameters. Click to see settings in the properties panel.

Outputs (right side): Data flowing out of the node after processing. Different data types have different colors for easy identification.

Data Type Color Coding:

Color	Data Type	Common Use	Example Nodes
Purple	Image	Main image data	Load Image, Upscale, Save
Blue	Number	Dimensions, settings	Width, Height, Scale Factor
Green	Text/String	File paths, names	File Path, Text
Red	Model	AI models	Load Model, Model output
Yellow	Directory	Folder paths	Folder Iterator
Orange	Array/List	Multiple values	File list, number array

Connecting Nodes:

Click and drag from an output dot to an input dot to create connections. ChaiNNer only allows compatible type connections - you can't connect an Image output to a Number input.

Compatible connections: Purple to purple (image to image), blue to blue (number to number).

Auto-conversion: Some nodes automatically convert types when sensible - a Number can feed into a Text input, for example.

Invalid connections: ChaiNNer prevents incompatible connections, so you can't accidentally create broken workflows.

Essential Node Categories:

Image Category:

Load Image: Start of most workflows. Browses for and loads a single image file.

Save Image: Output of workflows. Saves processed image to specified location with format options.

Load Images: Loads multiple images at once, outputting an image array.

Image File Iterator: Loops through all images in a folder, processing each one.

PyTorch / NCNN / ONNX Categories:

These contain AI model operations specific to each backend:

Load Model: Loads an AI model file (.pth, .onnx, etc.) for use in processing.

Upscale Image: Applies loaded model to upscale or enhance image.

Image Adjustment: Various AI-powered adjustments depending on model.

Utility Category:

Text: Creates text values for paths, filenames, settings.

Math: Performs calculations - add, multiply, divide numbers.

If/Else: Conditional logic - do different things based on conditions.

Note: Add comments to workflows for documentation.

Building a Complete Upscaling Workflow:

Here's a step-by-step workflow for upscaling images with AI:

Step 1: Input

• Add "Image File Iterator" node
• Set it to your input folder containing images to upscale
• This will loop through all images in the folder

Step 2: Load AI Model

• Add "Load Model" (PyTorch) node
• Browse to your RealESRGAN_x4plus.pth file
• This loads the upscaling model into memory

Step 3: Upscale

• Add "Upscale Image" (PyTorch) node
• Connect Image File Iterator output to Upscale Image input
• Connect Load Model output to Upscale Image model input
• Configure settings (tile size for VRAM management)

Step 4: Output

• Add "Save Image" node
• Connect Upscale Image output to Save Image input
• Set output directory
• Configure format (PNG, JPEG) and quality settings

Step 5: Execute

• Click Run button
• ChaiNNer processes all images in input folder
• Upscaled results save to output folder
• Progress bar shows completion status

Advanced Workflow Patterns:

Chain Processing:

Apply multiple operations in sequence by connecting nodes linearly:

Load Image > Upscale 2x > Sharpen > Color Correct > Compress > Save Image

Each operation feeds into the next, creating complex processing pipelines.

Parallel Processing:

Process an image through multiple paths simultaneously:

Load Image branches to:

• Path A: Upscale for print
• Path B: Resize for web
• Path C: Create thumbnail

Each path saves separately, creating multiple outputs from one input.

Conditional Processing:

Use If/Else nodes to process images differently based on properties:

Load Image > Get Dimensions > If width > 2000px:

• True path: Downscale then save
• False path: Upscale then save

This handles mixed-resolution inputs intelligently.

Iterative Processing:

Loop through collections with iterator nodes:

Folder Iterator > For each image:

• Load
• Process
• Save with sequential naming

Handles entire folders automatically.

Workflow Optimization Tips:

Minimize unnecessary operations: Each node adds processing time. Don't resize to 4000px then back to 2000px - calculate final size and resize once.

Batch when possible: Loading images individually in a loop is slower than loading all images at once with Load Images node when dealing with smaller batches.

Tile for large images: When upscaling very large images, use tiling options to process in chunks rather than loading entire image into VRAM.

Cache intermediate results: For workflows you run repeatedly with different final steps, save intermediate results to avoid reprocessing early stages.

Saving and Sharing Workflows:

Workflows save as .chn files containing the node graph and settings:

1. File > Save Workflow
2. Choose location and filename
3. Share .chn files with others
4. Load with File > Open Workflow

Community workflows available on:

• ChaiNNer Discord server
• Reddit r/ChaiNNer
• GitHub discussions

Common Workflow Templates:

Basic upscaling: Input folder > Load model > Upscale > Save to output folder

Format conversion: Input folder > Iterate images > Convert format > Adjust quality > Save

Watermarking: Load images > Load watermark > Blend/overlay > Save

Face restoration: Input > Load GFPGAN model > Restore faces > Upscale > Save

Print preparation: Input > Upscale to 300 DPI > Convert to CMYK > Save as TIFF

Start with templates, modify for your specific needs, save custom versions for reuse.

Debugging Workflows:

Node shows error (red border):

• Check input connections are correct types
• Verify file paths exist
• Check model compatibility
• Read error message in console

Workflow runs but produces wrong output:

• Check node parameters (click node, review settings)
• Verify connections go to correct inputs
• Test with single image before batch processing
• Add "Preview Image" nodes to inspect intermediate results

Slow performance:

• Reduce tile size if using tiled processing
• Close other applications using GPU
• Process in smaller batches
• Check if CPU/GPU is bottleneck

For users familiar with ComfyUI, many workflow design principles transfer directly. Our guide on fixing messy ComfyUI workflows applies equally to organizing complex ChaiNNer workflows.

What Are the Best Practices for Batch Processing Thousands of Images?

Batch processing is where ChaiNNer truly shines - taking workflows that would require hours or days of manual work and automating them to run unattended. Proper setup ensures efficiency, reliability, and quality results at scale.

Batch Processing Setup Strategy:

Before processing thousands of images, optimize your workflow with a small test batch:

1. Test with 5-10 images representing your full dataset variety
2. Verify output quality meets requirements
3. Check processing speed and estimate total time
4. Confirm file naming and organization work correctly
5. Scale to full batch once testing succeeds

Folder Structure Best Practices:

Organize your batch processing with clear folder structure:

input-folder/ image001.png image002.png ...

output-folder/ (processed images go here)

models/ RealESRGAN_x4plus.pth other-models.pth

workflows/ upscale-workflow.chn format-convert.chn

This separation keeps inputs safe (ChaiNNer doesn't modify originals), organizes outputs clearly, and centralizes models and workflows.

Using Image File Iterator:

The Image File Iterator node is the workhorse of batch processing:

Configuration options:

Directory: Browse to folder containing images to process

File extension filter: Process only specific types (*.png, *.jpg, etc.)

Recursive: Include images in subfolders

Sort order: Alphabetical, by date, by size, random

Example setup:

• Directory: C:/Projects/AI-Outputs/
• Filter: *.png
• Recursive: Enabled
• Sort: Alphabetical

This processes all PNG files in the folder and subfolders, in alphabetical order.

Progress Tracking and Monitoring:

ChaiNNer provides several ways to monitor batch processing:

Progress bar: Shows current image / total images

Console output: Displays which file is currently processing

Time estimation: Estimates remaining processing time based on average speed

Preview window: Shows current image being processed (can slow processing slightly)

For very long batch jobs (1000+ images), disable preview to maximize speed.

Performance Optimization:

Optimization	Impact	Trade-off	When to Use
Disable preview	5-10% faster	Can't watch progress visually	Large batches
Increase batch size	10-20% faster	More VRAM usage	If VRAM available
Use GPU acceleration	300-500% faster	Requires compatible GPU	Always if possible
Tile processing	Enables large images	Slower overall	Images exceed VRAM
Lower output quality	20-40% faster	Reduced quality	Drafts/previews only

VRAM Management:

When processing high-resolution images with AI models, VRAM becomes the limiting factor:

Symptoms of VRAM issues:

• Processing crashes mid-batch
• "Out of memory" errors
• System becomes unresponsive
• GPU driver resets

Solutions:

Enable tiled processing: Break large images into tiles, process separately, reassemble. Slower but uses less VRAM.

Reduce batch size: Process fewer images simultaneously. Set batch size to 1 for minimum VRAM usage.

Close other GPU applications: Free VRAM by closing games, other AI tools, GPU-accelerated browsers.

Upscale in stages: Instead of 1x to 4x in one step, do 1x to 2x, then 2x to 4x in separate passes.

Use smaller models: Some upscaling models have compact versions requiring less VRAM.

Handling Mixed Resolution Inputs:

When batch processing images of different sizes and resolutions:

Option 1: Conditional Processing Use Get Image Dimensions node with If/Else:

• If width < 1000px: Upscale 4x
• If width 1000-2000px: Upscale 2x
• If width > 2000px: Don't upscale, just enhance

Option 2: Target Resolution Calculate scale factor to reach target resolution:

• Target: 4000px width
• Input 500px: Scale 8x
• Input 1000px: Scale 4x
• Input 2000px: Scale 2x

Use Math nodes to calculate dynamic scale factors.

Option 3: Separate Batches Sort images by resolution, process in separate batches with appropriate settings.

File Naming Patterns:

Batch processing needs intelligent output naming:

Simple suffix: original-name_upscaled.png

Descriptive naming: original-name_4x_sharpened.png

Sequential numbering: output_0001.png, output_0002.png

Preserve original names: Keep same filename in different output folder

ChaiNNer's filename nodes support:

• Extracting original filename
• Adding prefixes/suffixes
• Sequential numbering
• Custom patterns with variables

Error Handling in Batch Processing:

Batch processing fails gracefully when individual images cause errors:

ChaiNNer behavior:

• Logs error for problematic image
• Continues processing remaining images
• Doesn't crash entire batch

After batch completion:

• Review console log for errors
• Identify which images failed
• Manually inspect and reprocess failures

Common errors and solutions:

Corrupted image files: Skip or delete, reprocess if possible

Unsupported format: Convert format first or exclude from batch

Extremely large files: Process separately with special handling

Memory errors: Reduce batch size or enable tiling

Real-World Batch Processing Scenarios:

Scenario 1: Upscaling 500 AI-Generated Images

• Input: 500 PNG images at 768x768
• Process: 4x upscale with RealESRGAN
• Output: 3072x3072 PNG files
• Time: Approximately 2-4 hours depending on GPU
• Setup: Image File Iterator > Load Model > Upscale > Save

Scenario 2: Converting Photo Archive to JPEG

• Input: 2000 TIFF files at various resolutions
• Process: Convert to JPEG, 90% quality
• Output: JPEG files with original names
• Time: Approximately 30-60 minutes
• Setup: Image File Iterator > Convert Format > Adjust Quality > Save

Scenario 3: Preparing Images for Web and Print

• Input: 100 high-res product photos
• Process: Create web version (1200px) and print version (4000px)
• Output: Two folders with different versions
• Time: Approximately 15-30 minutes
• Setup: Branching workflow with two save paths

Overnight Batch Processing:

For extremely large batches, run overnight:

1. Set up and test workflow thoroughly during the day
2. Start batch processing before bed
3. Configure power settings to prevent sleep
4. Disable screensaver (GPU-intensive, competes for resources)
5. Close all other applications
6. Start processing
7. Review results in the morning

Monitoring long batches:

• Check estimated completion time
• Set up to process while you're away
• Some users use remote desktop to check progress from phone

Batch Processing Checklist:

• Test workflow on 5-10 sample images
• Verify output quality meets requirements
• Organize input folder with only images to process
• Set up clear output folder (empty or organized)
• Configure proper file naming pattern
• Enable GPU acceleration if available
• Disable preview for large batches (optional)
• Estimate total processing time
• Ensure sufficient disk space for outputs
• Close competing applications
• Configure power settings (no sleep for long batches)
• Start batch and monitor first few images
• Return after completion to verify results

For users processing AI-generated images from ComfyUI or other tools, batch processing in ChaiNNer provides professional post-processing at scale. While Apatero.com offers integrated batch processing within the generation environment, ChaiNNer's flexibility makes it ideal for processing images from multiple sources or applying complex custom operations.

How Do You Create Advanced Upscaling Chains for Maximum Quality?

ChaiNNer's ability to chain multiple AI models in sequence enables upscaling quality beyond what any single model achieves alone. Understanding how to combine models strategically produces professional-grade results.

The Model Chaining Concept:

Instead of applying one upscaling model and calling it done, chaining applies multiple models in sequence, with each model addressing different aspects of quality:

Model 1: Increase resolution 2x, preserving structure Model 2: Enhance details and sharpness Model 3: Reduce artifacts and noise Model 4: Final quality pass

Each model's output becomes the next model's input, progressively refining the image.

Why Chaining Works Better:

Single-model upscaling often faces trade-offs:

• Models good at preserving details might introduce artifacts
• Models that reduce noise might over-smooth details
• High upscaling ratios (4x, 8x) can lose fine information

Chaining lets you use specialized models for specific purposes, combining their strengths while minimizing individual weaknesses.

Recommended Model Chains:

For AI-Generated Artwork:

Step	Model	Purpose	Scale Factor
1	4x-UltraSharp	Initial upscale, detail preservation	4x
2	4x-AnimeSharp (if anime)	Style-specific enhancement	1x (no scale)
3	Sharpen filter	Clarity enhancement	1x
4	Slight noise reduction	Clean final output	1x

This chain takes a 512x512 AI image to 2048x2048 with exceptional detail and clarity.

For Photographs:

Step	Model	Purpose	Scale Factor
1	RealESRGAN_x4plus	General photo upscale	4x
2	GFPGAN (if faces present)	Face restoration	1x
3	RealESR-general-x4v3	Photo restoration pass	1x (denoise)
4	Slight sharpening	Final clarity	1x

For Extreme Upscaling (8x or more):

Step	Model	Purpose	Scale Factor
1	RealESRGAN_x4plus	First 4x upscale	4x
2	Detail refinement	Enhance features	1x
3	RealESRGAN_x2plus	Second upscale to 8x total	2x
4	Artifact reduction	Clean up	1x

Breaking extreme upscaling into stages produces better results than trying to jump 8x in one step.

Building an Upscaling Chain Workflow:

Step 1: Load Models

Add multiple "Load Model" nodes, one for each model in your chain:

• Load Model node 1: RealESRGAN_x4plus.pth
• Load Model node 2: 4x-UltraSharp.pth
• Load Model node 3: SwinIR.pth

Step 2: Chain Upscale Nodes

Add "Upscale Image" nodes in sequence:

• Upscale 1: Connect to Model 1
• Upscale 2: Connect Upscale 1 output to input, Model 2 to model input
• Upscale 3: Connect Upscale 2 output to input, Model 3 to model input

Step 3: Intermediate Processing

Between upscale steps, add enhancement nodes:

• Sharpen
• Adjust Contrast
• Reduce Noise
• Color Correction

Step 4: Output

Connect final upscale/enhancement to Save Image node.

Balancing Quality and Processing Time:

More models mean longer processing:

Chain Length	Processing Time (relative)	Quality Gain	Best Use Case
1 model	1x (baseline)	Baseline	Quick previews
2 models	1.8x	Significant	General use
3 models	2.5x	Major	High quality needs
4+ models	3.5x+	Diminishing returns	Critical projects

For most use cases, 2-3 model chains provide the best quality/time balance.

Model-Specific Strengths:

Understanding what each model does best helps you build effective chains:

RealESRGAN_x4plus:

• Strength: General-purpose upscaling, good structure preservation
• Weakness: Can over-sharpen, occasional artifacts
• Best position: First in chain for initial upscale

4x-UltraSharp:

• Strength: Excellent detail enhancement, crisp results
• Weakness: Can introduce slight artifacts on some content
• Best position: Second in chain after initial upscale

SwinIR:

• Strength: Noise reduction, artifact cleanup, smooth results
• Weakness: Can over-smooth fine details
• Best position: Late in chain for cleanup

GFPGAN / CodeFormer:

• Strength: Face restoration and enhancement
• Weakness: Only affects faces, can look unnatural on artistic faces
• Best position: After upscaling, before final refinement

RealESR-general-x4v3:

• Strength: Photo restoration, good for old/damaged photos
• Weakness: Not ideal for already-clean AI-generated content
• Best position: Early or middle for photo restoration chains

Face-Specific Chains:

Images containing faces benefit from specialized chains:

1. Initial upscale: RealESRGAN_x4plus for overall image
2. Face detection and restoration: GFPGAN or CodeFormer
3. Blend restored faces: Adjust blend strength (0.5-0.8 usually best)
4. Final enhancement: Slight sharpening on entire image

ChaiNNer can detect faces, process them separately with face-specific models, then blend back into the main image - producing natural results where faces are enhanced without affecting the rest of the image.

Tiling for Large Images:

When chaining multiple upscales, intermediate steps can create extremely large images that exceed VRAM:

Tiling strategy:

• Enable tiling on first upscale node (tile size 512-1024)
• Subsequent nodes process tiled regions
• ChaiNNer reassembles seamlessly

Tile size selection:

VRAM Available	Recommended Tile Size	Notes
4-6 GB	256-512	Conservative
6-8 GB	512-768	Balanced
8-12 GB	768-1024	Good performance
12+ GB	1024-2048	Maximum speed

Smaller tiles use less VRAM but process slower due to overlap.

Quality vs. File Size Trade-offs:

Upscaling chains produce large outputs:

Original: 512x512 PNG = 500 KB After 4x upscale: 2048x2048 PNG = 8-15 MB After enhancement chain: 2048x2048 PNG = 12-20 MB

Managing file size:

• Use JPEG with 90-95% quality for web use (reduces to 2-4 MB)
• Keep PNG for print or further editing
• Use WEBP format for best compression with quality (4-6 MB)

Testing and Comparing Chains:

Before processing large batches, test chain effectiveness:

1. Select 5-10 representative images
2. Process with different chain configurations
3. Compare outputs at 100% zoom
4. Evaluate details, artifacts, overall appearance
5. Select best-performing chain for batch processing

Common Chain Mistakes to Avoid:

Over-processing: More models doesn't always mean better. Past 3-4 models, quality gains diminish while artifacts can accumulate.

Incompatible models: Some models work better with specific content types. Using anime-optimized models on photos or vice versa produces poor results.

Wrong order: Enhancement before upscaling wastes processing. Always upscale first, then enhance details.

Ignoring artifacts: If early chain steps introduce artifacts, later steps usually amplify them. Fix artifact sources, don't just try to clean them up later.

Extreme sharpening: Multiple sharpening passes create unnatural, over-processed appearance. Sharpen once, conservatively.

For comprehensive comparison of upscaling models and when to use each, see our AI upscaling battle guide. Understanding model characteristics helps you build chains that leverage each model's strengths.

While platforms like Apatero.com apply optimized upscaling automatically, ChaiNNer's chaining capabilities give advanced users ultimate control over quality when processing critical images or large professional projects.

How Does ChaiNNer Integrate with ComfyUI Workflows?

ChaiNNer and ComfyUI complement each other perfectly - ComfyUI excels at generation, ChaiNNer at processing. Integrating them creates powerful end-to-end workflows from creation to final output.

The Separation of Concerns Philosophy:

ComfyUI handles:

• Image generation from prompts
• Style application
• Character consistency
• Initial composition
• Creative iteration

ChaiNNer handles:

• Batch upscaling of outputs
• Format conversion
• Print preparation
• Consistent post-processing
• Automation of repetitive tasks

This separation keeps workflows focused and often performs better than trying to do everything in one tool.

Integration Methods:

Method 1: Folder-Based Integration (Simplest)

ComfyUI saves outputs to a folder, ChaiNNer processes that folder:

1. Configure ComfyUI to save to specific output folder
2. Generate batch of images in ComfyUI
3. Point ChaiNNer Image File Iterator to ComfyUI output folder
4. Run ChaiNNer workflow to process all generated images
5. ChaiNNer saves final outputs to separate folder

This manual handoff works well for occasional processing.

Method 2: Watch Folder Automation

Set up automated processing of new images:

1. ComfyUI saves to "generated" folder
2. ChaiNNer watches this folder (via external script or manual runs)
3. New images automatically processed
4. Outputs move to "final" folder

Requires some scripting or manual workflow execution when new images appear.

Method 3: API Integration (Advanced)

Both tools offer API access for programmatic control:

1. Script triggers ComfyUI generation via API
2. Script waits for completion
3. Script triggers ChaiNNer processing via API
4. Fully automated end-to-end pipeline

This requires programming knowledge but enables complete automation.

Practical Workflow Examples:

Workflow 1: Generate and Upscale Portrait Batch

ComfyUI side:

• Generate 20 portrait variations with Stable Diffusion
• Output at 768x768 to "portraits-raw" folder
• Use consistent style and quality settings

ChaiNNer side:

• Watch "portraits-raw" folder
• Upscale 4x with RealESRGAN
• Apply face restoration with GFPGAN
• Sharpen slightly
• Save to "portraits-final" at 3072x3072

Workflow 2: Product Mockup Generation and Preparation

ComfyUI side:

• Generate product visualizations from prompts
• Output at 1024x1024
• Multiple style variations

ChaiNNer side:

• Upscale to 4096x4096 for print
• Convert to CMYK color space
• Add 0.125" bleed area
• Save as TIFF for professional printing

Workflow 3: Social Media Asset Creation

ComfyUI side:

• Generate creative artwork
• Output at 1024x1024

ChaiNNer side:

• Branch processing:
  • Instagram: Resize to 1080x1080, convert to sRGB JPEG
  • Twitter: Resize to 1200x675, optimize file size
  • Facebook: Resize to 1200x630, compress
  • Pinterest: Resize to 1000x1500, maintain quality
• Each platform gets correctly sized, optimized version

File Organization Best Practices:

Structure folders for clear handoff:

project-name/ 01-comfyui-output/ (raw generations) 02-chainner-processing/ (intermediate processing steps) 03-final-output/ (finished, deliverable images) chainner-workflows/ upscale-workflow.chn format-convert.chn comfyui-workflows/ generation-workflow.json

This organization makes it clear which stage each image is in.

Metadata and Filename Preservation:

Preserve ComfyUI generation information through ChaiNNer processing:

ComfyUI filename: image_12345_seed42_cfg7.png

ChaiNNer processing:

• Extract original filename
• Add processing suffix: image_12345_seed42_cfg7_upscaled_4x.png
• Preserve generation parameters in filename

This maintains traceability from generation to final output.

Resolution Planning:

Plan resolution at generation time for optimal results:

For web use:

• Generate at 768x768 in ComfyUI
• Upscale to 1536x1536 in ChaiNNer
• Optimize for web delivery

For print use:

• Generate at 1024x1024 in ComfyUI
• Upscale to 4096x4096 in ChaiNNer (300 DPI at 13.6 inches)
• Convert to CMYK and add bleed

For social media:

• Generate at 1024x1024 in ComfyUI
• Create multiple sized versions in ChaiNNer
• Format-specific optimization

Batch Processing Generated Outputs:

After a ComfyUI generation session produces 50-100 images:

1. Review and select best generations
2. Move selected images to processing folder
3. Run ChaiNNer batch workflow on selections only
4. Archive raw generations, keep processed finals

This selective processing saves time and storage versus processing every generation.

Quality Control Integration:

ComfyUI quality control:

• Preview during generation
• Basic quality filtering
• Select promising outputs

ChaiNNer quality control:

• Test upscaling on 2-3 images first
• Verify quality before batch processing
• Adjust chain if needed
• Final quality verification

Handling Different Content Types:

Different ComfyUI outputs need different ChaiNNer processing:

Portraits: Face restoration chain Landscapes: General upscaling with detail enhancement Anime/Illustration: Anime-specific models Architecture: Sharp detail preservation Abstract: General enhancement without over-processing

Create multiple ChaiNNer workflow files for different content types, apply appropriately based on ComfyUI output category.

Performance Optimization Across Tools:

VRAM management:

• Close ComfyUI before heavy ChaiNNer batch processing
• Or use separate GPU for each tool if available
• Monitor total VRAM usage to prevent conflicts

Storage management:

• Automatically archive or delete intermediate files
• Keep only final processed outputs long-term
• Compress or delete raw generations after processing

Processing scheduling:

• Generate during the day in ComfyUI
• Process overnight in ChaiNNer
• Wake up to finished, optimized outputs

For users building comprehensive AI image workflows, the ComfyUI-ChaiNNer combination provides professional end-to-end capabilities. While Apatero.com integrates generation and processing in a single platform, understanding this tool integration enables powerful custom workflows for specific needs.

Additional workflow integration insights in our ComfyUI automation guide cover broader automation strategies that extend to ChaiNNer integration.

Frequently Asked Questions

Can ChaiNNer run without a GPU or is NVIDIA CUDA required?

ChaiNNer works perfectly on CPU-only systems, though processing is slower than with GPU acceleration. You don't need NVIDIA or CUDA - the NCNN backend supports AMD and Intel GPUs, and all backends work on CPU. Expect CPU processing to be 5-10x slower than GPU for AI operations like upscaling, but for simple operations like format conversion or resizing, CPU performance is acceptable. If you have any GPU (AMD, Intel, or NVIDIA), enable GPU acceleration in settings for significant speed improvements.

How does ChaiNNer compare to Photoshop Actions for batch processing?

ChaiNNer offers more flexibility and power than Photoshop Actions for several reasons. Actions record a linear sequence of steps and struggle with conditional logic or variable inputs, while ChaiNNer's node-based approach supports branching, conditions, and complex workflows. ChaiNNer natively integrates AI models (upscaling, face restoration) that require third-party plugins in Photoshop. ChaiNNer is also free and open-source versus Photoshop's subscription cost. However, Photoshop Actions integrate perfectly with other Photoshop features, so for workflows heavily using Photoshop-specific tools, Actions might be more convenient.

Can I use ChaiNNer to process video files or is it images only?

ChaiNNer currently supports only still images, not video files directly. However, you can process video through a workaround: extract video frames as individual images using FFmpeg or similar tools, process all frames through ChaiNNer (upscaling, enhancement, etc.), then reassemble frames into video with FFmpeg. This works but is time-consuming for long videos. For video upscaling, dedicated tools like Video2x or Topaz Video AI are more efficient, though ChaiNNer produces excellent results if you're willing to handle the frame extraction and reassembly steps.

What's the maximum image size ChaiNNer can handle?

ChaiNNer's maximum image size depends on available system RAM and VRAM rather than hard software limits. For GPU processing, VRAM is typically the bottleneck - an 8GB GPU can handle roughly 4000x4000 images in one pass, larger images require tiling. For CPU processing, system RAM limits size - 16GB RAM can handle 8000x8000+ images. Tiled processing removes size limits entirely by breaking large images into chunks, processing separately, and reassembling. For extremely large images like gigapixel panoramas, enable tiling and be patient - processing will complete successfully but slowly.

How do I share ChaiNNer workflows with others or download community workflows?

ChaiNNer workflows save as .chn files containing the complete node graph and settings. Share workflows by: exporting as .chn file (File > Save Workflow), sharing the file via Discord, Reddit, GitHub, or other platforms. Others load with File > Open Workflow. However, workflows don't include AI models (too large), so share instructions on which models are needed and where to download them. The ChaiNNer Discord server and r/ChaiNNer subreddit have active workflow sharing communities with pre-made workflows for common tasks.

Is ChaiNNer development still active or is it abandoned?

ChaiNNer is actively maintained and regularly updated. The development team consistently releases new versions with bug fixes, new nodes, performance improvements, and model compatibility updates. Check the GitHub repository for recent commits and release history - as of 2025, the project receives frequent updates. The Discord community is active with developers responding to questions and issues. Unlike some AI tools that peak and decline, ChaiNNer continues growing with expanding capabilities and improving stability.

Can ChaiNNer handle RAW photo formats from cameras?

ChaiNNer has limited RAW format support. It can read some RAW formats through underlying libraries, but support is inconsistent across different camera manufacturers and models. For reliable RAW processing, better to convert RAW to TIFF or PNG in dedicated RAW processors like Lightroom, Darktable, or RawTherapee first, then process the converted files in ChaiNNer. This workflow separation also makes sense because RAW processing involves different operations (white balance, exposure, color grading) than ChaiNNer's strengths (upscaling, enhancement, batch operations).

How do I update ChaiNNer when new versions are released?

ChaiNNer doesn't have automatic updates. Check for new versions manually by visiting the GitHub releases page periodically. Download the latest installer for your platform and install over the existing version. Your workflows (.chn files) and models remain intact during updates - they're stored separately from the application. Backup important workflows before updating as a precaution, though updates rarely break workflow compatibility. Subscribe to the GitHub repository or Discord announcements to get notified of new releases.

Can ChaiNNer optimize images for web use with modern formats like WebP and AVIF?

Yes, ChaiNNer supports modern web formats including WebP and AVIF alongside traditional formats like JPEG and PNG. Use the "Save Image" node and select format from the dropdown, then configure quality settings. WebP typically provides better compression than JPEG at similar quality levels, while AVIF offers even better compression but with less widespread browser support. ChaiNNer can batch convert entire folders to WebP or AVIF with quality control, making it excellent for optimizing web image libraries. Combine with resizing nodes to create perfectly optimized web assets.

What's the best way to process images from multiple projects with different requirements?

Create separate workflow files for different project types and organize with clear naming. For example: portrait-upscale-4x.chn, product-print-prep.chn, social-media-optimize.chn, etc. Store workflows in a dedicated folder with documentation about what each does. When starting a new project, load the appropriate workflow, point it to the project's input folder, adjust output location, and run. You can also create "template" workflows that you modify for specific projects, saving the modified version with the project name. This workflow library approach saves time and ensures consistent processing across similar projects.

Conclusion: Mastering ChaiNNer for Professional Image Processing

ChaiNNer fills a critical gap in AI image workflows - the space between generation and final delivery. While tools like ComfyUI excel at creating images and platforms like Photoshop handle complex manual editing, ChaiNNer owns batch processing, automation, and systematic post-processing operations that would be tedious or impossible manually.

The node-based workflow paradigm makes complex operations visual and accessible without requiring programming knowledge, while still providing the power and flexibility that programmers would appreciate. Once you've built and saved workflows for common tasks, processing thousands of images becomes as simple as selecting an input folder and clicking run.

Your Learning Path:

Start with simple workflows - upscaling a single image, converting formats, basic enhancement. Build familiarity with the interface, node connections, and data flow before attempting complex chains or conditional logic.

Progress to batch processing as you become comfortable with single-image workflows. The jump from processing one image to processing hundreds is trivial in ChaiNNer once your workflow is designed correctly.

Explore model chaining when you need maximum quality. Understanding how different AI models complement each other and learning to combine them strategically elevates your results from good to professional-grade.

Integrate with your broader workflow - whether that's ComfyUI for generation, Photoshop for final touches, or web delivery pipelines. ChaiNNer works best as part of a comprehensive toolkit rather than a standalone solution.

The Time Investment:

Expect to spend 2-4 hours learning ChaiNNer basics, building your first functional workflows, and processing your first batch successfully. This initial investment pays dividends immediately - tasks that would take hours or days manually complete in minutes or hours unattended.

As you build a library of workflows for common tasks, processing time approaches zero for routine operations. Load workflow, select input folder, run - finished.

Real-World Applications:

Photographers processing hundreds of wedding photos with consistent enhancements. Content creators generating social media assets in multiple sizes and formats. Print shops preparing customer files for production. AI artists post-processing generated outputs for professional delivery. Digital archivists modernizing and enhancing historical image collections.

Each use case benefits from ChaiNNer's core strength: automating repetitive image operations that require consistency and precision.

Looking Forward:

ChaiNNer development continues actively, with new models, formats, and capabilities added regularly. The fundamentals you learn now - node-based thinking, workflow design, model selection - remain relevant as the tool evolves.

The broader trend toward node-based tools for creative work (ComfyUI for generation, ChaiNNer for processing, Blender for 3D, etc.) means investing time in understanding this paradigm pays off across multiple tools and domains.

For users who want the power of automated batch processing without managing separate tools, platforms like Apatero.com integrate these capabilities into unified workflows. For those who need maximum flexibility and control over custom processing pipelines, ChaiNNer provides professional-grade capabilities at no cost beyond your time investment.

Master ChaiNNer's node-based workflows and model chaining techniques, and you'll never again face the prospect of manually processing hundreds or thousands of images. The tedious becomes automated, the time-consuming becomes instant, and what was previously impossible becomes routine.