gc-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@gc-mcp launch the ROM and press start"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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) orgamecube-hw(a real console). Hardware instances are permanently remembered in<data>/hardware.jsonuntil explicitly removed.Instance — one running Dolphin process, isolated by its own
--userdata 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 withffmpeg/xwdinto PNG. Rendering happens on a real GPU (via VirtualGLvglrun) when available, else Mesallvmpipe.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, elseffmpeg -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 forwarmup_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.75Memory 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 gamegc_rom_load is the unified entry point across targets:
Real hardware — sends
BOOTto the netboot listener. Setbba_ipwithgc_hardware_register(..., bba_ip=...)orgc_hardware_update(...); it is persisted on the hardware instance. If the console is currently inside a game the listener is down, sogc_rom_loadfirst 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 |
|
| Dolphin executable |
|
| Root for per-instance data & captures |
|
|
|
|
| BBA mode ( |
|
| Must be |
|
|
|
|
| GameCube native framebuffer |
|
|
|
| auto-detected | GPU DRM device path (e.g. |
| empty | 3D X server display for VirtualGL's GLX back end (e.g. |
|
|
|
|
| Default capture device for real hardware instances |
|
| Default hardware capture width |
|
| Default hardware capture height |
|
| Default hardware capture pixel format ( |
|
| Default hardware capture frame rate |
|
| Stale buffers flushed before reading a fresh frame (OpenCV path) |
|
| Seconds to stream a cold device before grabbing a frame ( |
|
| Seconds a warmed device is trusted before it is warmed again |
| empty | Default BBA IP for a new hardware instance (the console's own IP, used to reach the Swiss netboot listener) |
|
| 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_capabilitiesgc_instance_start,gc_instance_list,gc_instance_status,gc_instance_stop,gc_instance_removegc_capture_backends,gc_capture_configure,gc_capture_screenshotgc_hardware_devices,gc_hardware_register,gc_hardware_update,gc_hardware_list,gc_hardware_status,gc_hardware_removegc_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_resetgc_memory_read,gc_memory_writegc_dolphin_config_get,gc_dolphin_config_set,gc_dolphin_config_apply_profilegc_server_info,gc_gpu_info
Available Tools
45 toolsgc_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
BOOTcommand to the console's Swiss netboot listener (TCP 4242 on the instance'sbba_ip).rom_pathmust be a console-side path (sdc:/orfsp:/, 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:
NetbootErrorif theBOOTcommand is not answered withOK— 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
Scored across 45 tools
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.
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.
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.
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
Related MCP Connectors
Drive real devices from your AI Coding tool. Embed a client SDK (Unity, Godot, Flutter, iOS/macOS, Android, React Native, Web) in your app, then capture screenshots, traverse the UI tree, inject taps and key events, and run automated test tasks on the physical device over a secure relay.
Securely control computers you explicitly pair through files, terminals, processes, screenshots, desktop UI/input, clipboard, browser automation, diagnostics, and document tools.
Drive your retro handheld console: find your games, launch, save, set volume, get cheat codes.
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables programmatic control of the mGBA emulator for Game Boy, Game Boy Color, and Game Boy Advance games, including screenshot capture, memory reading, sprite data dumping, and custom Lua script execution for automated testing and game analysis.66-
- AlicenseAqualityBmaintenanceAn 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.).2045 npm6MIT
- AlicenseNot gradedqualityDmaintenanceProvides 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.1MIT
- FlicenseNot gradedqualityBmaintenanceEnables 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-