Skip to main content
Glama

text2d — 2D Retro Pixel Art Texture MCP Server

A high-performance Model Context Protocol (MCP) server that empowers AI assistants to procedurally generate, manipulate, and export 2D retro pixel art textures and tilesets for game development.


Features

  • Image to Retro Pixel Art Conversion: Ingest external PNG files and automatically downscale, quantize to retro palettes, and apply Bayer dithering via pixelize_image.

  • Procedural Texture Synthesis: Deterministic generation of wood, stone (cobblestone/rock), brick, grass, metal (brushed plates with rivets), and water caustics.

  • Pixel-Level Primitives: Full control via set_pixel, set_pixel_batch, draw_shape (lines, rects, circles), and flood_fill.

  • Retro Palettes & Quantization: Built-in authentic color palettes including PICO-8, DawnBringer 32 (DB32), Endesga 32, GameBoy, NES Classic, and Cyberpunk Neon.

  • Pixel-Art Post-Processing: Bayer ordered dithering (2x2, 4x4, 8x8) and 1px inner/outer pixel-perfect outlines.

  • Export Options: PNG files with nearest-neighbor integer scaling, Base64 Data URIs, ASCII Unicode block previews, and 2D JSON color grids.

Related MCP server: Aseprite MCP Tools

1. Image Pixelization (pixelize_image)

Convert high-resolution realistic photos or assets into authentic retro pixel art with automatic palette quantization and Bayer dithering.

Original Input

Endesga 32 (32x32)

PICO-8 (32x32)

GameBoy (32x32)

DawnBringer 32 (48x48)

Cyberpunk Neon (64x64)

2. Procedural Texture Synthesis (generate_texture)

Generate seamless, deterministic retro textures in seconds without external assets.

Wood (wood)

Stone (stone)

Brick (brick)

Grass (grass)

Metal (metal)

Water (water)


MCP Tools Matrix

Tool Name

Description

Key Parameters

pixelize_image

Ingests external PNG and converts to 2D retro pixel art

file_path, target_width, target_height, palette, sampling, dither, export_output_path

create_canvas

Initializes a new in-memory pixel canvas

width, height, palette, mode, backgroundColor

generate_texture

Synthesizes a procedural retro texture

canvas_id, texture_type, seed, palette, options

set_pixel

Sets a single pixel at (x, y)

canvas_id, x, y, color

set_pixel_batch

Batch updates multiple coordinates

canvas_id, pixels: [{x, y, color}]

draw_shape

Draws rasterized line, rect, or circle

canvas_id, shape, x1, y1, x2, y2, color, filled

flood_fill

Contiguous area flood fill

canvas_id, x, y, color

apply_dither

Applies Bayer ordered dithering

canvas_id, matrix_size, spread

apply_outline

Draws 1px pixel-perfect outline

canvas_id, color, mode

export_texture

Exports canvas to PNG, Data URI, ASCII or JSON

canvas_id, format, file_path, scale

list_palettes

Lists all built-in retro palettes

None

list_canvases

Lists active canvases in memory

None

get_canvas_info

Inspects canvas metadata and dimensions

canvas_id

delete_canvas

Frees canvas from memory

canvas_id


Installation & Usage

You can install and run text2d directly from GitHub without publishing to npm:

Install globally directly from the GitHub repository:

npm install -g github:al3duc/text2d-mcp

Once installed, the text2d command is available system-wide.


MCP Client Configuration

Add text2d to your MCP client configuration (e.g. claude_desktop_config.json, mcp_config.json, or Cursor):

Option A: Using Global Installation (Simplest)

{
  "mcpServers": {
    "text2d": {
      "command": "text2d"
    }
  }
}

Option B: Direct Execution via npx (No permanent install)

{
  "mcpServers": {
    "text2d": {
      "command": "npx",
      "args": [
        "-y",
        "github:al3duc/text2d-mcp"
      ]
    }
  }
}

Option C: Claude Code CLI Command

If using Claude Code, register it with a single terminal command:

claude mcp add text2d -- npx -y github:al3duc/text2d-mcp

Option D: Local Clone (Development)

git clone https://github.com/al3duc/text2d-mcp.git
cd text2d-mcp
npm install
npm run build
{
  "mcpServers": {
    "text2d": {
      "command": "node",
      "args": [
        "<PATH_TO_TEXT2D_REPOSITORY>/dist/index.js"
      ]
    }
  }
}

Note: Replace <PATH_TO_TEXT2D_REPOSITORY> with the absolute path to your cloned repository.


Build & Test

# Install dependencies
npm install

# Run unit & integration tests
npm test

# Build TypeScript to dist/
npm run build

# Generate procedural texture samples (wood, stone, brick, grass, metal, water)
npx tsx examples/generate_samples.ts

# Test converting realistic images from examples/input/ to pixel art
npx tsx examples/test_car_pixelize.ts

License

This project is licensed under the MIT License - see the LICENSE file for details.

Available Tools

14 tools
apply_ditherB

Applies ordered Bayer matrix dithering across the canvas.

Inputs: canvas_id (required), spread, matrix_size.

apply_outlineB

Generates a 1px pixel-perfect outline around shapes on the canvas.

Inputs: color (required), canvas_id (required), mode.

create_canvasA

Initializes a new in-memory pixel canvas with specified dimensions and palette.

Inputs: width (required), height (required), id, mode, +2 more.

delete_canvasA

Deletes a canvas from memory.

Inputs: canvas_id (required).

draw_shapeB

Draws a pixel-art rasterized geometric primitive (line, rect, circle).

Inputs: x1 (required), y1 (required), color (required), shape (required), +4 more.

export_textureB

Exports the pixel canvas to a PNG file, Base64 Data URI, ASCII preview grid, or JSON grid.

Inputs: format (required), canvas_id (required), scale, file_path.

flood_fillA

Fills a contiguous area of matching color starting at (x, y).

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

generate_textureB

Procedurally synthesizes a 2D retro pixel art texture (wood, stone, brick, grass, metal, water) using deterministic algorithms.

Inputs: canvas_id (required), texture_type (required), seed, options, +1 more.

get_canvas_infoA

Returns metadata, dimensions, and palette information for a specific canvas.

Inputs: canvas_id (required).

list_canvasesA

Lists all active canvases and their metadata in the current session.

Inputs: no named parameters.

list_palettesA

Lists all available built-in retro palettes (PICO-8, DB32, Endesga32, GameBoy, NES, Cyberpunk).

Inputs: no named parameters.

pixelize_imageA

Imports an external image file (PNG) and converts it to authentic 2D retro pixel art with downsampling, palette quantization, and dithering.

Inputs: file_path (required), scale, dither, palette, +6 more.

set_pixelA

Sets a single pixel at (x, y) with a hex color or palette index.

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

set_pixel_batchC

Efficiently sets multiple pixels at specified coordinates.

Inputs: pixels (required), canvas_id (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 14 tools

    Disambiguation5/5

    Each tool targets a distinct operation on the canvas or palette: lifecycle, drawing primitives, pixel manipulation, filters, and export. There is little to no overlap between tool purposes, making selection unambiguous.

    Naming Consistency5/5

    Tool names consistently follow a verb_noun (or verb_noun_batch) pattern with lowercase underscores. The parallel create/list/get/delete and set/apply/export groupings make the API predictable and easy to navigate.

    Tool Count5/5

    14 tools is within the ideal scope for a specialized pixel-art canvas server. Each tool covers a distinct editing, transformation, or I/O operation, so none feel redundant and the surface remains manageable.

    Completeness4/5

    The server covers a solid canvas lifecycle including creation, metadata access, deletion, multiple pixel-editing operations, filters, texture generation, and export. The main minor gap is the lack of a direct tool for reading individual pixel values, though export_texture can partially compensate by outputting a JSON grid.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to drive Aseprite for pixel-art creation, including sprite setup, grid-based drawing, layer/frame/tag management, reference image import, and export, with rendered previews after every mutation.
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables AI to directly control Pixelorama for real-time 2D game asset creation, including layer-based pixel drawing, animation frames, automatic quality checks, and export of spritesheets, .pxo files, and Godot resources.
      -