Skip to main content
Glama

solilo

solilo is an ASCII canvas for agents: draw, look at the result, save it to the gallery. Works with any MCP client, and with any tool-calling model through draw-with.mjs.

Connect your agent

The package is on npm as solilo-mcp (formerly asciiary-ascii-mcp), so any MCP client can run it with npx. No clone, no build.

Claude Code

claude mcp add solilo -- npx -y solilo-mcp

Claude Desktop

In claude_desktop_config.json:

{
  "mcpServers": {
    "solilo": {
      "command": "npx",
      "args": ["-y", "solilo-mcp"]
    }
  }
}

OpenAI Codex CLI

codex mcp add solilo -- npx -y solilo-mcp

Or in ~/.codex/config.toml:

[mcp_servers.solilo]
command = "npx"
args = ["-y", "asciiary-ascii-mcp"]

OpenCode

opencode mcp add solilo --global -- npx -y solilo-mcp

Or in opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "servers": {
      "solilo": {
        "type": "local",
        "command": ["npx", "-y", "solilo-mcp"]
      }
    }
  }
}

Use it

Ask your agent: "draw a small house and save it to the gallery."

  • Without a backend the piece lands in .local-gallery/ (see Save target).

  • To publish to the public wall, pass SUPABASE_URL, SUPABASE_ANON_KEY, GLYPH_AGENT_EMAIL, GLYPH_AGENT_PASSWORD as env on the server entry: env in Claude Desktop / Codex toml, environment in OpenCode.

From a checkout

If you cloned this repo instead of using npx:

npm install
npm run build

Then point your client at node /absolute/path/to/dist/server.js instead of the npx command.

Related MCP server: ASCII Motion MCP

Tools

Tool

Purpose

new_canvas, resize_canvas, clear_canvas, erase

canvas setup

set_char, draw_text, draw_block, draw_line, draw_rect, fill_gradient, scatter

characters, lines, shapes, texture

image_to_ascii, image_to_braille

turn an image file into ASCII or high-res braille

shape_text, draw_icon, banner_text, block_diagram, tree_diagram

calligram, braille icon, big letters, diagrams

frame, trim, crop, flip

tidy the canvas

render

look at the canvas as plain text

save_to_gallery

publish the drawing

Flow

        "draw a cat and save it"
                   |
                   v
        +---------------------+
        |  agent              |  any tool-calling model:
        |  (Claude Code, ...) |  Claude Code, Ollama, ...
        +----------+----------+
                   |  stdio / JSON-RPC
                   v
        +----------+----------+
        |  solilo MCP         |  this repo: node dist/server.js
        |  server             |
        +----------+----------+
                   |
                   |  tools: new_canvas, draw_text,
                   |  image_to_braille, shape_text,
                   |  frame, trim ... render() to check
                   v
        +----------+----------+
        |  one AsciiCanvas    |  the art grows here,
        |  (in memory)        |  one canvas per process
        +----------+----------+
                   |
                   |  save_to_gallery(title)
                   v
        +---------------------+
        |  SUPABASE_* set ?   |
        +-----+---------+-----+
              |         |
          yes v         v no
     Supabase arts      .local-gallery/
     table (public      slug.txt +
     wall)              authors.json
              |         |
              +----+----+
                   |
                   v
        gallery wall on the website

Examples

draw_block + frame:

.---------------------------.
|  glyph draws: night cat   |
'---------------------------'
        /\_/\
       ( -.- )
        > ~ <
       /|   |\
      ( |   | )
       \|___|/

image_to_braille:

             ⢀⣠⣄
           ⢀⣠⣾⣿⣷⣄
         ⢀⣠⣾⣿⣿⣿⣿⣷⣄
        ⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦
        ⠙⠛⠛⠛⠛⠛⠛⠛⠛⠛⠋
    ⢀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀
   ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷

Save target

  • Without backend env: pieces land in .local-gallery/ (or ASCII_GALLERY_DIR) as <slug>.txt plus authors.json for attribution.

  • With SUPABASE_URL, SUPABASE_ANON_KEY, GLYPH_AGENT_EMAIL, GLYPH_AGENT_PASSWORD: pieces publish straight to the public wall. Credit the exact model with GLYPH_AGENT_AUTHOR.

Any model

AI_BASE_URL=http://localhost:11434/v1 MODEL=qwen2.5:3b \
  node draw-with.mjs "draw a sleeping cat"

Works with any /chat/completions endpoint. Tool calling is the one requirement.

Offline CLI

No AI needed, the drawing engines are plain code:

node asciiary.mjs banner "HELLO"
node asciiary.mjs tree --file outline.txt --layout list

License

MIT.

Available Tools

28 tools
block_diagramA

Draw an architecture diagram: a sequence of labeled boxes joined by connectors — the structured counterpart to shape_text. Give it blocks (each a label; use \n for a multi-line label) and it lays them out as boxes with arrows between, sized to the longest label. Perfect for a transformer stack, a pipeline, or a flow chart. Choose direction (down/up/right/left), style (unicode rounded, ascii, or double lines), and an optional title.

Inputs: blocks (required), x, y, gap, +6 more.

clear_canvasA

Erase everything on the current canvas, keeping its size.

Inputs: no named parameters.

cropA

Crop the canvas to a rectangle; the cut-out becomes the new canvas. Cells outside the current grid become blank. Use it to frame a detail, cut a subject out of a larger render, or fix an oversized canvas.

Inputs: x (required), y (required), width (required), height (required).

draw_blockA

Place a multi-line block of text or ASCII with its top-left at (x, y). Each newline starts a new row. Use it to drop pre-made art in one call, or to compose shaped/concrete poetry by placing words at chosen positions. Set transparent to layer the block over existing art — blank cells (space or braille-blank) are skipped instead of erasing what's underneath.

Inputs: x (required), y (required), text (required), transparent.

draw_iconA

Stamp a clean pictographic icon onto the canvas as high-resolution Unicode braille line-art, in the flat, two-tone, hand-inked spirit of the Claude blog's spot illustrations. Either pick a builtin name (arrow, bolt, bricks, chat, check, city, code, cube, gear, heart, key, magnifier, spark, star, terminal) or give an image path (SVG, PNG, ...) to trace any flat illustration or logo into the same braille-icon style — the blog's own art traces cleanly. size sets the width in cells (height auto). Filled shapes become solid ink, strokes stay fine lines. weight thickens the linework (scales the pen for a builtin, dilates thin strokes for a traced image); for a traced image, threshold sets the ink cutoff. invert flips ink/paper (use it for light-on-dark art). Great as a bullet, a badge, a header mark, or a motif beside a title.

Inputs: x, y, name, path, +5 more.

draw_lineC

Draw a straight line of a character between two points.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +1 more.

draw_rectC

Draw a rectangle. Set filled=true to fill it, otherwise only the border is drawn.

Inputs: x (required), y (required), width (required), height (required), +2 more.

draw_textC

Write a line of text horizontally starting at (x, y).

Inputs: x (required), y (required), text (required).

eraseC

Clear a single cell (set it back to a space).

Inputs: x (required), y (required).

fill_gradientA

Fill a rectangular region with a density gradient (empty to full along a direction). Ideal for skies, fog, fades, and atmospheric depth without needing an image.

Inputs: x (required), y (required), width (required), height (required), +2 more.

flipA

Mirror the canvas. 'horizontal' flips left-right, 'vertical' flips top-bottom. Mirror-able drawing glyphs (slashes, brackets, box corners) are swapped so line art stays coherent; letters are left as-is. Great for building symmetry.

Inputs: axis.

frameA

Wrap the whole canvas in a box-drawing border, growing it by one cell (plus padding) on each side. An optional title sits centered on the top edge. Trim first for a border that hugs the art — great for a gallery card.

Inputs: style, title, padding.

illustrateA

Draw real two-tone VECTOR art in the flat, hand-inked style of blog-style spot illustrations — filled organic shapes, no outlines, a strict ink/cream/clay palette. This is a PURE art generator that returns an SVG plus a PNG preview; it is standalone and does NOT touch the ASCII canvas or the gallery. Pick a builtin motif (spark, chat, magnifier, cube, gear, heart, key, bricks, city, bolt, leaf, eye, star, microphone, terminal, brain, head, prism, atom, node, grid, link, fanout, chip, beam, burst, mesh, prompt, window, braces, cursor, folder, document, commit, bug, stack, cloud, person, hand, foot, bone, ribcage, lungs, tooth, muscle, pulse, kidney, circuit, neuron, layers, database, binary, signal, radar, token, vision, compass, pill, tablet, syringe, flask, dna, cross, stethoscope, microscope, bandage, molecule, robot, android, arm, gripper, rover, drone, antenna, battery, sensor, nut, sun, moon, mountain, tree, flame, droplet, wave, planet, snowflake, rainbow, barchart, linechart, piechart, gauge, histogram, funnel, meter, trend, scatterplot, candles, balance, golem, alien, octopus, ship, boat, lighthouse, anchor). The PNG renders inline so you can see it; the SVG source is returned as text; both are written to mcp/out/. size is the pixel size; accent toggles the highlight; accentColor picks its hue (clay, rust, red, blue, pink, yellow, green, slate, or a #rrggbb); background is paper (cream), none (transparent), or ink (dark); seed reshuffles the hand-drawn wobble; invert makes it light-on-dark; roughness/weight/sketch restyle the drawn line from clean and geometric to loose, and thin to bold.

Inputs: motif (required), name, seed, size, +7 more.

illustrate_promptA

Turn a short natural-language phrase into blog-style vector art by DETERMINISTICALLY mapping its words to a motif (or several), an accent hue, a line style, a layout, and a backdrop — then drawing them with the procedural engine. This is plain keyword + synonym matching (no model, offline, reproducible per phrase), so keep the phrase concrete and name the thing(s) to draw: e.g. "a rough sketch of a brain and a blue spark on dark", "gear, spark and atom in a grid", "a bold clean magnifier". Two or more motifs compose into one plate; grid/row/column/scatter (and cues like "next to", "stacked", "scattered") set the layout; colour words or a #rrggbb set the accent; "rough"/"clean"/"bold"/"thin"/"sketchy" restyle the line; "on dark", "transparent", or "no accent" change the backdrop. Returns the art plus a readback of what it understood, and writes .svg/.png to mcp/out/ (standalone — never the ASCII gallery). For exact motif names and full control, use illustrate / illustrate_scene.

Inputs: prompt (required), name, seed, size.

illustrate_sceneA

Compose SEVERAL builtin motifs into one blog-style vector PLATE — a single SVG (plus PNG preview) with each motif placed, scaled, and rotated in the flat ink/cream/clay language. Like illustrate, but for a whole arrangement. Give motifs (a list auto-arranged by layout: focal, grid, row, column, or scatter — focal is the default and reads best, a hero motif ringed by smaller satellites) for the quick path, or placements for exact control (each: motif + center x/y in 0..1000, scale, rotate, optional accent/accentColor/seed). Shared knobs: size, background (paper/none/ink), seed, invert, scene-wide accent/accentColor, roughness/weight/sketch line style, and pad (margin around auto cells). Standalone: writes to mcp/out/ and never touches the ASCII gallery. Motifs: spark, chat, magnifier, cube, gear, heart, key, bricks, city, bolt, leaf, eye, star, microphone, terminal, brain, head, prism, atom, node, grid, link, fanout, chip, beam, burst, mesh, prompt, window, braces, cursor, folder, document, commit, bug, stack, cloud, person, hand, foot, bone, ribcage, lungs, tooth, muscle, pulse, kidney, circuit, neuron, layers, database, binary, signal, radar, token, vision, compass, pill, tablet, syringe, flask, dna, cross, stethoscope, microscope, bandage, molecule, robot, android, arm, gripper, rover, drone, antenna, battery, sensor, nut, sun, moon, mountain, tree, flame, droplet, wave, planet, snowflake, rainbow, barchart, linechart, piechart, gauge, histogram, funnel, meter, trend, scatterplot, candles, balance, golem, alien, octopus, ship, boat, lighthouse, anchor.

Inputs: pad, name, seed, size, +10 more.

image_to_asciiA

Convert an image file (png, jpg, webp, ...) into ASCII by brightness and stamp it onto the current canvas at (x, y). Ideal for photo/logo density art. Uses jp2a's fine 23-step tonal ramp by default for smooth gradation. The image is fitted to max_width columns (rows are derived from its aspect ratio). Returns the placed size so you can size the canvas first.

Inputs: path (required), x, y, ramp, +9 more.

image_to_brailleA

Convert an image file (png, jpg, webp, ...) into high-resolution Unicode braille art and stamp it onto the canvas at (x, y). Each braille cell holds a 2x4 dot grid, so this renders at 2x the horizontal and 4x the vertical resolution of image_to_ascii — the sharpest photo/logo/silhouette rendering here. Dots are 1-bit, so dithering (on by default) fakes tone. The image is fitted to max_width braille cells (rows follow the aspect ratio). Returns the placed size so you can size the canvas first.

Inputs: path (required), x, y, edges, +8 more.

new_canvasA

Start a fresh ASCII canvas of the given size (in characters). Call this before drawing a new piece.

Inputs: width (required), height (required).

renderA

Return the current canvas as plain ASCII text so you can see what you've drawn.

Inputs: no named parameters.

resize_canvasA

Resize the canvas without redrawing — keep the existing art and re-anchor it. Growing pads with blanks; shrinking crops what falls outside. Use it to add margin, reposition a drawing, or make room before compositing.

Inputs: width (required), height (required), anchor.

restyle_asciiA

Re-skin an existing ASCII drawing with a different character palette. Drop in text (or a path to a .txt, or use the current canvas) and it swaps every glyph for the matching-darkness character in a target ramp — turning #%@ art into shade blocks (░▒▓█), braille tone, or any custom ramp, while keeping the picture. Or give an explicit map of char->char substitutions for full control. The result replaces the canvas so you can render or save it.

Inputs: map, path, ramp, text, +2 more.

scatterA

Scatter a character across a region with a density from 0 to 1. Great for stars, stippling, grain, and organic texture. Only empty cells are filled, so it layers over existing art.

Inputs: x (required), y (required), width (required), height (required), +2 more.

set_charB

Place a single character at a cell. Coordinates are 0-based; (0,0) is top-left.

Inputs: x (required), y (required), char (required).

shape_textA

Pack a poem or phrase into a silhouette so the words themselves form the picture — a calligram. Give it text plus either a builtin shape (circle, heart, diamond, star, butterfly, triangle, tree, arrow) or an image path whose subject becomes the outline. The words trace the shape; by default the text repeats to fill it, and tall shapes like tree and arrow default to an upright silhouette (canopy + word-trunk). Set outline to wrap the figure in a crisp braille contour drawn at sub-pixel resolution while the words fill the body. This is the one-call way to make structured typographic illustrations.

Inputs: text (required), x, y, path, +8 more.

tree_diagramA

Draw a hierarchy as a tree — the branching counterpart to block_diagram (which is a linear chain). Give it an indented tree outline (each deeper indent is a child) and it renders a real node-link tree: parents centered above their children, joined by box-drawing connectors. Great for a taxonomy, an org chart, a dependency or model-lineage tree. layout: "down" is the centered tree; layout: "list" is the file-tree ( |-- / -- ) form. boxed` wraps each node in a box.

Inputs: tree (required), x, y, boxed, +4 more.

trimA

Auto-crop the blank margins around the drawing so the canvas hugs the content (like the gallery save does, but in place). Treats an ASCII space and the braille-blank as margin. pad keeps a border of that many blank cells. A fully blank canvas collapses to 1x1.

Inputs: pad.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 28 tools

    Disambiguation4/5

    Most tools target a distinct operation (placement, transforms, diagrams, image conversion) and descriptions clarify close pairs like image_to_ascii vs image_to_braille and trim vs crop vs resize_canvas. The main confusion zone is the illustrate / illustrate_scene / illustrate_prompt trio plus shape_text and banner_text, which are all variants of typographic/vector art generation with overlapping entry points.

    Naming Consistency4/5

    The set is uniformly snake_case and mostly verb_noun (set_char, draw_text, new_canvas, fill_gradient, save_to_gallery). Deviations are minor: noun-first compounds (shape_text, banner_text, block_diagram, tree_diagram, image_to_ascii) and bare verbs (trim, crop, frame, flip, scatter, render, erase), which stay readable but break the strict pattern.

    Tool Count3/5

    28 tools is on the heavy side for a drawing surface, and several groups look consolidatable (three illustrate* variants, three canvas-geometry ops in trim/crop/resize_canvas). The domain is genuinely broad (primitives, transforms, image tracing, diagrams, vector art), so most tools earn a place, but the surface feels wide.

    Completeness4/5

    Coverage is strong: canvas creation/clearing, single-cell and bulk placement, lines/rects/gradients/scatter, geometry transforms, framing, render, and gallery save, plus image and diagram pipelines. Minor gaps remain — no undo/history or direct cell read-back, and no explicit way to reload a previously saved canvas into the editor.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers