Skip to main content
Glama

gc-mcp

An MCP (Model Context Protocol) server that drives multiple, stock, unmodified Dolphin emulator instances as if each were a real Nintendo GameCube. It launches ROM/DOL/ELF instances with custom per-instance configuration (Broadband Adapter and other peripherals), captures rendered output inside a Docker container, and manipulates all four GameCube controller ports.

The tool surface is designed around a unified gc_ interface that works on both the emulator and real GameCube hardware. Anything that can only ever apply to the emulator (e.g. changing Dolphin's own configuration) is exposed under a gc_dolphin_ prefix.

Why

The model that drives an agent is often too slow to hold a button press/release pair together, so controller tools support momentary actions and timed input sequences. Memory read/write is provided so the agent can inspect or patch game state.

Related MCP server: mcp-dolphin

Concepts

  • Platform — an abstraction over a target: dolphin (an emulator instance) or gamecube-hw (a real console). Hardware instances are permanently remembered in <data>/hardware.json until explicitly removed.

  • Instance — one running Dolphin process, isolated by its own --user data directory, with its own controllers, capture backend and memory backend; or a registered real GameCube hardware instance.

  • Controller port — one of the four GameCube controller ports (0–3).

  • Capture backend — how rendered frames are grabbed:

    • xvfb (default): Dolphin runs under a virtual X server (Xvfb) using OpenGL; the display is sized to the GameCube native resolution so the capture has no black borders. Frames are captured with ffmpeg/xwd into PNG. Rendering happens on a real GPU (via VirtualGL vglrun) when available, else Mesa llvmpipe.

    • framedump: Dolphin's built-in frame dump (Movie.DumpFrames) to PNG, as a fallback that needs no display server.

    • v4l2: grab a frame from a Video4Linux2 capture device (e.g. a capture card) for a real GameCube. Uses OpenCV (cv2) when installed, else ffmpeg -f v4l2. A USB capture card only delivers real content after it has been fed a continuous stream for a few seconds, so the backend warms up a cold device (streaming it for warmup_seconds) before grabbing a frame.

GPU rendering

By default gpu_accel=auto: if VirtualGL (vglrun) is installed and a GPU DRM device is present under /dev/dri, Dolphin is launched under vglrun -d <device> so OpenGL renders on the real GPU instead of Mesa software llvmpipe. The rendered frame is blitted onto the Xvfb display, so captures still come from ffmpeg/xwd. Without vglrun, it falls back to software rendering.

The Xvfb screen is sized to the GameCube native resolution (640x480 default) scaled by the instance's internal_resolution, so the render window fills the screen and the capture has no black borders. crop (W:H:X:Y) is available as an optional escape hatch via gc_capture_configure, but sizing is preferred.

Controller interface

Dolphin ships a stock "Pipes" input backend. The server creates named FIFOs in the instance's Pipes/ directory, maps each GameCube port to a device (Pipe/0/ctrlN), and writes newline-delimited commands:

PRESS A
RELEASE A
SET MAIN 0.5 0.5
SET C 1.0 0.0
SET L 0.75

Memory interface

Memory read/write is implemented per-PID with process_vm_readv/process_vm_writev after locating the instance's emulated RAM (/dev/shm/dolphinmem*) in /proc/<pid>/maps. This sidesteps py-dolphin-memory-engine's limitation of attaching to only the first matching process, so multiple instances each get their own memory backend. dolphin-memory-engine is supported as an optional backend.

Memory operations fail gracefully: if the emulator has not yet allocated RAM or is not running a game, gc_memory_read/gc_memory_write return an is_error result with a clear message rather than crashing the server.

Real GameCube hardware

A real console is connected through a capture card / USB capture device exposed as a Video4Linux2 node (e.g. /dev/video0), and up to four serial devices that will act as the controller ports. Register it once; it is remembered permanently (persisted to <data>/hardware.json) until removed:

gc_hardware_devices            # probe /dev/video* and report capture capability
gc_hardware_register("hw-001", capture_device="/dev/video0")
gc_capture_screenshot("hw-001")   # grab a frame -> PNG
gc_hardware_update("hw-001", serial_devices=["/dev/ttyUSB0", ...])
gc_hardware_status("hw-001")
gc_hardware_remove("hw-001")

Every hardware instance carries a free-form info annotation (default "") that you can set with gc_hardware_register(..., info=...) or gc_hardware_update("hw-001", info=...). It is persisted and shown in gc_hardware_list, gc_hardware_status, and gc_platform_list — handy for labelling a console ("living-room rig", "capture is the UGREEN card"). Dolphin instances take info at launch via gc_instance_start(..., info=...).

gc_hardware_devices probes each node with v4l2-ctl and reports its card name, the pixel formats it exposes, and whether it can actually capture video frames (can_capture). Some nodes expose only UVC metadata (a capture card's second interface) and cannot produce a video stream — prefer a device with can_capture: true.

Only screen capture and ROM loading are implemented for hardware so far; controller and memory operations raise "not implemented". Capture uses the v4l2 backend, which prefers OpenCV (cv2, the same library as cap_example.py) for low-latency capture and falls back to ffmpeg -f v4l2.

Some capture cards (e.g. the UGREEN USB one) return a placeholder/black frame until they have been streamed continuously for a few seconds. To handle this the backend warms up a cold device: on the first capture it streams for warmup_seconds (default 5) and writes the final frame, then remembers the device as warm so subsequent captures are fast. A device is re-warmed if it has not been captured for warmup_ttl seconds (default 60). Tune per instance with gc_capture_configure("hw-001", warmup_seconds=5, warmup_ttl=60).

ROM loading (Swiss netboot)

A real console boots a ROM through Swiss's netboot listener: a custom Swiss build listens on TCP 4242 of the console's own BBA IP, and a one-line BOOT <path> command starts a game from the console's own media. The path is a console-side path starting with sdc:/ (SD2SP2) or fsp:/ (the configured FSP file server):

gc_hardware_update("hw-001", bba_ip="192.0.2.10")   # remember the console's IP
gc_rom_load("hw-001", "sdc:/games/Foo.iso")           # boot the game

gc_rom_load is the unified entry point across targets:

  • Real hardware — sends BOOT to the netboot listener. Set bba_ip with gc_hardware_register(..., bba_ip=...) or gc_hardware_update(...); it is persisted on the hardware instance. If the console is currently inside a game the listener is down, so gc_rom_load first tries to return to Swiss with the A+Z+START combo — which needs hardware button pressing and is not implemented yet (it raises "not implemented" until then).

  • Dolphin instance — stops the current process and relaunches it booting a host-side ROM/DOL/ELF path, keeping the instance id and config.

The netboot protocol is one command per TCP connection (PING→PONG, STATUS→READY/BUSY, BOOT <path>→OK/ERR <reason>).

Running

Requires mcp v2.x (the server uses MCPServer; FastMCP was removed in mcp 2.x). The project pins mcp>=1.2.0 but uv sync resolves to 2.x; if you need the v1 API, pin mcp<2.

uv sync
uv run gc-mcp        # stdio transport (what an MCP client / opencode uses)

Point your MCP client at uv run gc-mcp as a stdio server.

Configuration

Environment variables (all optional):

Variable

Default

Meaning

GC_MCP_DOLPHIN_BINARY

dolphin-emu

Dolphin executable

GC_MCP_DATA_DIR

~/.gc-mcp

Root for per-instance data & captures

GC_MCP_VIDEO_BACKEND

OGL

OGL/Vulkan/Software Renderer

GC_MCP_BBA_MODE

ipc

BBA mode (ipc, hle, xlink, tap, tapserver, or empty/none)

GC_MCP_BBA_MAC_PREFIX

00:09:bf

Must be 00:09:bf or 00:17:ab

GC_MCP_CAPTURE_BACKEND

auto

auto, xvfb, framedump

GC_MCP_NATIVE_RES

640x480

GameCube native framebuffer WxH (display/capture sizing)

GC_MCP_GPU_ACCEL

auto

auto, none, software, vgl, vgl-egl, vgl-glx

GC_MCP_GPU_DEVICE

auto-detected

GPU DRM device path (e.g. /dev/dri/card2)

GC_MCP_VGL_3D_DISPLAY

empty

3D X server display for VirtualGL's GLX back end (e.g. :0.0)

GC_MCP_MEMORY_BACKEND

process_vm

process_vm or dolphin_engine

GC_MCP_HW_CAPTURE_DEVICE

/dev/video0

Default capture device for real hardware instances

GC_MCP_HW_CAPTURE_WIDTH

640

Default hardware capture width

GC_MCP_HW_CAPTURE_HEIGHT

480

Default hardware capture height

GC_MCP_HW_CAPTURE_FORMAT

mjpg

Default hardware capture pixel format (mjpg, yuyv, ...)

GC_MCP_HW_CAPTURE_FPS

30

Default hardware capture frame rate

GC_MCP_HW_CAPTURE_FLUSH

5

Stale buffers flushed before reading a fresh frame (OpenCV path)

GC_MCP_HW_CAPTURE_WARMUP

5

Seconds to stream a cold device before grabbing a frame (0 disables)

GC_MCP_HW_CAPTURE_WARMUP_TTL

60

Seconds a warmed device is trusted before it is warmed again

GC_MCP_HW_BBA_IP

empty

Default BBA IP for a new hardware instance (the console's own IP, used to reach the Swiss netboot listener)

GC_MCP_HW_BBA_PORT

4242

Default Swiss netboot listener port

Docker

A Dockerfile is provided that installs Dolphin, Xvfb, Mesa (llvmpipe), ffmpeg and Python, then runs the server over stdio. It is not tested in this environment (no Dolphin display/GPU available), but it is the intended deployment shape for a headless container.

Tool reference

All tools take an instance_id where relevant.

  • gc_platform_list, gc_platform_capabilities

  • gc_instance_start, gc_instance_list, gc_instance_status, gc_instance_stop, gc_instance_remove

  • gc_capture_backends, gc_capture_configure, gc_capture_screenshot

  • gc_hardware_devices, gc_hardware_register, gc_hardware_update, gc_hardware_list, gc_hardware_status, gc_hardware_remove

  • gc_controller_press, gc_controller_release, gc_controller_set_stick, gc_controller_set_trigger, gc_controller_sequence, gc_controller_sequence_cancel, gc_controller_get_state, gc_controller_reset

  • gc_memory_read, gc_memory_write

  • gc_dolphin_config_get, gc_dolphin_config_set, gc_dolphin_config_apply_profile

  • gc_server_info, gc_gpu_info

Available Tools

45 tools
gc_capture_backendsA

List the available capture backends and how to use them.

Inputs: no named parameters.

gc_capture_configureB

Configure the capture backend of an instance (e.g. display, screen_size).

For a real GameCube hardware instance, this updates the V4L2 capture device / resolution / format and persists the change. opts may include a capture dict of capture options.

Inputs: opts (required), instance_id (required).

gc_capture_screenshotB

Capture the current frame of an instance to a PNG.

Returns the path to the saved PNG, and optionally base64-encoded image data.

Inputs: instance_id (required), filename, include_base64.

gc_controller_flickA

Flick an analog stick: push to (x, y), hold, then return to centre.

This is the analog counterpart to gc_controller_press_once — a single atomic action you can use for menu navigation (e.g. nudge the stick up/down to move a cursor) without pairing set_stick/reset calls.

stick is 'main' or 'c'. x/y are in -1..1 (0,0 = centre). The stick is always returned to centre afterwards. hold_duration defaults to 200 ms.

Inputs: x (required), y (required), port (required), stick (required), +2 more.

gc_controller_get_stateC

Return the current state of a GameCube controller port.

Inputs: port (required), instance_id (required).

gc_controller_pressA

Press (hold) a button on a GameCube controller port.

Buttons: A, B, X, Y, Z, START, L, R, D_UP, D_DOWN, D_LEFT, D_RIGHT. Remember to call gc_controller_release (or use gc_controller_sequence).

Inputs: port (required), button (required), instance_id (required).

gc_controller_press_onceA

Tap a button once: press, hold for hold_duration ms, then release.

This is the recommended way to send a button press for agent use. It is a single atomic action — you do not need to pair gc_controller_press and gc_controller_release. The button is always released afterwards.

hold_duration defaults to 200 ms. Pass a larger value to hold the button longer (e.g. to hold START through a loading screen).

Inputs: port (required), button (required), instance_id (required), hold_duration.

gc_controller_releaseC

Release a button on a GameCube controller port.

Inputs: port (required), button (required), instance_id (required).

gc_controller_resetC

Reset a GameCube controller port to its neutral state.

Inputs: port (required), instance_id (required).

gc_controller_sequenceA

Run a timed input sequence.

Each step is a dict: {"t": ms, "type": "press"|"release", "button": "A"} {"t": ms, "type": "stick", "stick": "main", "x": 0.0, "y": 1.0} {"t": ms, "type": "trigger", "trigger": "L", "value": 1.0} {"t": ms, "type": "wait"} {"t": ms, "type": "reset"} The sequence runs on a background thread. Use gc_controller_sequence_cancel to stop it.

Inputs: port (required), steps (required), instance_id (required), loop.

gc_controller_sequence_cancelC

Cancel a running input sequence.

Inputs: instance_id (required), sequence_id (required).

gc_controller_set_stickB

Set a stick position (analog).

stick is 'main' or 'c'. x/y are in -1..1 (0,0 = centre).

Inputs: x (required), y (required), port (required), stick (required), +1 more.

gc_controller_set_triggerC

Set an analog trigger value (0..1). trigger is 'L' or 'R'.

Inputs: port (required), value (required), trigger (required), instance_id (required).

gc_dolphin_config_apply_profileB

Apply a whole Dolphin.ini profile (a dict of section -> {key: value}).

This is Dolphin-only. Existing keys in the same section are preserved unless overridden by the profile.

Inputs: profile (required), instance_id (required).

gc_dolphin_config_getA

Read a single Dolphin.ini configuration value for an instance.

This is Dolphin-only (real hardware has no such config).

Inputs: key (required), section (required), instance_id (required).

gc_dolphin_config_setB

Set a single Dolphin.ini configuration value for an instance.

Writes to the instance's Config/Dolphin.ini. This is Dolphin-only.

Inputs: key (required), value (required), section (required), instance_id (required).

gc_dolphin_freezeA

Hard-freeze the Dolphin process with SIGSTOP.

This is a coarse OS-level pause that always works (no X display or xdotool needed). It is not compatible with frame-advance (the process is suspended, so it cannot process hotkeys); use gc_dolphin_toggle_pause for a TAS-friendly pause.

Inputs: instance_id (required).

gc_dolphin_hotkey_getA

Read a Dolphin emulator hotkey binding.

key is the Hotkeys.ini key <group>/<control> (e.g. General/Toggle Pause, Save State/Save State Slot 1). Returns the current binding expression (F10, @(Shift+F1)), or None if the hotkey is unbound. This is Dolphin-only (real hardware has no emulator hotkeys).

Inputs: key (required), instance_id (required).

gc_dolphin_hotkey_setA

Set (or clear) a Dolphin emulator hotkey binding.

key is the Hotkeys.ini key <group>/<control>. expression is the binding in Dolphin input syntax, e.g. F8 for a single key or @(Shift+F8) for a combination. Pass expression="" to unbind it.

Dolphin loads Hotkeys.ini all-or-nothing, so this preserves every existing binding and the built-in default set, then applies key. A running instance may need a restart for the change to take effect. This is Dolphin-only.

Common keys (see gc_dolphin_* tools): General/Toggle Pause, Frame Advance/Frame Advance, Save State/Save State Slot 1..8, Load State/Load State Slot 1..8.

Inputs: key (required), expression (required), instance_id (required).

gc_dolphin_load_stateB

Load a save-state from slot (1-8) via F{slot}.

Only slots 1-8 have a Dolphin default hotkey binding (see gc_dolphin_hotkey_get).

Inputs: slot (required), instance_id (required).

gc_dolphin_save_stateA

Save a save-state to slot (1-8) via Shift+F{slot}, then copy it.

Only slots 1-8 have a Dolphin default hotkey binding (see gc_dolphin_hotkey_get).

After saving, the state file is copied into copy_dir (or the server's configured states directory, <data>/states, by default). The result includes copied, state_file and copied_to.

Inputs: slot (required), instance_id (required), copy_dir.

gc_dolphin_step_frameA

Advance exactly one frame when the emulator is paused.

Sends Dolphin's Frame Advance hotkey. Unlike Step Into (a CPU-debugger step), Frame Advance steps one video frame, which is what a TAS tool wants.

The instance config binds Frame Advance to F8 by default (see gc_dolphin_hotkey_get/gc_dolphin_hotkey_set). If it is unbound this tool returns ok=False and no frame advances.

Inputs: instance_id (required).

gc_dolphin_toggle_pauseA

Toggle the emulator's pause state (Dolphin's Toggle Pause hotkey, F10).

Use this to pause a game (e.g. before inspecting memory or screen), then resume. When paused, gc_dolphin_step_frame advances exactly one frame.

This injects a keystroke into the instance's X display via xdotool, so it requires the xvfb capture backend and xdotool installed. On a headless --batch instance Dolphin's [Input] BackgroundInput = True keeps the input gate open so the hotkey is received without window focus.

Inputs: instance_id (required).

gc_dolphin_unfreezeA

Resume a frozen Dolphin process with SIGCONT.

Inputs: instance_id (required).

gc_gpu_infoA

Report GPU rendering diagnostics for this host.

Useful for deciding whether a GameCube instance will render on a real GPU or fall back to Mesa software (llvmpipe), and for diagnosing the /dev/shm SIGBUS crash that occurs when the shared-memory filesystem is too small for Dolphin's emulated RAM.

Inputs: no named parameters.

gc_hardware_devicesA

Probe the Video4Linux2 capture devices present on this host.

A real GameCube registers one of these (e.g. /dev/video0) as its capture_device so the server can grab frames from the console. Each entry reports the node, its card name, the pixel formats it offers, and whether it can actually capture video frames (can_capture). Some nodes expose only UVC metadata and cannot produce a video stream, so prefer one with can_capture: true.

Inputs: no named parameters. Returns: result

gc_hardware_listA

List all registered real GameCube hardware instances.

Inputs: no named parameters. Returns: result

gc_hardware_registerA

Register a real GameCube hardware instance.

A hardware instance represents a physical console that stays connected to this host. It is permanently remembered (persisted to the server's data dir) until it is explicitly removed with gc_hardware_remove.

Args: instance_id: Unique id for the hardware instance (e.g. hw-001). capture_device: Video4Linux2 device path (default /dev/video0). Prefer a device reported with can_capture: true by gc_hardware_devices. capture: Optional capture options, e.g. {"width": 640, "height": 480, "format": "mjpg", "fps": 30, "flush_frames": 5, "warmup_seconds": 5, "warmup_ttl": 60}. warmup_seconds is how long a cold capture card is streamed before grabbing a frame (0 disables). serial_devices: Up to four serial device paths that will act as the GameCube controller ports (0-3). Controller driving is not yet implemented, but the devices are remembered. bba_ip: The console's own BBA IP (e.g. 192.0.2.10), used by gc_rom_load to reach the Swiss netboot listener. bba_port: The netboot listener port (default 4242). info: Free-form description/annotation shown in list and status output.

Inputs: instance_id (required), info, bba_ip, capture, +3 more.

gc_hardware_removeA

Forget a registered hardware instance.

This removes the instance from the persistent registry so it is no longer remembered across server restarts. Use gc_hardware_register to re-add it.

Inputs: instance_id (required).

gc_hardware_statusC

Get detailed status for one hardware instance.

Inputs: instance_id (required).

gc_hardware_updateB

Update a registered hardware instance's settings and persist them.

Use this to set the console's bba_ip (its own IP) so gc_rom_load can reach the Swiss netboot listener, or to change the capture device / ports / info annotation.

Inputs: instance_id (required), info, bba_ip, capture, +3 more.

gc_instance_listB

List all known instances and their status.

Inputs: no named parameters. Returns: result

gc_instance_removeB

Stop and delete an instance and its data directory.

Inputs: instance_id (required).

gc_instance_startA

Start a new Dolphin instance booting the given ROM/DOL/ELF.

Args: instance_id: Unique id for the instance. rom_path: Path to a .iso/.gcm/.dol/.elf file. controller_ports: Which GameCube ports (0-3) get a controller (default [0]). bba_mode: Broadband Adapter mode: ipc, hle, xlink, tap, tapserver, modem, or None/empty to disable. bba_mac: MAC address for the BBA (must start with 00:09:bf or 00:17:ab). video_backend: OGL, Vulkan, Null, or Software Renderer. capture_backend: auto, xvfb, or framedump. memory_backend: process_vm or dolphin_engine. internal_resolution: 1x/2x/... internal resolution. native_resolution: GameCube native framebuffer "WxH" (default 640x480). gpu_accel: auto/none/software/vgl/vgl-egl/vgl-glx (default auto). extra_core: Extra Dolphin.ini [Core] overrides. boot_ipl: Boot the original GameCube IPL (disable "Skip System Menu"), so the boot logo/menu runs before the disc. Only meaningful for a GameCube disc ('.iso'/'.gcm'); requires the server to be configured with a GC_MCP_IPL_DIR folder containing /IPL.bin files (see gc_server_info). Errors if IPL boot is requested but no IPL folder/files are configured. info: Free-form description/annotation shown in list and status output.

Inputs: rom_path (required), instance_id (required), info, bba_mac, +10 more.

gc_instance_statusC

Get detailed status for one instance.

Inputs: instance_id (required).

gc_instance_stopC

Stop a running Dolphin instance.

Inputs: instance_id (required), timeout.

gc_logA

Read this instance's Dolphin log file (<user_dir>/dolphin.log).

Useful for diagnosing crashes, OSReport output from the ROM, or emulator warnings. grep keeps only lines containing the (case-insensitive) substring. tail returns only the last tail lines of the (possibly filtered) output. Returns the matching lines and some metadata.

Inputs: instance_id (required), grep, tail.

gc_memory_readB

Read bytes from the emulated GameCube RAM.

address is a Dolphin emulated address (e.g. 0x80000000 for the start of MEM1). Returns a hex string. Fails gracefully if memory is not available.

Inputs: length (required), address (required), instance_id (required).

gc_memory_read_structB

Read memory at address and unpack it with a Python struct format.

fmt is a Python :mod:struct format string, e.g. ">12f" for twelve big-endian floats (a 3x4 transform matrix), ">II" for two big-endian u32 values, or ">4h" for four big-endian s16 values.

GameCube is big-endian, so include a byte-order prefix in fmt: > (big-endian, standard sizes) or ! (network order). If you omit it the format uses the host's native byte order/sizes, which is almost never what you want for a GameCube, so it is recommended to always prefix with >.

The result values is a list of the unpacked values in format order.

Inputs: fmt (required), address (required), instance_id (required).

gc_memory_writeB

Write bytes to the emulated GameCube RAM.

data is a hex string (e.g. "00010203"). address is a Dolphin emulated address. Fails gracefully if memory is not available.

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

gc_memory_write_structB

Pack values with a Python struct format and write them to memory.

fmt is a Python :mod:struct format string (see gc_memory_read_struct for the byte-order notes). values is a list of the values to pack, in format order, e.g. for ">12f" pass 12 floats.

Returns the number of bytes written.

Inputs: fmt (required), values (required), address (required), instance_id (required).

gc_platform_capabilitiesB

Describe the capabilities of a platform.

platform may be dolphin:<instance_id> or gamecube-hw:<id>.

Inputs: platform (required).

gc_platform_listA

List the platforms currently available to control.

Includes each running Dolphin instance (dolphin:<id>) and each registered real GameCube hardware instance (gamecube-hw:<id>).

Inputs: no named parameters. Returns: result

gc_rom_loadA

Boot/load a ROM on an instance.

This is the unified entry point for pointing a target at a game:

  • Real GameCube hardware — sends a BOOT command to the console's Swiss netboot listener (TCP 4242 on the instance's bba_ip). rom_path must be a console-side path (sdc:/ or fsp:/, e.g. sdc:/games/Foo.iso). If the console is currently inside a game the listener is down; this first tries to return to Swiss with the A+Z+START combo (which needs hardware button pressing, not implemented yet).

    Raises :class:NetbootError if the BOOT command is not answered with OK — including when the listener returns no reply at all (console mid-boot / dropped connection) or refuses the ROM (ERR <reason>).

  • Dolphin instance — stops the current process and relaunches it booting the given host-side ROM/DOL/ELF path.

For hardware, set the console's IP with gc_hardware_update(instance_id, bba_ip='<console-ip>') before loading a ROM.

Inputs: rom_path (required), instance_id (required).

gc_server_infoB

Return information about this gc-mcp server and its environment.

Inputs: no named parameters.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 45 tools

    Disambiguation4/5

    Most tools target a distinct resource+action (memory_read vs memory_write_struct, controller_press vs set_stick, hardware_register vs hardware_update). A few pairs overlap: gc_instance_start vs gc_rom_load (both boot a ROM), gc_platform_list vs gc_instance_list, gc_dolphin_freeze/unfreeze vs gc_dolphin_toggle_pause, and gc_capture_configure vs gc_hardware_update for capture settings. Descriptions do explicitly distinguish these (SIGSTOP vs TAS-friendly pause, atomic press_once vs press/release), which keeps misselection limited.

    Naming Consistency4/5

    Strong, predictable gc_<domain>_<verb_noun> pattern throughout (gc_instance_start, gc_controller_press_once, gc_memory_read_struct, gc_hardware_register). Minor deviations exist for noun-only tools (gc_log, gc_server_info, gc_gpu_info, gc_controller_get_state), but all names are snake_case with the gc_ prefix and are readable.

    Tool Count2/5

    45 tools is well above the 25-tool threshold and heavy even for a broad emulator+hardware surface; several could be consolidated (press/release/press_once/flick, set_stick, set_trigger; platform_list vs instance_list; hardware_update vs capture_configure). The scope is genuinely multi-domain, but the surface is larger than necessary for coherent selection.

    Completeness4/5

    Coverage is broad and lifecycle-complete in most areas: instance and hardware CRUD, full controller input including sequences, memory read/write (raw and struct), save-states, hotkeys, config, capture, and logs. Notable gaps are explicitly stated — controller driving over serial for real hardware is not implemented, and hardware button-press to return to Swiss is missing — but these are minor relative to the overall surface.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      An MCP server for Dolphin (GameCube + Wii) — drives memory r/w, controller input (GameCube + Wii Remote), pause/resume/reset, savestates, and frame advance from MCP-compatible clients (Claude Desktop, Claude Code, etc.).
      20
      45 npm
      6
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides a set of low-level tools for reverse engineering GameCube and Wii games via Dolphin's DAP debug server, including memory/register operations, disassembly, breakpoints, and code injection.
      1
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables controlling a real Minecraft Bedrock client by injecting input and reading frames through the launcher's agent socket, including launching, stopping, screenshotting, sending chat, and managing multiple bot instances.
      6
      -