M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
C

C64 Bridge MCP Server

Community
MCP server to control and program the Commodore 64 from AI clients
How to install ↓ Compare GitHub source repository ↗
Category
Dev Tools #147 of 438
Stars
★ 39 Popular
Transport
stdio (local process)
Runtime
Node.js 24+
Credentials
No credential needed
License
GPL-2.0
Last commit
Tools
17
58FMRS · C

C64 Bridge is a comprehensive, well-documented community open-source MCP server (GPL-2.0, npm package c64bridge, v1.0.2) that connects AI clients to C64 Ultimate / Ultimate 64, U2-family cartridges, and VICE through 17 grouped tools covering programming, memory, graphics, audio, storage, printing, and knowledge retrieval. It is not an official Commodore product but is listed in the Official MCP Registry and ships extensive LLM-facing safety and knowledge resources, making it a strong fit for serious C64 retro developers; it is unsuitable without matching hardware or an emulator.

Strongest · Documentation 17/20 Weakest · Reliability 7/20

Reliability
7/20
Security and permissions
10/20
Maintenance
11/20
Documentation
17/20
Setup experience
13/20
Why each score
Reliability 7/20
The README documents a stdio startup flow with connectivity probing and a detailed table of behaviors for all 17 tools, which is specific and checkable. However, this static review had no access to actual repository files (test suites, CI workflow definitions) — only README-cited build/test scripts and CI/Codecov badges, which count as unverified self-reported evidence. There is no way to confirm that key paths (e.g., dual C64U/VICE backend switching, firmware-version-gated endpoint fallbacks) are actually covered by committed tests. Per the static calibration rule, reliability cannot exceed 12 without verifiable execution evidence; given the significant evidence gap, 7 is assigned.
Security and permissions 10/20
Secret handling looks reasonably careful — C64U_PASSWORD and GITHUB_TOKEN are both marked isSecret, and the config file lookup/merge order is clearly documented. However, several high-impact operations are directly callable with no confirmation gate: c64_system's poweroff/reboot/power_cycle, c64_config's reset_defaults/save_flash, and c64_debug's nuclear_reset all lack any confirm-style parameter, relying entirely on the client to gate them. In VICE mode, operations like run_prg read host-local file paths, crossing into host filesystem territory. The optional RAG feature can use GITHUB_TOKEN against GitHub with an undocumented scope. None of this rises to red-line malware/exfiltration territory, but least-privilege scoping and confirmation for destructive actions are clearly incomplete, warranting 10.
Maintenance 11/20
The repo is GPL-2.0 licensed, not archived, published to npm at version 1.0.2, and claims CI plus Codecov integration, indicating some engineering process is in place. But with only 33 stars and 1 open issue, and no verifiable commit history, release cadence, or issue-response data available in this review, long-term sustainability and governance rigor cannot be established, so a middling 11 is given.
Documentation 17/20
Documentation quality is strong: the README is organized into config file order/merge rules, a per-backend (C64U/U2/VICE) capability comparison, an environment variable reference table with defaults and JSON config key mappings, explicit firmware-version dependency notes, and an auto-generated full inventory of tools/resources/prompts with per-operation required/optional inputs and a platform support matrix. Concrete client setup examples (VS Code, Claude Code, Cursor) are also included. Points are deducted for lacking a consolidated 'known limitations/troubleshooting' section — firmware-dependency caveats (e.g., machine:input) are scattered through the body rather than centralized — so 17 rather than full marks.
Setup experience 13/20
The README supplies Node 24+ install steps across platforms, three startup paths (npx / local npm install / source build), one-click install badges with JSON configs for multiple mainstream clients, and detailed backend-selection/override rules — the overall path looks clear. However, this static review found no verifiable execution logs or integration tests proving these install paths actually work, and per the static calibration rule setup cannot exceed 15 without such evidence. The setup also depends on external factors like firmware versions and VICE binary auto-detection, adding real-world fragility, so 13 is assigned.

Static review · not runListed 2026-09-07

Read the FMRS scoring method →

Fit and risk

What it can accessWrites / deletes local filesRuns commands or codeUses the network

Best for

  • Retrocomputing enthusiasts who own Ultimate-family hardware or run VICE and want AI-assisted C64 development
  • Developers working with BASIC / 6502 assembly, SID music, or PETSCII graphics
  • Teams automating C64 program testing across real hardware and emulators with an AI agent

Not for

  • Users without any C64 hardware or the VICE emulator (no backend is available)
  • Beginners seeking a fully hosted cloud service with no local setup
  • Retro platforms other than the Commodore 64 (this server is C64-specific)

Required permissions

  • Network access to C64 Ultimate / Ultimate 64 / U2 cartridges via REST (default port 80), with an optional network password sent as an X-Password header
  • Ability to launch and manage a local VICE emulator process and its Binary Monitor (default 127.0.0.1:6502)
  • Local file access for config files, memory/screen dumps, diagnostics, and output artifacts
  • Optional: GITHUB_TOKEN for RAG discovery against GitHub; optional use of sidplayfp for audio generation

Risks and side effects

  • The server can write memory, control power/reset, and manage drives; misuse may disrupt running C64 programs or firmware state
  • Network passwords and GitHub tokens are passed in plaintext via environment variables, so credential handling matters
  • The optional HTTP bridge is disabled by default; if enabled without protection, local clients could invoke tools
  • U2-family cartridges have reduced capability (no machine input, debug registers, power-off, or streaming), and some operations require recent firmware (e.g., U64 3.15+), so older firmware makes certain tools unavailable

Setup

Before you start

Runtime：Node.js 24+

C64U_PASSWORD optionalsecret Ultimate 64 network password (only if enabled in the device's network settings), sent as X-Password.
U2_PASSWORD optionalsecret U2-family network password sent as X-Password; used only when C64_MODE=u2.
GITHUB_TOKEN optionalsecret GitHub personal access token used only for optional RAG discovery against GitHub; create one under GitHub Settings > Developer settings.
Other optional settings (13)
C64_MODE optional Selects the initial backend (c64u, u2, or vice); defaults to c64u.
C64BRIDGE_CONFIG optional Path to the C64 Bridge configuration JSON file, defaults to ~/.c64bridge..
LOG_LEVEL optional Logger verbosity: debug, info, warn, or error.
C64U_HOST optional Ultimate 64 host name or IP address, defaults to c64u.
C64U_PORT optional Ultimate 64 REST port, defaults to 80.
U2_HOST optional Host name or IP of a U2/U2+/U2+L cartridge; used only when C64_MODE=u2.
U2_PORT optional U2-family REST port; used only when C64_MODE=u2.
VICE_BINARY optional VICE emulator binary to launch, defaults to x64sc.
VICE_DIRECTORY optional VICE resource directory (ROMs/UI assets), overriding auto-detection when needed.
VICE_VISIBLE optional Set true to launch a visible desktop window; false uses headless Xvfb.
VICE_WARP optional Enables VICE warp mode (faster execution).
VICE_ARGS optional Extra command-line arguments forwarded to managed VICE launches, e.g. -minimized.
VICE_PREWARM optional Set to 1 to start/connect VICE in the background during MCP startup; otherwise VICE starts lazily on first use.

Requires Node.js 24+ and npm. Start with npx -y c64bridge@latest. In your MCP client config (e.g., .vscode/mcp.), add a server entry with command npx and args ["-y","c64bridge@latest"], optionally setting env vars such as C64_MODE (c64u/u2/vice), C64U_HOST, C64U_PORT, C64U_PASSWORD, VICE_BINARY, VICE_VISIBLE, and VICE_WARP. Backend configuration can also be provided via the JSON file pointed to by C64BRIDGE_CONFIG (default ~/.c64bridge.).

.mcp.json 
{"servers":{"c64bridge":{"command":"npx","args":["-y","c64bridge@latest"]}}}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "c64bridge": {
      "command": "npx",
      "args": [
        "-y",
        "c64bridge@latest"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add c64bridge -- npx -y c64bridge@latest

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

In your MCP client, confirm tools like c64_program, c64_memory, and c64_select_backend appear in the tool list, then ask the client to run a BASIC program printing HELLO on the vice backend and read the screen to verify the output.

Troubleshooting

  1. Confirm Node.js 24+ is installed and on PATH (node --version should show v24.x)
  2. Verify C64_MODE matches the intended backend and that host/IP, port, and password are correct (use c64://platform/status to inspect the active backend)
  3. Check whether the C64U firmware provides machine:input / machine:menu_screen endpoints (or U64/U2 firmware 3.15+); otherwise native keyboard input and menu screen reads are unavailable
  4. If VICE fails to start, verify VICE_BINARY and VICE_DIRECTORY, or ensure x64sc/x64 is on PATH
  5. If tools do not appear, confirm the server was approved at the requested scope in your client and that LOG_LEVEL=debug logs show connectivity checks passing

Things to try

Once connected, you can ask your AI assistant things like:

  • c64u: write a small BASIC program that clears the screen and prints HELLO C64U and run it
  • vice: write a small BASIC program that clears the screen and prints HELLO VICE
  • u2: list the currently mounted disk drives
  • Read the current screen contents and tell me what it displays

Tools 17

c64_batch writes
Execute multiple c64bridge tool calls in a single request to reduce latency for multi-step workflows.
c64_config writes
Grouped entry point for configuration reads/writes, diagnostics, snapshots, firmware info, debug registers, and program shuffling.
c64_debug read-only
Grouped entry point for VICE debugger operations: checkpoints (breakpoints), register reads/writes, stepping, and wait-for-state polling.
c64_disk writes
Grouped entry point for disk mounts, image creation, file metadata, and find-and-run for PRG/CRT programs.
c64_drive writes
Grouped entry point for drive power, emulation mode (1541/1571/1581), IEC reset, and temporary ROM loading.
c64_extract read-only
Grouped entry point for sprite/charset extraction, memory dumps, filesystem stats, and firmware health checks.
c64_graphics writes
Grouped entry point for frame capture, PETSCII art and text rendering, bitmap import, and sprite display.
c64_input writes
Grouped entry point for cross-platform PETSCII typing plus native Ultimate keyboard matrix and joystick events.
Show 9 more tools
c64_memory read-only
Grouped entry point for memory I/O, fill, search, copy, compare, disassembly, screen reads, and screen polling.
c64_printer writes
Grouped entry point for Commodore and Epson (ESC/P) printing helpers, including text and bitmap printing.
c64_program writes
Grouped entry point for program upload and execution: BASIC v2, 6502/6510 assembly, PRG, CRT, and batch runs.
c64_rag read-only
Grouped entry point for BASIC and 6502/6510 assembly reference lookups in the local knowledge base.
c64_select_backend writes
Switch the active backend between C64U/U64 hardware, U2-family cartridges, and VICE without restarting the server.
c64_sound writes
Grouped entry point for SID control, playback, composition (SIDWAVE/CPG), preset performances, recording, and analysis.
c64_stream writes
Grouped entry point for starting and stopping Ultimate streaming sessions (C64U/U64 only).
c64_system writes
Grouped entry point for power, reset, pause/resume, menu screen reads, and background task management.
c64_vice writes
Grouped entry point for reading and updating selected VICE configuration resources (safe prefixes only).

Use cases

Have an AI client write and run C64 BASIC or 6510 assembly programs and verify screen output
Render PETSCII art and sprites, or import and display bitmaps
SID music playback, composition (SIDWAVE), and audio analysis
Memory inspection, disassembly, disk image management, and firmware configuration
Seamlessly switch between real hardware and VICE emulation with c64_select_backend

Supported clients

GitHub Copilot
Claude Code
Cursor
Visual Studio
VS Code Insiders

Listed from the project's documentation, not tested by this site.

Overview

C64 Bridge is an MCP server built on the official TypeScript @modelcontextprotocol/sdk that gives an AI agent one place to drive a Commodore 64 environment. It targets C64 Ultimate, Ultimate 64, U2-family cartridges (U2/U2+/U2+L), and the VICE emulator, with runtime backend switching via c64_select_backend. It exposes 17 grouped tools, 27 resources (covering BASIC, 6510 assembly, SID, VIC-II, memory maps, KERNAL, printers, and more), and 10 prompts for running BASIC and assembly programs, reading and writing memory, rendering PETSCII graphics and sprites, playing and composing SID music, managing disks and drives, controlling printers, and optional RAG knowledge retrieval. The server communicates over stdio, with an optional HTTP bridge intended only for manual inspection.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →
Compare with other MCP servers

Source revision 06889481feb3 Data synced 2026-10-19 Read the FMRS scoring method