Docs

Exaro Drawing

Install Exaro Drawing, activate your licence, make your first sprite, and drive it from scripts or from your AI.

The Exaro Drawing page shows the work: two games whose art was made in it and the animations it exported. The app also has its own Help center (Help menu, or F1 over any control) with a section for every tool.

Requirements

Windows 10 or 11, 64-bit.
A mouse, or a pen tablet for pressure and tilt (Wacom and Windows Ink pens work).
Optional: ffmpeg for WebM and ProRes export (winget install ffmpeg, or set EXARO_FFMPEG to the path of ffmpeg.exe). MP4, GIF and APNG are built in.
Optional: an Anthropic or OpenAI API key for the built-in AI assistant. An MCP client such as Claude Code, Codex or Cursor uses its own subscription.

1. Get Exaro Studio and download

Exaro Drawing comes with every Exaro Studio plan (monthly, yearly or Studio); it is not sold on its own.
Sign in, then open your account. Under Exaro Drawing, download the Windows installer, ExaroDrawing-Setup-<version>.exe.
Your licence key is on the same page and under Account › Licences.

2. Install

Run ExaroDrawing-Setup-<version>.exe. It installs for your Windows user, so it does not need an administrator, into %LOCALAPPDATA%\Programs\Exaro Drawing.
It adds Exaro Drawing to the Start menu, opens .exa documents with it, and registers an uninstaller under Settings › Apps.
Your preferences, autosaves and logs live in %LOCALAPPDATA%\ExaroDrawing. Uninstalling removes the program and leaves your documents and preferences alone.

3. Activate your licence

Start Exaro Drawing and open Help › Activate licence…. Paste the key from your account and choose Activate. It works offline for 30 days between check-ins.
An Individual licence covers one person on up to 2 machines; Studio covers five seats with two machines each. To move to a new PC, release the old machine from Account › Licences.
Your licence never locks you out of your own files: whatever the licence state, you can open, save and export your documents.

4. Your first sprite

File › New Pixel Art: pick a size (16 to 256 px), a tile grid and a background. The canvas opens with the pixel pencil and a toolbar holding the eraser, exact-colour fill, colour picker, selection, brush sizes 1 to 4 and the active palette.
Choose a palette (Game Boy, CGA, EGA, C64, DB16, Sweetie 16, Endesga 32 or your own) and draw. Zoom snaps to whole steps; Preview shows the sprite at 1x to 4x, or repeated 3 x 3 to check a tile is seamless.
For animation, add frames on the timeline, tag ranges (walk, idle) and set frame timing.
Export a sprite sheet: a PNG grid, an Aseprite-style JSON file with frames and tags, and optionally a normal map so the sprite takes light in the engine.

Save as .exa to keep layers, the timeline, puppets, tile maps and history metadata. Exaro Drawing also opens and saves PSD, OpenRaster, TIFF, WebP, PNG, JPG, BMP and TGA, and its compatibility report tells you what each format keeps before you save.

5. Scripting: every tool is a command

Everything Exaro Drawing does is a named command with JSON parameters: the menus, the command palette, macros, scripts, the AI assistant and MCP clients all call the same ones. Open the command palette with Ctrl+K to find any command; ones with parameters open a small form. In the AI box, type /help to list them.

Run a script from the command line

A script is a .jsonl file with one {"command": "...", ...parameters} object per line. --script runs it headless (no window) through the real app; --out saves the flattened result as a PNG, --results writes each command's returned data, and --log picks the log file.

# hello.jsonl - one command per line; lines starting with # are comments
{"command": "document.new_pixel", "width": 32, "height": 32}
{"command": "pixel.rect", "x0": 4, "y0": 4, "x1": 27, "y1": 27, "filled": true, "color": "#3b82f6"}
{"command": "pixel.outline", "color": "#000000"}
{"command": "pixel.check", "palette": "sweetie16"}
{"command": "document.save", "path": "hello.exa"}

exarodrawing --script hello.jsonl --out hello.png --log hello.log
exarodrawing --script hello.jsonl --results results.jsonl

Add "expect": {...} to a line to check the data a command returns (the script fails if it does not match), as in the Star Sweeper title card on the product page. Every command logs ok or FAIL with its reason.

Command families

Commands	What they do
`document.*`	New, open, save, export, canvas size. document.new_pixel starts a sprite.
`layer.*`	Add, remove, reorder, opacity, blend modes, masks.
`brush.* · stroke.draw`	Pick a brush or preset and paint a stroke from points with pressure.
`shape.draw · shape.tool`	Filled cartoon shapes (ellipse, box, rounded box, polygon, star) with ink, thick-thin and shading.
`pixel.*`	pixel.write (a character grid), pixel.line, .rect, .ellipse, .outline, .mirror, .cleanup, .check (palette lint).
`palette.quantize · ai.pixelize`	Snap a layer to a palette (with Bayer dither), or turn an image into pixel art.
`selection.* · fill.apply`	Rectangle, ellipse and polygon selections; fills and gradients.
`animation.*`	Frames, timing, tags, onion skin, export to MP4, GIF, APNG, WebM, ProRes, EXR or a PNG sequence.
`export.sprite_sheet`	A grid sheet + Aseprite-style JSON, with an optional normal map.
`tilemap.*`	Build a map from a tileset, paint and fill it, auto-tile terrain, export map + tileset + collision.
`puppet.*`	Rigs, bones, IK, swaps, poses, skins, walk cycles, lip-sync and skeletal export.
`tween.* · curve.* · camera.*`	Tweens and their curves, camera moves and multiplane depth.
`cutscene.*`	Screenplay import, dialogue lines, lip-sync from audio, export with subtitles and a manifest.

Actions and macros

Record what you do, edit the steps and save them as a macro with a shortcut. File paths in a recording become placeholders that you fill in when you replay it.

6. Connect your AI over MCP

Exaro Drawing is an MCP server, so Claude, Codex, Cursor or any MCP client can draw, animate and export with the same commands. There are two ways to connect:

Headless, over stdio. The client starts Exaro Drawing itself: exarodrawing --mcp --mcp-scope read,edit,files. The scope limits what it may do: read, edit, files (open and save) and network.
Into the running app. Exaro Drawing listens on 127.0.0.1 only and writes the port and token to %LOCALAPPDATA%\ExaroDrawing\mcp.json for your client's configuration. The first time a client connects, Exaro Drawing asks you to allow it (read only, edit, edit + files, or deny), and you can revoke it at any time. You watch every change land on the canvas.

Claude Code:

claude mcp add exaro-drawing -- "C:\Users\<you>\AppData\Local\Programs\Exaro Drawing\exarodrawing.exe" --mcp --mcp-scope read,edit,files

Claude Desktop, Cursor and other clients that take a JSON config:

{
  "mcpServers": {
    "exaro-drawing": {
      "command": "C:\\Users\\<you>\\AppData\\Local\\Programs\\Exaro Drawing\\exarodrawing.exe",
      "args": ["--mcp", "--mcp-scope", "read,edit,files"]
    }
  }
}

Every call an AI makes is one undo step labelled with the client's name, so you can step back through exactly what it did. AI-made changes are recorded in the document's provenance.

The built-in assistant

The AI panel takes a request in plain words, proposes a plan, previews the result, and you keep or discard the whole turn as one undo step. Nothing is sent to an AI service until you add a key and allow each kind of data (canvas, prompt, audio, document). Keys are kept in the Windows credential store, budgets cap spending, and the audit log lists every call. Local mode uses on-device operations only.

7. Send it to your engine

Sprite sheets

{"command": "animation.tag.add", "name": "walk", "from": 0, "to": 7}
{"command": "export.sprite_sheet", "path": "hero.png", "json": "hero.json", "normal_map": "hero_n.png", "normal_y_down": true}

normal_y_down is for Unreal; leave it off for Unity and Godot. The JSON sidecar follows Aseprite's layout, so tools that read Aseprite sheets read these.

Puppets as skeletons

{"command": "puppet.auto_rig", "name": "hero"}
{"command": "puppet.cycle", "puppet": "hero", "kind": "walk"}
{"command": "puppet.export_skeleton", "puppet": "hero", "path": "out/hero.json"}
{"command": "puppet.export_skeleton", "puppet": "hero", "path": "out/hero.tscn", "format": "godot"}

Spine format: skeleton JSON, a texture atlas and one PNG per part, with the timeline and each animation tag as an animation.
Unity: the Exaro Skeleton 2D package (a C# skeleton player and an .atlas importer) plays them.
Godot 4: format: godot writes a ready scene.
Unreal: Exaro Unreal imports and plays them with its native skeleton player.

Tile maps

View › Tile Tools turns the canvas into a tileset; paint a map, add auto-tiling terrain and collision, and Export map + tileset + collision writes name.json, name.tiles.png and name.map.png. The JSON is engine-independent: row-major, top-left origin, zero-based tile ids, -1 for empty.

Cutscenes and video

cutscene.from_script imports a screenplay, cutscene.lipsync keys each speaker's puppet mouth to the dialogue, and cutscene.export writes the MP4 with SRT and WebVTT subtitles and a JSON manifest for the engine. Timeline › Export… has presets for video sites, a half-size draft, WebM with transparency for game overlays, and a chat GIF; animation.export also writes ProRes 4444 masters and EXR sequences.

Troubleshooting

WebM or ProRes export says ffmpeg is missing. Install it with winget install ffmpeg and restart Exaro Drawing, or set EXARO_FFMPEG to the full path of ffmpeg.exe.
A script line failed. The log names the line, the command and the reason (cmd[N] name -> FAIL). Run with --log and read it.
An MCP client cannot connect to the running app. Check that it uses the port and token in %LOCALAPPDATA%\ExaroDrawing\mcp.json, and that you allowed it when Exaro Drawing asked.
Exaro Drawing closed unexpectedly. Reopen it: autosave offers to recover your work.

Support

Licence keys, activation, refunds and bugs: [email protected]. Include your Exaro Drawing version (Help › About) and, for a bug, the steps and the log.