Check whether the Retro Diffusion local backend is reachable on ws://127.0.0.1:8765.

By default this only opens a socket (zero side effects). With handshake=True it also performs the version handshake, which makes the backend minimize its console window once - avoid unless diagnosing.

Start the Retro Diffusion local backend (image_server.py in the extension venv) if not already listening.

Headless: no console window, UTF-8 IO env, logs to mcp-backend.log.

Ask the Retro Diffusion backend to shut down (also closes its console window loop).

List available Retro Diffusion style LoRAs (.pxlm) with their alias keys.

List selectable base models, ControlNet models, texture tiling modes and dimension presets.

Save a named generation preset (any rd_generate kwargs) to presets.json.

List saved generation presets.

Return a saved preset's settings so they can be passed to rd_generate.

Delete a saved preset.

Text to Image with the local Retro Diffusion pixel-art model.

Output pixels = width//pixel_size (or a size_preset like 64x64/160x144, swap=True transposes). Internally normalized onto RD's 8px latent grid so small sprites never degrade. quality ~1.6-6 drives steps; cfg_scale is the prompt scale; adherence 0-5 trades ELLA/CLIP guidance. Modifiers: comp_* (hue/tint/brightness/saturation/contrast/outline sliders), light_* (directional lighting leco). Rendering options: pixelvae (fast pixel decoder), rembg, post_process (auto reduce colors), tile_x/tile_y. Display: save_grid composes one grid PNG; save_progress stores intermediate previews. preset + overrides replays a saved preset (other args ignored).

Image to Image: refine/repaint existing PNGs. strength 0-100.

Inputs are resized to max side 512 like the UI does. Same advanced options as rd_generate.

ControlNet Text to Image.

controlnets: list of {model: Composition|Depth|Pose|Sketch|Tile, weight: 0-100, process: bool (preprocess input), enabled: bool}; control_images: parallel list of input PNG paths (None for disabled slots). Palette constraint via palette_files (PNG palettes) or palette_url. Uses explicit steps (no quality).

ControlNet Image to Image: same as rd_cn_txt2img plus a source image (appended after the ControlNet slots, resized to 512 like the UI) and strength 0-100.

Neural Transform: re-imagine the input image in a new style/pose from a prompt.

Neural Pixelate: convert an image (photo/render) into pixel art.

blip auto-captions the input; color_map preserves the source palette.

Neural Resize: change pixel density/resolution of pixel art while keeping detail coherent.

Neural Detail: add or remove detail (detail 0-100) on existing pixel art.

Retrodiffusion.ai cloud API: text to image (needs an API key: arg, RD_API_KEY env, or the extension's settings rdapikey).

Retrodiffusion.ai cloud API: image to image (needs an API key).

Retrodiffusion.ai cloud API: text to animation. Returns frame PNGs plus an assembled GIF (needs an API key).

Retrodiffusion.ai cloud API: image to animation. Returns frame PNGs plus an assembled GIF (needs an API key).

Remove Background: cut the background out of images (ISNET matting).

Generate Textures: PBR maps (normal/roughness/displacement) from images.

tiling: none | seamless | mirror | replicate (extend).

Palettize: reduce images to a palette (file/URL constrained or automatic).

dither: None | Bayer 2x2 | Bayer 4x4 | Bayer 8x8; dither_strength, denoise, smoothness, intensity are 0-100 sliders mirroring the UI.

Color Style Transfer: recolor images to match a reference image's palette.

strict enforces the exact reference colors.

K-Centroid Resize: downscale images with k-means palette preservation (centroids = target colors), optionally re-adding an outline.

Generate a color palette with Retro Diffusion's palette model.

Returns the swatch image path plus extracted hex colors (row-major, deduplicated).

Extract a text prompt/description from a reference image (BLIP captioning, optionally guided by a partial description).

Translate/enhance prompts into model-friendly English prompt text.

Run the backend benchmark (throughput/consistency measurement).

Reduce a PNG to an indexed palette (GBA-friendly) and return the hex palette.

Pillow median-cut quantization; output is a P-mode PNG. Default out_path sits next to the input with a _q{colors} suffix.

Import a PNG (e.g. an RD generation) into an .aseprite sprite as a new layer.

The image cel is placed at (0,0) on the given 1-based frame. The sprite file is saved in place. Runs headless via the Aseprite CLI.

Append each PNG as a new animation frame on a new layer of an .aseprite sprite.

Useful to turn RD generations into idle-animation frames. Optionally wraps the new frames in an animation tag. Saves in place, headless CLI.

Create a new .aseprite sprite (rgb|grayscale|indexed). Returns its path.

Sprite metadata: dimensions, color mode, frames (with durations), layers, tags.

Save a sprite copy to a new path.

Draw individual pixels [{x,y,r,g,b,a}] (or hex via r/g/b/a ints) on a cel.

merge=True skips fully transparent pixels (sprite stamping); default replaces everything including alpha.

Convenience: draw pixels given as [{x, y, color: '#rrggbb' or '#rrggbbaa'}].

Read a rectangular region of a cel as {width,height,pixels:[{x,y,r,g,b,a,hex}]}.

Draw a line (Bresenham, optional thickness).

Draw a rectangle (filled or outline).

Draw a circle (filled or outline).

Draw a polyline/polygon through points.

Fill a region with a dither pattern (bayer_2x2/4x4/8x8, checkerboard, noise).

Flood fill from a point (paint bucket), RGBA tolerance 0-255.

Set the server-side selection to a rectangle.

Set the server-side selection to an ellipse (bounding box).

Select the whole cel.

Clear the server-side selection.

Move the selection bounds (not pixels).

Current selection state.

Copy the selected pixels to the server clipboard (keeps sprite intact).

Copy the selection to the clipboard and clear it in the cel.

Paste the server clipboard onto a cel at (x,y), respecting alpha.

Draw an outline around non-transparent pixels of a cel.

Directional cell shading: recolor opaque pixels of the base color toward shadow/highlight depending on which way the silhouette faces the light.

Detect jagged diagonal edges and suggest (or apply) 50% blend pixels.

Color-wheel analysis: complementary pairs, triads, analogous groups, temperature.

Return the sprite palette as hex colors.

Replace the sprite palette with the given hex colors.

Set one palette entry by index.

Append a color to the sprite palette (grows by one).

Sort the sprite palette by hue|saturation|brightness|luminance.

Append a frame; returns the new frame count.

Delete a 1-based frame.

Duplicate a frame; insert_after=0 appends at the end.

Set a frame's duration in ms.

Create an animation tag (forward|reverse|pingpong).

Delete an animation tag by name.

Add a new image layer.

Delete a layer by name.

Flatten all layers into one.

Make a cel linked (shared image) with another frame's cel.

Scale the whole sprite (nearest|bilinear).

Box-ish downsample to target size (bilinear then nearest for pixel art).

Resize canvas without scaling content (anchor: center|top_left|top_right|bottom_left|bottom_right).

Rotate 90/180/270 degrees clockwise (sprite or active layer).

Flip horizontally|vertically (sprite or active layer).

Crop the sprite to a rectangle.

Trim transparent borders (optionally by grid boundaries).

Convert color mode: rgb|grayscale|indexed, with optional ordered dithering (none|ordered) and bayer2x2|bayer4x4|bayer8x8 matrix.

Export sprite to png|gif|jpg|bmp; frame=0 exports the animation.

Export a spritesheet (horizontal|vertical|rows|columns|packed) with optional JSON metadata.

Rename a layer (accepts group/child paths).

Duplicate a layer with independent copies of all its cels, plus opacity and blend mode. The copy lands directly above the source; default name is the source name plus a copy suffix.

Move a layer to a 1-based stack position (1 = bottom).

Set a layer's blend mode: normal, darken, multiply, color_burn, lighten, screen, color_dodge, addition, overlay, soft_light, hard_light, difference, exclusion, subtract, divide, hue, saturation, color, luminosity.

Merge a layer into the layer directly below it (must not be bottom).

Set layer opacity 0-255.

Show or hide a layer.

Replace one color with another across a layer (None = all layers), preserving alpha. frame=0 processes every frame. tolerance is per-channel 0-255. Returns the number of pixels replaced.

Shift hue (-360..360 deg), saturation (-100..100) and lightness (-100..100) of all opaque pixels: palette swaps, night scenes, shadow layers. layer None = all layers; frame=0 processes every frame.

Magic eraser: make every pixel matching a color fully transparent (per-channel tolerance 0-255). layer None = all layers, frame=0 = every frame. Returns the number of pixels erased.

Fill a rectangle with a two-color Bayer 4x4 ordered-dither gradient (the classic pixel-art blend: no new intermediate colors). Top-to-bottom by default; horizontal=true runs left-to-right. Coordinates are sprite-global (the cel is normalized to the canvas).

List the built-in retro palette presets (gameboy, pico8, c64, cga, dawnbringer16/32, grayscale_4, monochrome) with their hex colors. Pure data: works without Aseprite.

Set the sprite palette to a built-in retro preset. Only the palette is changed; snap existing pixels with ase_quantize_to_palette afterwards.

Generate a dark-to-light shading ramp around a base color using the standard pixel-art hue-shift technique: shadows lean cooler, highlights lean warmer, saturation tapers toward the light end. Pure computation (no Aseprite needed); feed the result to ase_set_palette or shading ops.

Returns the ramp darkest-first.

Snap every opaque pixel to the nearest color in the sprite's own palette (RGB distance, cached per color). layer None = all layers, frame=0 = every frame. Run after ase_apply_palette_preset / ase_set_palette to make existing art conform. Returns the number of pixels changed.

Append N blank frames, each with the given duration. Returns the new frame count.

Set every frame's duration in ms (unit-probed for Aseprite 1.3+).

Create an empty canvas-sized cel on a layer/frame (no-op if one exists). layer None = first image layer.

Delete the cel on a layer/frame (makes it truly empty, unlike painting it transparent). layer None = first image layer.

Copy a cel's image from one frame to another (independent clone, unlike ase_link_cel which shares the image). layer None = first image layer.

Place a cel at sprite coordinates (x, y). layer None = first image layer; errors when the cel does not exist (create/draw one first).

Set a single cel's opacity 0-255 (layer None = first image layer).

Copy the cels of a source frame across a frame range (per layer list; None = every image layer). The animation workhorse: draw once, propagate, then tween positions. replace=True overwrites existing cels.

Tween a cel's position linearly across a frame range (movement arcs, attacks, slides). easing: linear | ease_in | ease_out | ease_in_out | smoothstep. Missing cels are cloned from the start frame when create_missing=true. layer None = first image layer.

Sine-wave cel motion across a frame range (bobbing, breathing, hovering). Offsets are applied relative to each cel's position at script start, so run once per animation pass. x follows sin, y follows cos. layer None = first image layer.

Create a named slice (rectangular region exported for game engines).

Set a slice's 9-patch center rectangle (relative to the slice origin): the stretchable region for game-engine 9-patch scaling.

Set a slice's pivot point (relative to the slice origin).

List all slices with bounds, 9-patch centers and pivots.

Delete a slice by name.

Create a tilemap layer with its own tileset: sets the sprite grid to the tile size and adds the layer. Tile index 0 is the reserved empty tile; draw real tiles with ase_draw_on_tile (which appends on demand).

Paint pixels into a tile of a tilemap layer's tileset. Coordinates are tile-local (0,0 = tile top-left); pixels are [{x, y, color: '#rrggbb'}]. tile_index 1 is the first real tile (0 is the reserved empty tile); passing tile_index == current tile count appends a new tile.

Place tiles on a tilemap layer by grid position. tiles are [{col, row, tile_index}] (col/row are 0-based grid coordinates; tile_index 0 clears the cell). The cel is (re)built at map size.

Read which tile occupies a grid cell (0 = empty).

Tilemap layer info: tile size, real tile count (excluding empty tile 0), and map dimensions in cells.

Render a frame over translucent ghosts of neighboring frames (batch onion-skinning) to check motion continuity without opening Aseprite. The flattened frames are exported via the CLI and composited with Pillow over white, then nearest-neighbor scaled. Returns the PNG path.

Diff two frames of the flattened sprite: changed pixel count, percent, and the bounding box of the changed region. Use while animating to confirm a frame actually changed (or did not change too much).

Histogram the colors of a flattened frame: unique color count, opaque pixel count, and the most-used colors. Catches palette drift and near-duplicate colors.

Export each visible layer as its own PNG named after the layer (--split-layers). out_dir defaults to output/layers_/. include_hidden also exports hidden layers.

Export an animation tag: .gif output gives an animation, .png a frame-numbered sequence. The tag is validated up front because Aseprite's --tag silently exports ALL frames for a missing tag. output_path defaults to output/_.gif.

Execute arbitrary Aseprite Lua in batch mode - the escape hatch when no dedicated tool fits (full API: https://www.aseprite.org/api/). One script can batch many operations into a single Aseprite launch.

Essentials: when sprite_path is given it is opened first and bound to a local 'spr' (also app.activeSprite); changes are NOT saved automatically - call spr:saveAs(spr.filename) at the end; print() is the only way to return data (captured in the result's output list); do NOT end the script with a top-level return (it skips the completion marker and the call is reported as failed). Cel-image coordinates are cel-local: offset sprite-global coordinates by cel.position.

WARNING: executes unrestricted Lua (including io/os access) on the host running Aseprite. Only pass scripts you trust.

Check whether the headless Aseprite CLI is available (executable present and a probe batch run succeeds). Cached 60s; file-touching ase_* tools gate on this and report {available:false,...} instead of crashing when missing.

When the executable cannot be found the result also carries the locations that were probed, so an install in a custom folder can be pointed at directly instead of guessed.

One-call overview of what this server can currently do: Aseprite (primary subsystem) and Retro Diffusion (conditional) availability, the gating behavior, and how to fetch image content back to the caller.

Return a PNG file's bytes as a PLAIN TEXT base64 field in the JSON result ({"png_base64": "iVBORw0...", "mime": "image/png", "bytes": N, ...}) instead of an ImageContent block, so the caller can decode and write it themselves (e.g. into a sandboxed outputs directory). Transparency is preserved. max_side=0 keeps the original size; otherwise downscale before encoding.

Return an image file as MCP image content so the caller can SEE it (downscaled to max_side for token sanity), preceded by an info dict.

Return several image files as MCP image content blocks (animation frames, before/after pairs), each preceded by its info dict.

Render one cel of a sprite to PNG and return it as MCP image content so the caller can SEE the current sprite state (layer defaults to first).

Check whether Krita is running with the MCP plugin active (forced probe).

Create a new canvas in Krita.

Set the foreground (paint) color (hex like #ff6b6b).

Set brush preset and properties (preset partial name, size px, opacity 0-1).

Paint a stroke through [x, y] points; pressure 0-1.

Fill a circle at (x, y) with the current color.

Draw rectangle|ellipse|line on the canvas; x2/y2 are line endpoints.

Export the current Krita canvas to PNG (plugin output dir).

as_base64=true returns the PNG bytes as a plain text png_base64 field for callers that decode/write themselves; otherwise returns the plugin result including the exported path.

Undo the last action in Krita.

Redo the last undone action in Krita.

Clear the canvas to a solid color.

Save the current Krita document to path (.kra/.png/...).

Sample the canvas color at (x, y) (eyedropper).

Falls back to exporting the canvas and reading the pixel locally when the Krita plugin's native action fails (older plugin builds crash on bytes formatting until Krita is restarted with the patched plugin).

List Krita brush presets (partial-name filter).

Open a file in Krita (.kra, .png, .jpg, ...).

Active Krita document overview: name, filename, size, resolution, color model/depth, layer count, active layer, selection state, zoom, Krita version.

Layer tree of the active document (top-of-stack first): name, type, visibility, lock, opacity, blending mode, bounds, nested children.

Create a paint or group layer. above = existing layer name to stack it over (default: top). The new layer becomes active.

Make a layer the active paint target (searched recursively by exact name).

Change layer visibility/lock/opacity/blending mode/name. Only the provided fields are touched.

Delete a layer (refuses to delete the only top-level layer).

Duplicate a layer with its full pixel content; the clone lands directly above the source and becomes active.

Merge a layer into the one below it.

Export a canvas region as PNG (merged projection; layer=None reads the whole composite). width/height 0 = to the canvas edge. Returns the file path; as_base64 also returns the PNG bytes as a text field. Pair with px_view_image / read_image to LOOK at the canvas.

Stamp a PNG file into a layer at (x, y) - the bridge for bringing Aseprite sprites or Retro Diffusion generations into Krita. layer=None targets the active layer.

List Krita filter names usable with krita_apply_filter (partial-name filter).

Crash-free image adjustments on a Krita layer region, computed with Pillow over the get_pixels/set_pixels PNG bridge (libkis Filter.apply() hard-crashes Krita 5.3.3, so native filters are quarantined; see krita_list_filters for names).

operation: invert | grayscale | hsv (hue_shift -360..360, saturation_shift/value_shift -100..100) | blur (radius px) | bright_contrast (brightness/contrast factors, 1.0 = unchanged) | posterize (bits 1-8). width/height 0 = to the canvas edge; layer=None targets the active layer. Alpha is preserved throughout.

Set the global selection to a rectangle, or the whole canvas (all=True).

Modify the current selection: invert | feather(radius) | grow(x_radius,y_radius) | shrink(x_radius,y_radius,edge_lock) | smooth | erode | dilate | border(x_radius,y_radius).

Current global selection: exists flag plus bounding box.

Deselect everything.

Resize the canvas without scaling content (crop or expand). x/y is the offset of the old canvas inside the new one (negative crops).

Scale the whole image to new pixel dimensions (resampling strategy: Bilinear | NearestNeighbor | Lanczos3 ...). xres/yres 0 keeps the current resolution.

Flatten all layers of the active document into one.

Export every top-level layer as its own PNG (trimmed to its bounds). Defaults to the plugin's canvas output dir; returns per-layer paths.

Control the active view's canvas: zoom level (1.0 = 100%), rotation degrees, mirror, wrap-around mode. Only provided fields change; returns the resulting zoom/rotation.

List Krita QAction names runnable via krita_run_action (partial-name filter on name or display text).

Trigger any named Krita action (e.g. flatten_image, mirror_canvas, view_zoom_in, selectiontool...). Unknown names return did_you_mean suggestions from krita_list_actions.

Execute arbitrary Python inside Krita (escape hatch). The namespace provides: krita module, Krita/app, doc (active Document), view, InfoObject, Selection, QImage, os, json, math. print() is captured into the result's output field; assign to a variable named result to return a value (repr'd).

WARNING: executes unrestricted code inside the running Krita process. Only pass code you trust.