The #1 MCP Server for Godot Engine

Build Godot games
with AI superpowers

Connect Claude, Cursor, or any AI assistant directly to your Godot 4 editor with 147 tools. Create scenes, write scripts, simulate player input, inspect your running game, build 3D environments, set up physics, add particles and audio — all from a single AI conversation.

Get on itch.io Buy Me a Coffee
$5 one-time purchase · Lifetime updates

See It in Action

One prompt → AI builds a complete Reversi game, launches it, and play-tests with mouse clicks.

Watch the full 5-minute demo on YouTube → 
AI Assistant <--stdio/MCP--> Node.js Server <--WebSocket--> Godot Editor

Real-time bidirectional communication. No file polling. No CLI subprocess spawning. Just instant feedback.

How It Works

Connect your AI assistant to Godot in under 5 minutes.

Install the Plugin

Copy addons/godot_mcp/ into your Godot project. Enable it in Project > Project Settings > Plugins. The plugin starts a WebSocket server inside the editor automatically.

Build the MCP Server

Run npm install && npm run build in the server/ directory. This compiles the TypeScript MCP server that bridges your AI client to the Godot plugin.

Start Building with AI

Add the server to your AI client's MCP config. Open Godot, and your AI assistant now has real-time access to 147 tools — creating scenes, editing scripts, simulating input, and analyzing your running game.

147
Tools
23
Categories
16
Exclusive categories
(no competitor has)
∞
Undo/Redo
on all mutations

147 Tools, 23 Categories

Everything you need to let AI build, inspect, test, and modify your Godot project in 2D and 3D.

Project

7 tools
  • get_project_info metadata & autoloads
  • get_filesystem_tree recursive file tree
  • search_files fuzzy/glob search
  • get/set_project_settings read & write
  • uid_to_project_path UID conversion
  • project_path_to_uid path conversion

Scene

9 tools
  • get_scene_tree live hierarchy
  • get_scene_file_content raw .tscn
  • create_scene new scenes
  • open_scene delete_scene save_scene
  • add_scene_instance prefab-like instancing
  • play_scene stop_scene

Node

11 tools
  • add_node delete_node rename_node
  • duplicate_node deep copy
  • move_node reparent
  • update_property smart type parsing
  • get_node_properties inspect all props
  • add_resource shapes, materials
  • set_anchor_preset UI anchors
  • connect_signal disconnect_signal

Script

6 tools
  • list_scripts project-wide overview
  • read_script create_script
  • edit_script search/replace & insert
  • attach_script attach to nodes
  • get_open_scripts editor awareness

Editor

9 tools
  • get_editor_errors errors & stack traces
  • get_editor_screenshot editor viewport
  • get_game_screenshot running game
  • compare_screenshots visual diff NEW
  • execute_editor_script run GDScript
  • get_signals inspect signal connections
  • reload_plugin reload_project
  • clear_output

Input Simulation

5 tools
  • simulate_key keyboard with modifiers
  • simulate_mouse_click positioned clicks
  • simulate_mouse_move absolute/relative
  • simulate_action Godot InputActions
  • simulate_sequence multi-event combos

Runtime Analysis

15 tools
  • get_game_scene_tree live game hierarchy
  • get/set_game_node_properties runtime inspection & tweaking
  • execute_game_script run code in live game
  • capture_frames multi-frame screenshots
  • monitor_properties property timeline
  • start/stop/replay_recording input recording & replay NEW
  • find_nodes_by_script get_autoload
  • find_ui_elements click_button_by_text NEW
  • wait_for_node batch_get_properties NEW

Animation

6 tools
  • list_animations create_animation
  • add_animation_track value/position/bezier
  • set_animation_keyframe insert keys
  • get_animation_info tracks & keyframes
  • remove_animation

AnimationTree NEW

8 tools
  • create_animation_tree with state machine root
  • get_animation_tree_structure full tree inspection
  • add/remove_state_machine_state manage states
  • add/remove_state_machine_transition with conditions
  • set_blend_tree_node Add2, Blend2, TimeScale
  • set_tree_parameter conditions & blends

TileMap

6 tools
  • tilemap_set_cell place tiles
  • tilemap_fill_rect fill regions
  • tilemap_get_cell read tile data
  • tilemap_clear clear all
  • tilemap_get_info tile set sources
  • tilemap_get_used_cells query used cells

3D Scene NEW

6 tools
  • add_mesh_instance primitives & .glb/.gltf import
  • setup_lighting sun/indoor/dramatic presets
  • set_material_3d full PBR material setup
  • setup_environment sky, fog, glow, SSAO, SSR
  • setup_camera_3d projection, FOV, cull mask
  • add_gridmap GridMap with MeshLibrary

Physics NEW

6 tools
  • setup_collision auto-detect 2D/3D shapes
  • set/get_physics_layers layer & mask management
  • add_raycast RayCast2D/3D
  • setup_physics_body CharacterBody & RigidBody config
  • get_collision_info full collision audit

Particles NEW

5 tools
  • create_particles GPUParticles 2D/3D
  • set_particle_material direction, velocity, emission shape
  • set_particle_color_gradient color ramp stops
  • apply_particle_preset fire, smoke, rain, snow, sparks
  • get_particle_info full config inspection

Navigation NEW

5 tools
  • setup_navigation_region auto-detect 2D/3D
  • bake_navigation_mesh mesh baking & polygon gen
  • setup_navigation_agent pathfinding & avoidance
  • set_navigation_layers layer management
  • get_navigation_info full nav audit

Audio NEW

6 tools
  • get_audio_bus_layout full bus overview
  • add_audio_bus set_audio_bus create & configure
  • add_audio_bus_effect reverb, delay, compressor, EQ
  • add_audio_player 2D/3D audio players
  • get_audio_info subtree audio audit

Theme & UI

6 tools
  • create_theme new Theme resource
  • set_theme_color color overrides
  • set_theme_constant constant overrides
  • set_theme_font_size font sizes
  • set_theme_stylebox StyleBoxFlat
  • get_theme_info inspect overrides

Shader

6 tools
  • create_shader with templates
  • read_shader edit_shader
  • assign_shader_material to nodes
  • set_shader_param set uniforms
  • get_shader_params read all params

Resource NEW

3 tools
  • read_resource inspect .tres properties
  • edit_resource modify & save
  • create_resource new .tres of any type

Batch & Refactoring

6 tools
  • find_nodes_by_type search by class
  • find_signal_connections audit signals
  • batch_set_property bulk changes
  • find_node_references cross-file search
  • get_scene_dependencies dependency graph
  • cross_scene_set_property project-wide changes NEW

Testing & QA NEW

5 tools
  • run_test_scenario automated test sequences
  • assert_node_state property assertions
  • assert_screen_text UI text verification
  • run_stress_test random input fuzzing
  • get_test_report pass/fail summary

Code Analysis NEW

6 tools
  • find_unused_resources dead asset detection
  • analyze_signal_flow signal graph mapping
  • analyze_scene_complexity node count & depth
  • find_script_references cross-project search
  • detect_circular_dependencies cycle detection
  • get_project_statistics full project overview

Profiling

2 tools
  • get_performance_monitors FPS, memory, physics
  • get_editor_performance quick summary

Export

3 tools
  • list_export_presets configured presets
  • export_project build commands
  • get_export_info paths & templates

Why Pro?

Features that free alternatives don't have.

Signal Management

Connect, disconnect, and inspect signals between nodes. No competitor supports this. Essential for Godot's event-driven architecture.

Full Undo/Redo

Every mutation goes through Godot's UndoRedo system. Ctrl+Z everything the AI does. Free alternatives modify scenes directly with no undo.

Smart Type Parsing

Vector2(100,200), #ff0000, Color(1,0,0) — the AI sends strings, we parse them into proper Godot types automatically.

Production-Grade Connection

WebSocket with heartbeat, auto-reconnect (exponential backoff), and port auto-scanning. No dropped connections, no manual restarts.

Contextual Error Suggestions

Errors include structured codes and actionable suggestions. The AI can self-correct instead of getting stuck on cryptic failures.

Complete Node Operations

11 node tools: add, delete, rename, duplicate, move/reparent, update properties, add resources, set anchors. No competitor covers all of these.

Input Simulation & Recording

Let AI play your game. Simulate keyboard, mouse, and InputActions. Record input sessions and replay them for regression testing with frame-precise timing.

Runtime Analysis

15 tools for live game inspection. Read and modify properties at runtime, capture frames, monitor property changes, find UI elements, click buttons by text, and wait for nodes to appear.

Animation & AnimationTree

Create animations, add tracks, insert keyframes. Build state machines with transitions and conditions. Configure blend trees with Add2, Blend2, and TimeScale nodes.

3D Scene Building

Add meshes (primitives or .glb/.gltf), set up lighting with presets, configure PBR materials, create environments with sky/fog/SSAO/SSR, place cameras, and build GridMaps.

Physics & Navigation

Set up collision shapes, configure physics bodies, manage collision layers, add raycasts. Create navigation regions, bake nav meshes, configure pathfinding agents.

Particles & Audio

Create GPU particle systems with presets (fire, smoke, rain, snow). Manage audio buses, add effects (reverb, delay, compressor), and place 2D/3D audio players.

Shader Pipeline

Create shaders from templates, edit GLSL code, assign ShaderMaterials, and tweak uniforms at runtime. Full shader workflow without leaving the AI chat.

Testing & QA

Run automated test scenarios with input simulation and assertions. Verify UI text on screen. Stress test with random input fuzzing. Generate pass/fail test reports.

Code Analysis

Find unused resources, map signal flows, analyze scene complexity, detect circular dependencies, search script references, and get full project statistics.

Batch Operations

Find nodes by type, audit signal connections, bulk-set properties across scenes, search across all project files, and analyze dependencies. Refactor at scale.

What Can AI Do in Your Godot Project?

Real examples of what you can ask your AI assistant to do — and it just works.

Build a Complete Game from Scratch

"Create a Reversi board game with an 8x8 grid, click-to-place mechanics, AI opponent, and score display."

AI creates scenes, writes scripts, connects signals, sets up the UI, and runs the game — all in one conversation. Watch the demo video.

Uses: create_scene add_node create_script connect_signal play_scene

Set Up a 3D Environment

"Add a terrain mesh, set up dramatic lighting with shadows, configure PBR materials with roughness 0.3, and add fog with volumetric density 0.02."

AI adds meshes, configures lighting presets, sets up PBR materials, and tweaks environment settings — all through the editor API with full undo/redo.

Uses: add_mesh_instance setup_lighting set_material_3d setup_environment

Automated Play-Testing

"Play the game, walk the character right for 2 seconds, jump, then check if the player reached the platform."

AI launches the game, simulates keyboard input, captures screenshots, inspects runtime node properties, and verifies game state — enabling automated QA workflows.

Uses: play_scene simulate_key get_game_screenshot get_game_node_properties assert_node_state

Debug GDScript Errors

"Check for errors in the editor and fix them."

AI reads the editor's error output and script compile errors, identifies the issue, edits the script to fix it, and verifies the fix — a tight feedback loop without copy-pasting error messages.

Uses: get_editor_errors read_script edit_script get_editor_errors

Add Particle Effects

"Add fire particles to the torch node with an orange-to-red gradient and upward velocity."

AI creates GPU particles, configures emission shape and velocity, applies color gradients, or uses built-in presets (fire, smoke, rain, snow, sparks) for instant results.

Uses: create_particles set_particle_material set_particle_color_gradient

Refactor Across Scenes

"Find all CharacterBody2D nodes in the project and set their floor_snap_length to 8."

AI searches across all scenes, finds matching nodes, and applies bulk property changes — tasks that would take minutes of manual clicking done in seconds.

Uses: find_nodes_by_type batch_set_property cross_scene_set_property

Comparison

How Godot MCP Pro stacks up against alternatives.

Feature Godot MCP Pro GDAI MCP ($19) godot-mcp (free)
Total Tools 147 ~30 13
Categories 23 ~8 4
Connection WebSocket + heartbeat WebSocket Headless CLI
Undo/Redo Yes Yes No
Signal Management Yes No No
Node Rename/Duplicate/Move Yes No No
Smart Type Parsing Yes Limited No
Input Simulation Key / Mouse / Action / Sequence No No
Runtime Analysis 15 tools (tree, props, frames, UI, recording) No No
3D Scene Tools Mesh, Lighting, PBR, Environment, Camera No No
Physics Setup Collision, Layers, Raycasts, Bodies No No
Particles GPU 2D/3D with presets No No
Navigation Region, Mesh baking, Agent No No
Audio Buses, Effects, Players No No
AnimationTree State machine, Blend tree No No
Automated Testing Scenarios, Assertions, Stress test No No
Code Analysis Unused resources, Signal flow, Complexity No No
Screenshots Editor + Game + Visual diff Yes No

Frequently Asked Questions

Common questions about Godot MCP Pro.

What is Godot MCP Pro?

Godot MCP Pro is a premium MCP (Model Context Protocol) server that connects AI assistants like Claude, Cursor, and Cline directly to the Godot 4 editor via WebSocket. It provides 147 tools across 23 categories for scene manipulation, animation, 3D modeling, physics setup, particle effects, audio management, shader editing, input simulation, runtime analysis, and automated testing.

How do I connect Claude to Godot?

Install the Godot MCP Pro plugin in your project, enable it in Project Settings > Plugins, build the MCP server with npm install && npm run build, and add it to your .mcp.json. Claude (Code or Desktop) will automatically connect to the Godot editor via WebSocket and have access to all 147 tools.

Which AI assistants work with Godot MCP Pro?

Any MCP-compatible AI client works, including Claude Code, Claude Desktop, Cursor, VS Code with Cline extension, Windsurf, and other tools that support the Model Context Protocol standard. The MCP protocol is an open standard, so new clients are added regularly.

Can AI build 3D games in Godot?

Yes. Godot MCP Pro includes dedicated 3D tools for adding mesh primitives or importing .glb/.gltf models, setting up lighting with presets, configuring PBR materials, creating environments with sky/fog/SSAO/SSR, placing cameras, and building GridMaps. Combined with physics, navigation, and particle tools, AI can build complete 3D game scenes.

Can AI play-test my game?

Yes. The runtime analysis suite includes 15 tools that let AI launch your game, simulate keyboard/mouse/action input, capture screenshots, inspect the live scene tree, read and modify properties at runtime, record and replay input sessions, find UI elements, click buttons by text, and run automated test scenarios with assertions.

Does it work with Cursor?

Yes. Godot MCP Pro works with Cursor, VS Code + Cline, Windsurf, Claude Code CLI, Claude Desktop, and any other MCP-compatible client. Configure the MCP server in your editor's settings and it connects via WebSocket.

What Godot version is required?

Godot 4.4 or later (tested on Godot 4.6) and Node.js 18+. Works on Windows, macOS, and Linux.

How does it compare to free alternatives?

Godot MCP Pro offers 147 tools compared to 13-32 in free alternatives. Exclusive features include full undo/redo, signal management, input simulation with recording/replay, 15-tool runtime analysis suite, 3D scene building, physics setup, particle systems, audio bus management, navigation mesh tools, AnimationTree state machines, automated testing, and code analysis.

Is the plugin source code available?

Yes. The GDScript editor plugin (addons/godot_mcp/) is fully open source and available on GitHub. You can inspect exactly how the plugin communicates with the editor before purchasing. The MCP server (TypeScript) is included in the paid download.

Is there a subscription?

No. Godot MCP Pro is a one-time $5 purchase with lifetime updates for v1.x, unlimited projects, unlimited machines, and Discord support. No recurring fees, no seat limits.

Quick Setup Guide

Get up and running in under 5 minutes.

1. Install the Godot Plugin

Copy the addons/godot_mcp/ folder from the download into your Godot project's root directory. Then enable the plugin:

Project > Project Settings > Plugins > Godot MCP Pro > Enable

2. Build the MCP Server

Open a terminal in the server/ directory:

cd server
npm install
npm run build

3. Configure Your AI Client

Add the server to your AI client's MCP configuration file (e.g., .mcp.json for Claude Code):

{
  "mcpServers": {
    "godot-mcp-pro": {
      "command": "node",
      "args": ["/path/to/server/build/index.js"]
    }
  }
}

4. Start Using It

Open your Godot project with the plugin enabled. The status panel in the editor dock shows the connection state. Start your AI assistant and begin building — it now has direct access to 147 tools in your Godot editor.

Simple, One-Time Pricing

Pay once, use forever. Lifetime updates for v1.x included.

$5
One-time payment
  • ✓ All 147 tools across 23 categories
  • ✓ 2D and 3D support
  • ✓ Lifetime updates (v1.x)
  • ✓ Unlimited projects
  • ✓ Unlimited machines
  • ✓ Discord support channel
Buy on itch.io Buy on Buy Me a Coffee Questions? Join our Discord