Skip to main content
Glama

AI coding assistants are structurally bad at GDScript. Models trained on data skewed towards Godot 3 hallucinate deprecated APIs (yield instead of await, KinematicBody instead of CharacterBody3D, export var instead of @export var). Godot Forge fixes this.

8 tools. Zero config. Works with every MCP-compatible IDE.

Install

npx -y godot-forge

That's it. Godot Forge auto-detects your Godot binary (Steam, Homebrew, direct download) and finds your project.godot automatically.

Add to your IDE

claude mcp add godot-forge -- npx -y godot-forge

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "godot-forge": {
      "command": "npx",
      "args": ["-y", "godot-forge"]
    }
  }
}

Add to .vscode/mcp.json:

{
  "servers": {
    "godot-forge": {
      "command": "npx",
      "args": ["-y", "godot-forge"]
    }
  }
}

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "godot-forge": {
      "command": "npx",
      "args": ["-y", "godot-forge"]
    }
  }
}

Add to settings.json:

{
  "context_servers": {
    "godot-forge": {
      "command": {
        "path": "npx",
        "args": ["-y", "godot-forge"]
      }
    }
  }
}

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%/Claude/claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "godot-forge": {
      "command": "npx",
      "args": ["-y", "godot-forge"]
    }
  }
}

See IDE Setup Guide for configuration snippets for all supported IDEs.

Related MCP server: godot-devtool

Tools

Tool

Description

Needs Godot

Needs Editor

godot_run_tests

Run GUT/GdUnit4 tests, get structured pass/fail results

Yes

No

godot_search_docs

Search Godot 4 API docs with 3→4 migration mapping

No

No

godot_analyze_script

Detect 10 GDScript pitfalls (deprecated API, coupling, re-entrancy)

No

No

godot_analyze_scene

Parse .tscn/.tres, detect antipatterns and format errors

No

No

godot_get_project_info

Project structure overview with progressive disclosure

No

No

godot_get_diagnostics

LSP diagnostics from Godot's language server

No

Yes

godot_run_project

Launch/stop project, capture debug output

Yes

No

godot_screenshot

Capture viewport screenshot as base64 PNG

Yes

No

TIP

6 of 8 tools work without Godot installed. Only test running, project launching, and screenshots need the binary.

Features

Test Runner

Auto-detects GUT and GdUnit4. Returns structured JSON with pass/fail counts, failure details with file paths and line numbers. Supports filtering by script, method, or inner class.

Ask your AI: "Run the water profile tests"
→ { total: 5, passed: 5, failed: 0, duration_ms: 462 }

Godot 3→4 Migration Mapping

The #1 reason AI writes broken GDScript. When your AI queries a deprecated API, it gets the correct Godot 4 equivalent instantly (30+ mappings covering classes, methods, syntax, and constants).

Query: "KinematicBody"  →  "Renamed to CharacterBody3D in Godot 4"
Query: "yield"          →  "yield(obj, 'signal') → await obj.signal"
Query: "instance()"     →  "instance() → instantiate()"

Script Analysis: 10 Pitfalls

Every pitfall detected from real game development:

#

Pitfall

What It Catches

1

Godot 3→4 API

yield, connect("signal"), export var, instance()

2

Giant scripts

Over 300 lines. Should be split

3

:= on Variant

Type inference on Dictionary.get() causes parse errors

4

Tight coupling

Excessive get_node("../../...") references

5

Signal re-entrancy

Signal emitted between state changes

6

Autoload misuse

Too many autoloads, static func on autoloads

7

Missing disconnect

connect() without _exit_tree() cleanup

8

_init() timing

Node tree access before node is in tree

9

Python-isms

List comprehensions, len(), Python imports

10

.tres type field

Custom class name instead of type="Resource"

Scene Analysis

Parses .tscn and .tres files. Detects deep nesting (>8 levels), oversized scenes (>100 nodes), missing script references, preload() in .tres, integer resource IDs, and more.

LSP Diagnostics

Connects to Godot's built-in language server (runs automatically when the editor is open). Returns real compiler errors and warnings (no guesswork).

NOTE

Requires the Godot editor to be running with your project open. All other tools work without the editor.

Screenshot Capture

Captures the game viewport as a PNG image. Loads the project's main scene (or a specified scene), waits for rendering, and returns the screenshot as base64 for the AI to see.

Configuration

Godot Binary

Auto-detected in this order:

  1. GODOT_PATH environment variable

  2. godot / godot4 in PATH

  3. Steam installation (macOS, Windows, Linux)

  4. Platform defaults (/Applications/Godot.app, Homebrew, Scoop, Flatpak, Snap, etc.)

Override manually:

export GODOT_PATH="/path/to/godot"

See Godot Detection for the full list of searched paths.

Project Directory

Auto-detected by walking up from the current directory to find project.godot. Override:

npx godot-forge --project /path/to/godot/project

Requirements

  • Node.js 18+: for npx execution

  • Godot 4.x: auto-detected (optional for 6 of 8 tools)

  • Any MCP-compatible IDE: Claude Code, Cursor, VS Code, Windsurf, Zed, and more

Design Principles

  • Outcomes, not operations: Each tool delivers a complete result, not raw API wrapping

  • 8 curated tools: No 93-tool context bloat (why this matters)

  • Progressive disclosure: Summaries first, details on demand

  • spawn() not exec(): No command injection, no Windows quoting bugs

  • Actionable errors: Every error includes a suggestion the AI can act on

  • Cross-platform: macOS, Windows, Linux. Steam and non-Steam installs.

Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

Development

git clone https://github.com/gregario/godot-forge.git
cd godot-forge
npm install
npm run build
npm test        # 74 tests across 12 test files

Running locally

# Point your IDE at the local build
claude mcp add godot-forge-dev -- node /path/to/godot-forge/dist/index.js

Roadmap

See ROADMAP.md for planned features.

Phase 2: Input simulation, runtime scene tree inspection, performance profiling, shader validation, export/CI pipeline.

Licence

MIT

Available Tools

8 tools
godot_analyze_sceneA
Read-onlyIdempotent

Parse .tscn scene files or .tres resource files and return structured analysis. Detects antipatterns (deep nesting, oversized scenes, missing scripts) and format errors (preload in .tres, custom class names in type field, integer resource IDs).

Inputs: path (required).

godot_analyze_scriptA
Read-onlyIdempotent

Analyse GDScript files for all 10 battle-tested pitfalls: Godot 3→4 API misuse, giant scripts, := on Variant, tight coupling, signal re-entrancy, autoload misuse, missing signal disconnect, _init() timing, Python-isms, and static func on autoloads.

Inputs: path (required).

godot_get_diagnosticsA
Read-onlyIdempotent

Get LSP diagnostics (errors, warnings) from Godot's built-in language server. Requires Godot editor to be running with the project open.

Inputs: path, port.

godot_get_project_infoA
Read-onlyIdempotent

Return project structure overview: project name, Godot version, scenes, scripts, autoloads, addons, and directory tree. Uses progressive disclosure — summary by default, full details on request.

Inputs: detail.

godot_run_projectA

Launch, stop, or get debug output from a running Godot project. Captures stdout/stderr with timestamps.

Inputs: action (required), scene.

godot_run_testsA
Idempotent

Run GUT or GdUnit4 tests headlessly and return structured pass/fail results. Auto-detects the test framework. Returns total/passed/failed counts with failure details including file paths and line numbers.

Inputs: script_path, method, inner_class, framework, +1 more.

godot_screenshotA
Read-onlyIdempotent

Capture a viewport screenshot from the running Godot project. Returns base64-encoded PNG image. Requires a display server (not headless mode).

Inputs: scene.

godot_search_docsA
Read-onlyIdempotent

Search Godot 4.x API documentation. Returns class overviews, method details, or fuzzy search results. Automatically detects Godot 3 API queries and suggests Godot 4 equivalents — the #1 source of AI-generated GDScript bugs.

Inputs: query (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool addresses a distinct concern: testing, documentation lookup, diagnostics, scene analysis, script analysis, project execution, screenshots, and project metadata. There is no functional overlap, and the descriptions clearly delineate their purposes.

    Naming Consistency4/5

    All tools share the 'godot_' prefix and most follow a verb_noun pattern (run_tests, search_docs, get_diagnostics, analyze_scene, analyze_script, run_project, get_project_info). 'godot_screenshot' deviates slightly as a noun-only name, but it remains unambiguous and consistent with the overall style.

    Tool Count5/5

    With 8 tools, the surface is well-scoped for a Godot development assistant. Each tool serves a clear purpose in the workflow without unnecessary bloat or missing essential capabilities.

    Completeness4/5

    The toolset covers the core development cycle: test execution, documentation, diagnostics, static analysis of scenes and scripts, project running, and visual capture. Minor gaps exist, such as lack of scene editing or deployment support, but these are outside the intended analysis/run scope and do not create dead ends.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      A Model Context Protocol server that enables AI assistants to interact with the Godot game engine, allowing them to launch the editor, run projects, capture debug output, and control project execution.
      14
      194 npm
      6,603
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      A TypeScript MCP server bridging MCP clients to Godot 4 editor, enabling scene, node, script editing and more via WebSocket.
      194 npm
      MIT