Skip to main content
Glama
Commodore 64 Ultimate Computer MCP Server

Commodore 64 Ultimate Computer MCP Server

by xphileby

Commodore 64 Ultimate MCP Server

Control your Commodore 64 Ultimate device with AI. This MCP server lets Claude and other AI assistants interact with your C64 Ultimate hardware over your local network.

What Can You Do?

Create and Debug Programs - Claude can write C64 BASIC or machine code programs, run them, capture the screen to see the results, inspect memory, and iteratively fix issues. Describe what you want and watch Claude develop it on real hardware.

Write and Run BASIC Programs - Ask Claude to write a BASIC program and it will tokenize the code, inject it directly into C64 memory, and run it. No typing required.

Play Classic Games and Demos - Load and run .PRG programs or .CRT cartridge images from your device's storage or upload them directly.

Listen to SID Music - Play classic C64 SID tunes or Amiga MOD tracker files. Just point to a file on your device or upload one.

See What's on Screen - Capture screenshots from any graphics mode: text, multicolor, hires bitmap, and more. Claude can see what's happening and respond accordingly.

Type and Control - Send keystrokes, navigate menus, and interact with running programs through the keyboard buffer.

Manage Floppy Drives - Mount and unmount D64/D71/D81 disk images, switch between 1541/1571/1581 emulation modes, and create new disk images.

Read and Write Memory - Inspect and modify C64 memory directly via DMA. Useful for debugging, poking values, or examining program state.

Configure Your Device - Adjust device settings, save configurations to flash, and manage your C64 Ultimate setup.

Related MCP server: C64 Debug MCP

How It Works

This server implements the Model Context Protocol (MCP) to expose the C64 Ultimate REST API as tools that AI assistants can use. When connected to Claude Desktop or another MCP client, you can have natural conversations about your C64 and Claude will use these tools to carry out your requests.

Prerequisites

Enable Web Remote Control Service from the C64 Ultimate menu:

  • Navigate to: Network Settings → Web Remote Control Service → Enabled

Installation

cd c64u-mcp-server
uv sync

Configuration

Set the C64U_URL environment variable to your device's IP address:

export C64U_URL="http://192.168.200.157"

Default: http://192.168.200.157

Running the Server

uv run python server.py

Claude Desktop Configuration

Add to your Claude Desktop claude_desktop_config.json:

{
  "mcpServers": {
    "commodore64": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/c64u-mcp-server", "python", "server.py"],
      "env": {
        "C64U_URL": "http://192.168.200.157"
      }
    }
  }
}

Available Tools

Machine Control

  • machine_reset - Reset the C64

  • machine_reboot - Reboot Ultimate device

  • machine_pause - Pause CPU via DMA

  • machine_resume - Resume from pause

  • machine_poweroff - Power off (U64 only)

  • capture_screen - Capture C64 screen as PNG image

  • type_text - Type text into keyboard buffer (supports special keys)

  • send_key - Send a special key to keyboard buffer

  • enter_basic_program - Enter BASIC program directly into memory (tokenized)

Memory Access

  • write_memory - Write hex data to C64 memory

  • write_memory_binary - Write binary data to memory (base64)

  • read_memory - Read C64 memory

  • read_debug_register - Read debug register (U64)

  • write_debug_register - Write debug register (U64)

Runners (SID/MOD/PRG/CRT)

  • sidplay_file - Play SID file from device filesystem

  • sidplay_upload - Upload and play SID file (base64)

  • modplay_file - Play MOD file from device filesystem

  • modplay_upload - Upload and play MOD file (base64)

  • load_prg_file - Load PRG without executing

  • load_prg_upload - Upload and load PRG (base64)

  • run_prg_file - Load and run PRG from filesystem

  • run_prg_upload - Upload and run PRG (base64)

  • run_crt_file - Start cartridge from filesystem

  • run_crt_upload - Upload and start cartridge (base64)

Floppy Drives

  • list_drives - List all drives and mounted images

  • mount_disk_file - Mount disk from filesystem

  • mount_disk_upload - Upload and mount disk (base64)

  • drive_reset - Reset drive

  • drive_remove - Unmount disk

  • drive_on - Enable drive

  • drive_off - Disable drive

  • drive_load_rom_file - Load custom ROM

  • drive_load_rom_upload - Upload custom ROM (base64)

  • drive_set_mode - Change drive type (1541/1571/1581)

Configuration

  • list_config_categories - List all config categories

  • get_config_category - Get items in a category

  • get_config_item - Get specific config item

  • set_config_item - Set config item value

  • batch_set_config - Set multiple config items

  • load_config_from_flash - Restore config from flash

  • save_config_to_flash - Save config to flash

  • reset_config_to_default - Reset to factory defaults

Streams (U64 only)

  • stream_start - Start video/audio/debug stream

  • stream_stop - Stop active stream

File Operations

  • get_file_info - Get file metadata

  • get_version - Get REST API version

  • create_d64 - Create D64 disk image

  • create_d71 - Create D71 disk image

  • create_d81 - Create D81 disk image

  • create_dnp - Create DNP disk image

API Reference

Based on: https://1541u-documentation.readthedocs.io/en/latest/api/api_calls.html

Available Tools

49 tools
batch_set_configC

Set multiple configuration items at once

Inputs: settings (required).

capture_screenA

Capture the C64 screen as a PNG image. Auto-detects the active graphics mode and renders accordingly. Supported modes: Standard Text (40x25), Multicolor Text, Extended Background Color (ECM), Standard Bitmap (Hires 320x200), and Multicolor Bitmap (160x200). Returns base64 encoded PNG data with mode info.

Inputs: scale, include_border.

create_d64B

Create a new D64 disk image

Inputs: path (required), tracks, diskname.

create_d71C

Create a new D71 disk image

Inputs: path (required), diskname.

create_d81C

Create a new D81 disk image

Inputs: path (required), diskname.

create_dnpC

Create a new DNP disk image

Inputs: path (required), tracks (required), diskname.

drive_load_rom_fileC

Load custom ROM for drive from filesystem

Inputs: drive (required), file (required).

drive_load_rom_uploadC

Upload and load custom ROM for drive (base64 encoded)

Inputs: drive (required), data (required).

drive_offC

Disable a drive

Inputs: drive (required).

drive_onC

Enable a drive

Inputs: drive (required).

drive_removeC

Unmount disk image from drive

Inputs: drive (required).

drive_resetC

Reset a specific drive

Inputs: drive (required).

drive_set_modeB

Change drive type (1541/1571/1581)

Inputs: drive (required), mode (required).

get_config_categoryC

Get all configuration items in a category

Inputs: category (required).

get_config_itemC

Get a specific configuration item's details

Inputs: category (required), item (required).

get_file_infoC

Get metadata about a file on the device

Inputs: path (required).

get_versionA

Get the REST API version number from the Commodore 64 Ultimate Computer device

Inputs: no named parameters.

list_config_categoriesB

List all configuration categories

Inputs: no named parameters.

list_drivesB

Get information about all floppy drives and mounted images

Inputs: no named parameters.

load_config_from_flashB

Restore configuration from non-volatile memory

Inputs: no named parameters.

load_prg_fileC

Load a program file from filesystem without executing

Inputs: file (required).

load_prg_uploadB

Upload and load a program file without executing (base64 encoded)

Inputs: data (required).

machine_pauseB

Halt the C64 CPU via DMA line

Inputs: no named parameters.

machine_poweroffB

Power down the machine (U64 only)

Inputs: no named parameters.

machine_rebootB

Restart and reinitialize the Ultimate device

Inputs: no named parameters.

machine_resetB

Send reset signal to the C64

Inputs: no named parameters.

machine_resumeB

Resume C64 from paused state

Inputs: no named parameters.

modplay_fileC

Play an Amiga MOD file from the device filesystem

Inputs: file (required).

modplay_uploadC

Upload and play an Amiga MOD file (base64 encoded)

Inputs: data (required).

mount_disk_fileC

Mount a disk image from filesystem

Inputs: drive (required), image (required), type, mode.

mount_disk_uploadC

Upload and mount a disk image (base64 encoded)

Inputs: drive (required), data (required), type, mode.

read_debug_registerB

Read debug register (U64 only)

Inputs: no named parameters.

read_memoryC

Read data from C64 memory

Inputs: address (required), length.

reset_config_to_defaultB

Reset configuration to factory defaults

Inputs: no named parameters.

run_crt_fileC

Start a cartridge file from filesystem

Inputs: file (required).

run_crt_uploadC

Upload and start a cartridge file (base64 encoded)

Inputs: data (required).

run_prg_fileC

Load and execute a program file from filesystem

Inputs: file (required).

run_prg_uploadC

Upload, load and execute a program file (base64 encoded)

Inputs: data (required).

save_config_to_flashB

Save current configuration to non-volatile memory

Inputs: no named parameters.

send_keyA

Send a special key to the C64 keyboard buffer. For control keys that can't be easily typed as text.

Inputs: key (required).

set_config_itemC

Set a specific configuration item's value

Inputs: category (required), item (required), value (required).

sidplay_fileC

Play a SID file from the device filesystem

Inputs: file (required), songnr.

sidplay_uploadC

Upload and play a SID file (base64 encoded)

Inputs: data (required), songnr.

stream_startC

Start a video/audio/debug stream (U64 only)

Inputs: stream (required), ip (required).

stream_stopC

Stop an active stream (U64 only)

Inputs: stream (required).

type_textA

Type text into the C64 keyboard buffer. Converts ASCII to PETSCII and writes to the keyboard buffer at $0277. The C64 will process these keystrokes. Automatically handles text longer than 10 chars by chunking. Use {RETURN} for newline, {CLR} to clear screen, {HOME} for home, {UP}/{DOWN}/{LEFT}/{RIGHT} for cursor, {F1}-{F8} for function keys, {DEL}/{INS} for delete/insert.

Inputs: text (required), wait_ms.

write_debug_registerC

Write debug register (U64 only)

Inputs: value (required).

write_memoryC

Write data to C64 memory via DMA

Inputs: address (required), data (required).

write_memory_binaryC

Write binary data to C64 memory via DMA (base64 encoded)

Inputs: address (required), data (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 49 tools

    Disambiguation3/5

    Most tools have distinct purposes, but there is notable overlap in file handling (e.g., load_prg_file vs. run_prg_file) and disk image creation (create_d64, create_d71, etc.), which could cause confusion. The descriptions help clarify, but the high tool count increases ambiguity.

    Naming Consistency4/5

    Tool names follow a consistent snake_case pattern with clear verb_noun structures (e.g., capture_screen, list_drives). Minor deviations exist, such as modplay_file vs. sidplay_file (inconsistent prefix usage), but overall naming is predictable and readable.

    Tool Count2/5

    With 49 tools, the count is excessive for a single server, making it feel heavy and overwhelming. While the domain (Commodore 64 emulation/control) is broad, many tools could be consolidated (e.g., multiple create_d* for disk images) to improve usability.

    Completeness5/5

    The tool set provides comprehensive coverage for the domain, including configuration management, disk operations, file loading/execution, machine control, and debugging. There are no obvious gaps; it supports full CRUD/lifecycle operations for emulating and controlling a Commodore 64 system.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to control Commodore 64 Ultimate hardware via REST API, supporting program execution, memory operations, disk management, audio playback, and device configuration through natural language commands.
      22
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI-powered control and debugging of Commodore 64 programs via the VICE emulator, supporting memory operations, breakpoints, register access, and program loading.
      18
      8 npm
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables controlling and interacting with a Commodore 64 emulator running in the browser via MCP.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Lets AI clients control and program a Commodore 64, including running programs, reading/writing memory, rendering graphics, playing sound, and switching between C64 Ultimate hardware and VICE emulation.
      593 npm
      43
      GPL 2.0