Local files. Agent tools. 41 algorithms.

Color with
character.

Give your agent local image tools. Choose from 41 dithering algorithms and 256 palettes. Save recipes to reproduce your settings.

Connect your agent Compare textures

One Go binaryMCP over stdioLocal processing

Fig. 001 / Moon Garden6 colors

Moon Garden rendered with Atkinson dithering in six clay and paper colors

Original ray-traced still life of a waxy-leaf plant, ceramic pot, textured stones, and a golden sphere

OriginalAtkinson

Compare original and result50%

Atkinson · Clay · 2× pixels

Image → recipe → artifactPalettes you choosePixels you keepCreated in your workspace

Supported files

Images and video

Still-image tools apply orientation and supported color profiles before dithering. Local FFmpeg handles video containers and codecs.

Workflow	Input	Output
Still images	PNG, JPEG, GIF, WebP, BMP, and TIFF	PNG, JPEG, GIF, SVG, PBM, and ASCII
Generated animation	One supported still image	Animated GIF or a PNG sprite sheet
GIF animation	Animated GIF	Animated GIF or a PNG sprite sheet
Video	MP4, MOV, WebM, Matroska, and AVI	MP4 (H.264), WebM (VP9), GIF, or a PNG sprite sheet
Print separation	One supported still image	ZIP with PNG ink plates and a JSON manifest

JPEG, PNG, WebP, and TIFF inputs can contain EXIF orientation and RGB ICC profiles. BMP V5 inputs also support embedded RGB ICC profiles. The tool applies all eight orientations and converts supported RGB profiles to sRGB. Untagged RGB images use sRGB. Still-image tools use the first GIF frame. To process all GIF frames, use dither_animate with effect: "source". GIF animation defaults to this mode and preserves source timing. Print separation supports at most 16 inks.

For video, start the server with --allow-video. Install local FFmpeg and ffprobe executables. The tool processes short, bounded segments without audio. Available decoders and codecs depend on your FFmpeg build.

View orientation and color normalization

Stored EXIF orientation 6 and linear RGB samples beside actual upright and sRGB service previews — Stored pixel samples appear at left. Actual local service previews appear at right. A linear neutral sample of 128 converts to sRGB 188. View the original sources and inspection receipts.

01 / Texture studies

Explore the
pixel patterns.

Each algorithm creates a different pixel pattern. Compare these outputs from the Go engine.

Moon Garden detail in warm monochrome, using Atkinson dithering

AtkinsonError diffusion

Botanical still life in the green Game Boy palette — Garden, in green

Mineral still life in a custom dark purple, rust, gold, and cream palette — Stone, in ember

Botanical still life in vibrant magenta and cyan CGA colors — Garden, in CGA

A local Go ray tracer generated the original artwork. dither-mcp produced every processed image.

02 / The color library

Every palette.
A new possibility.

Explore 256 palettes across 16 categories. Filter by category and color count. Use the palette’s exact colors in your next recipe.

Twelve palettes. One Moon Garden.

These Floyd–Steinberg renders use the same source and settings. Choose a study to view its palette.

View the complete palette atlas ↗Download the engine catalog ↓

The Go generator creates these catalog entries, swatches, and image treatments. MCP and the CLI use the same engine.

03 / Agent workflows

Create a
reproducible recipe.

Your agent can compare algorithms, render variations, and save a recipe. Tools return structured results. File-producing tools also return local artifact paths.

Ask your agent

“Create a botanical print with four warm colors. Compare a few algorithms. Save the recipe I choose.”

dither_catalogdither_comparedither_renderdither_recipe_save

Local CLI / same engine

# Render the image with Atkinson and Game Boy colors.
dither-mcp render \
  --root . \
  --input moon-garden.png \
  --output garden.png \
  --algorithm atkinson \
  --palette gameboy \
  --width 960 --pixel-scale 2

# Save the settings in a versioned recipe.
dither-mcp call --root . \
  dither_recipe_save '{"output":"garden.recipe.json",
    "recipe":{"version":1,"palette":"gameboy",
      "options":{"algorithm":"atkinson",
        "pixel_scale":2}}}'

Process images locally

The tool reads images and writes artifacts in your configured workspace. It processes each image locally.

Combine image settings

A recipe combines an algorithm, palette, mask, adjustments, and retro effects. Each operation adds its animation or export settings.

Check the specifications

OpenSpec defines behavior. Quint models input normalization, quantization, artifact publication, and palette discovery. Go tests check the implementation.

04 / Animation

Create a
looping animation.

The animation tool generates loops from still images. It also processes all frames of a source GIF. Both workflows export GIFs or PNG sprite sheets.

Watch the terminal demos

Dithered botanical still life with a wave animation — Wave / 24 frames / 12 fps

05 / Recorded commands

From request
to pixels.

Charmbracelet VHS recorded these local demos. Each demo runs the binary with the artwork above.

Choose a palette. Render a print.

The CLI inspects the local source and creates an Atkinson render.

Compare algorithms. Create an animation.

The CLI creates a contact sheet and exports a looping GIF.

Run a local MCP session.

The Go client discovers 13 tools through stdio. It compares treatments, previews an artifact, saves a recipe, and checks its digest.

Find colors for your next image.

The CLI filters palettes by category and color count. It searches the 256-palette library and renders an image with Oat and Ink.

06 / Connect your agent

Connect your agent
to dither-mcp.

Build the binary locally.
Add it to your MCP client.
Set --root to the folder that contains your images and outputs.

Build from the source checkout

go build -o bin/dither-mcp ./cmd/dither-mcp
./bin/dither-mcp catalog

MCP client configuration

{
  "mcpServers": {
    "dither": {
      "command": "/absolute/path/bin/dither-mcp",
      "args": ["mcp", "--root", "/path/to/images"]
    }
  }
}

Build with Go 1.27. Video processing also uses a local FFmpeg installation. The server sends images and tool results to your connected MCP client. Get the source and setup guide on GitHub.