home / skills / willsigmon / sigstack / upscale-expert

This skill helps you upscale images with AI, enhancing resolution and quality across tools for faster photo restoration and web-ready assets.

npx playbooks add skill willsigmon/sigstack --skill upscale-expert

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.7 KB
---
name: Upscale Expert
description: AI upscaling - image enhancement, resolution increase, photo restoration
allowed-tools: Read, Edit, Bash, WebFetch
model: sonnet
---

# Upscale Expert

Enhance image resolution and quality with AI.

## Tools Comparison

| Tool | Best For | Free Tier | Pricing |
|------|----------|-----------|---------|
| Topaz Gigapixel | Photos | Trial | $99 one-time |
| Real-ESRGAN | Open source | Unlimited | Free |
| Magnific AI | Creative upscale | 10 images | $39/mo |
| Let's Enhance | Easy web tool | 10 images | $12/mo |
| Upscayl | Local, free | Unlimited | Free |

## Upscayl (Free, Local)

Best free option for developers.

### Install
```bash
# macOS
brew install --cask upscayl

# Or download from upscayl.org
```

### CLI Usage
```bash
upscayl-cli -i input.png -o output.png -s 4 -m realesrgan-x4plus
```

### Models
- `realesrgan-x4plus`: General purpose
- `realesrgan-x4plus-anime`: Anime/illustrations
- `ultramix_balanced`: Balanced quality
- `ultrasharp`: Maximum sharpness

## Real-ESRGAN (Python)

### Install
```bash
pip install realesrgan
```

### Usage
```python
from realesrgan import RealESRGAN
from PIL import Image

model = RealESRGAN('cuda')  # or 'cpu'
model.load_weights('weights/RealESRGAN_x4plus.pth')

image = Image.open('input.png')
upscaled = model.predict(image)
upscaled.save('output.png')
```

### CLI
```bash
realesrgan-ncnn-vulkan -i input.png -o output.png -s 4
```

## Magnific AI (Creative)

Best for creative enhancement, not just upscaling.

### Features
- Resolution increase up to 16x
- Creative hallucination (adds detail)
- Style control
- Face enhancement

### API
```python
import requests

response = requests.post(
    "https://api.magnific.ai/v1/upscale",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "image_url": "https://example.com/image.jpg",
        "scale": 4,
        "creativity": 0.5,  # 0-1, higher = more AI enhancement
        "style": "photo"    # photo, art, anime
    }
)
```

## Use Cases for App Development

### App Store Screenshots
```bash
# Upscale 1x to 3x for retina displays
upscayl-cli -i screenshot.png -o [email protected] -s 3
```

### Icon Generation
```bash
# From 256px to 1024px for App Store
upscayl-cli -i icon_256.png -o icon_1024.png -s 4
```

### Marketing Assets
```bash
# Upscale for print/billboard
upscayl-cli -i hero.png -o hero_print.png -s 8
```

## Batch Processing

### Script
```bash
#!/bin/bash
for file in input/*.png; do
    filename=$(basename "$file")
    upscayl-cli -i "$file" -o "output/${filename%.png}_4x.png" -s 4
done
```

### Python
```python
from pathlib import Path
from realesrgan import RealESRGAN
from PIL import Image

model = RealESRGAN('cuda')
model.load_weights('weights/RealESRGAN_x4plus.pth')

for path in Path('input').glob('*.png'):
    image = Image.open(path)
    upscaled = model.predict(image)
    upscaled.save(f'output/{path.stem}_4x.png')
```

## Quality Tips

### Best Results
1. Start with highest quality source
2. Remove compression artifacts first
3. Use appropriate model for content type
4. Don't upscale more than 4x per pass

### Multiple Passes
```bash
# For extreme upscaling, do 2 passes
upscayl-cli -i input.png -o temp.png -s 4
upscayl-cli -i temp.png -o output.png -s 4
# Total: 16x upscale
```

### Face Enhancement
```bash
# Use GFPGAN for face restoration
pip install gfpgan
gfpgan -i face.png -o restored.png --upscale 4
```

## Comparison by Content

| Content | Recommended Tool |
|---------|------------------|
| Photos | Topaz or Real-ESRGAN |
| Anime/Art | Waifu2x or Real-ESRGAN-anime |
| Faces | GFPGAN |
| Text/UI | Lanczos (no AI) |
| Creative | Magnific |

Use when: App Store assets, marketing images, icon generation, photo restoration

Overview

This skill provides practical guidance and tools for AI-powered image upscaling, enhancement, and photo restoration. It compares popular upscaling options, shows local and cloud workflows, and offers scripts and tips for batch processing and quality control. The focus is on fast, reliable results for app assets, marketing materials, and photo restoration.

How this skill works

The skill inspects image content and recommends the right model or tool (Real-ESRGAN, Upscayl, Topaz, Magnific AI, GFPGAN) based on photo, anime, face, or creative needs. It provides install and CLI/Python examples to run local upscaling, APIs for creative cloud upscaling, and scripts for batch processing. It also outlines quality steps like artifact removal, model selection, and safe multi-pass upscaling.

When to use it

  • Prepare App Store screenshots and multi-resolution assets for retina displays
  • Generate high-resolution icons and marketing images for print or billboard
  • Restore old photos and enhance facial details before editing
  • Batch-upscale large image sets for a release or migration
  • Experiment with creative upscaling where AI can add stylistic detail

Best practices

  • Start from the highest-quality source possible and remove JPEG artifacts before upscaling
  • Choose models by content: anime models for illustrations, face restoration for portraits, general models for photos
  • Avoid single-pass upscaling beyond 4x; use controlled multi-pass steps if needed
  • Run batch jobs locally with CLI tools like Upscayl or Real-ESRGAN for privacy and speed
  • Validate text/UI images with traditional resampling (Lanczos) to avoid AI hallucination

Example use cases

  • Upscale app screenshots 1x→3x for retina and store listing imagery
  • Convert 256px icons to 1024px for App Store submissions using a 4x model
  • Batch-process product photos into print-ready hero images at 8x or multi-pass 16x
  • Restore and enhance old portrait photos with GFPGAN face restoration prior to color correction
  • Use Magnific AI when you want stylistic/detail hallucination and creative control via API

FAQ

Which tool is best for free local processing?

Upscayl and Real-ESRGAN are the best free local options; Upscayl offers an easy GUI/CLI while Real-ESRGAN provides Python integration for pipelines.

How do I avoid AI artifacts on UI or text?

Use classical resampling like Lanczos for text and UI. If using AI, test on representative samples and keep enhancement conservative to avoid hallucinated details.