claude-paint CLI
A Rust oil painting simulator and an easel with MCP: an agent paints with brushes, mixes paint and views the canvas
- 156 ★ on the repository
- Last commit
Extended access
Why this level
- The easel runs Lua code written by the agent and writes canvas and journal files
- The remote HTTP adapter exposes a service externally and requires authentication
Install
Manual install
Install Rust, a C compiler, Python 3.10+, uv and Perl and run `cargo build --release -p easel`. Prepare a studio with `scripts/prepare_capy_studio <profile> <path> --brief <BRIEF.md> --studio-notes <notes>`, which prints JSON with the command that starts MCP over stdio. Connect that server to the agent and use the `paint`, `look`, `note`, `status` and `log` tools.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The easel runs Lua code written by the agent and writes canvas and journal files
- The remote HTTP adapter exposes a service externally and requires authentication
This is third-party code. Review the repository files before installing.
What it does
claude-paint is the project of an artist-programmer where an agent learns to paint in oils on a simulator. The Rust engine models a bristle brush that carries wet paint over a primed linen canvas. Paint levels and dries on a clock, and layers combine by Kubelka–Munk optics. Color comes only from piles knifed together from named tubes. The `easel` is a live Lua session over the engine. The MCP adapter in `harness/easel_mcp` gives the agent five tools: `paint` (run Lua), `look` (get a PNG of the canvas with a caption), `note` (a journal entry), `status` and `log`. `wait(minutes)` pauses remain Lua inside `paint`. The `scripts/prepare_capy_studio` script exports a studio with an approved brief and prints JSON with the command that starts MCP over stdio. For a painter whose easel and stream stay on the Mac there is a remote HTTP adapter with authentication. `notes/` holds an easel guide, techniques (planning, glazing, scumbling) and research notes on materials. Finished paintings live in the author separate repositories.
Who it is for. Researchers and artists studying how agents work with a physical creative tool, and developers who want an example of an MCP adapter for a Lua session.
Good fit when
- You want to see a model paint a picture from a brief, with a journal, timelapse and final image
- You need an example MCP server that gives an agent canvas images with a caption
- You need an engine with a faithful model of brushstrokes, layer drying and pigment mixing
- You need to run the easel remotely on a Mac and connect an agent over HTTP with authentication
Not a fit when
- You need an ordinary text-to-image generator: this is step-by-step painting through code
- You need a quick one-request result: a painting is made in long sessions of strokes
- You need a build without Rust: it requires the Rust compiler, C, Python, uv and Perl
Example request
Connect easel as an MCP server and paint a small study from the brief: mix paint from tubes first, then look at the canvasLimitations
The build needs Rust, a C compiler, Python 3.10 or newer, uv and Perl. The project follows a specific research process (rounds, studios, runners) and many scripts depend on the author paths and infrastructure, so they will not run without adaptation. Paintings, journals and session records live in separate repositories, one of them private.
The easel runs Lua code and writes the canvas to disk. Studio viewing uses the `studio/studio.py` service, which the author runs as launchd background services. The README carries a notice against using the benchmark data in model training.
How to disable. Stop the MCP server in the agent configuration and delete the repository clone with the `target/` directory. Journals and canvases live in the studio folders you created.
FAQ
Which tools does the agent see?
Five: `paint` runs Lua in the session, `look` returns a PNG of the canvas with a caption, `note` writes to the journal, `status` and `log` show state and history.
How do I build the project?
Run `cargo build --release -p easel` to get the `target/release/easel` binary. `scripts/test` runs the checks.
How do I connect it to an agent?
`scripts/prepare_capy_studio` exports a studio and prints JSON with the command, args, working directory and environment for launching MCP over stdio. Register these in the agent settings.
How is paint physically modeled?
A bristle brush carries wet paint over the canvas, a layer levels and dries on a clock and layer mixing is computed by Kubelka–Munk optics.
Where can I see finished paintings?
In the author separate public repository stillwet-paintings-public and on the site stillwet.art.
Discussion
No questions or reviews yet.
Related
CLI toolsA skill that makes Claude a pixel artist: every pixel is placed in Pillow code and every render is checked against a checklist.
An MCP server giving an agent 123 Aseprite tools for pixel art and animation, plus previews to check its own drawing
The Scumble desktop editor with an MCP server of 119 tools: an agent opens, selects, generates and exports images.
Aseprite AI Artist: pixel art through an agent
Aseprite AI Artist
A plugin and MCP server that let an agent draw and animate in your open Aseprite window, with every action undone by one Ctrl+Z
Pixelbolt lets an agent draw and edit pixel art from a JSON recipe: sprites, effects and animations as PNG, GIF and atlases.
A Codex marketplace with three creative plugins: black-pen drawing, animated pixel particles and deadpan watercolor doodles
README in short
The repository holds the engine, easel, runner, scripts, tests and notes. Painting records live in separate repositories. The author describes a workflow of rounds (tags and folders), studio export and viewing painting sessions live or replayed.