Skip to main content
Glama

Wick

Roslyn-enriched C# exception telemetry for Godot Engine, exposed over MCP.

CI License: MIT


What is Wick?

When a Godot C# game crashes, your AI assistant sees a raw stack trace and spends 8+ turns asking you to open files. Wick captures that exception, enriches it with Roslyn-powered source context (the actual method body, caller chain, recent logs, scene state), and hands the full picture to the AI in one call. One turn to diagnosis instead of ten.

What makes Wick different?

Other Godot MCP servers (like the excellent GoPeak) focus on scene manipulation and GDScript tooling. Wick focuses on the C#/.NET developer experience:

  • Roslyn-enriched exception telemetry -- stderr-captured C# exceptions enriched with the calling method body, surrounding source lines, enclosing type, and caller chain. No other Godot MCP server does this.

  • In-process exception capture -- optional Wick.Runtime NuGet companion catches TaskScheduler.UnobservedTaskException and async exceptions that stderr can't see.

  • Build diagnostics with source context -- dotnet build errors enriched with Roslyn source context through the same pipeline as runtime exceptions.

  • C# analysis tools -- find symbol, find references, member signatures via Roslyn workspace.

  • 5-pillar tool group system -- activate only what you need: core, runtime, csharp, build, scene.

Related MCP server: Godot MCP

Getting Started

Prerequisites

Installation

Wick has two parts: a Godot-side bridge addon (/addons/wick/) and the .NET MCP server.

Godot bridge — install via the Godot Asset Library in-editor (recommended), or copy /addons/wick/ into your project manually.

MCP server — clone and build:

git clone https://github.com/buildepicshit/Wick.git
cd Wick
dotnet build Wick.slnx --configuration Release -maxcpucount:1

MCP Configuration

Add Wick to your AI coding assistant's MCP configuration:

{
  "mcpServers": {
    "wick": {
      "command": "dotnet",
      "args": ["run", "--project", "path/to/Wick/src/Wick.Server"],
      "env": {
        "WICK_GROUPS": "core,runtime,csharp,build",
        "WICK_GODOT_BIN": "/path/to/godot",
        "WICK_PROJECT_PATH": "/path/to/your/godot-project"
      }
    }
  }
}

Tool Groups

Activate tool pillars via WICK_GROUPS env var or --groups CLI flag:

Pillar

What it includes

Default

core

GDScript tools, scene parsing, GDScript LSP, introspection

Always on

runtime

Exception pipeline, game launch/stop, log tail, runtime_diagnose

Opt-in

csharp

Roslyn analysis, find symbol, find references, member signatures

Opt-in

build

dotnet build/test/clean, NuGet management, build_diagnose

Opt-in

scene

Scene create/modify via headless Godot dispatch

Opt-in

Example: WICK_GROUPS=core,runtime,csharp,build or --groups=all.

Optional: Wick.Runtime Companion

For in-process exception capture (async exceptions, TaskScheduler.UnobservedTaskException) and live scene-tree queries, add the Wick.Runtime NuGet companion to your Godot C# project:

dotnet add package Wick.Runtime

Wire both Install() and Tick() into your game's entry point — both are required:

using Wick.Runtime;

public partial class Main : Node
{
    public override void _Ready() => WickRuntime.Install();

    public override void _Process(double delta) => WickRuntime.Tick();
}

If your in-process bridge tools (runtime_query_scene_tree, etc.) hang forever, you forgot Tick(). Install() alone covers exception capture, but live RPC handlers need Tick() to drain the main-thread dispatcher. See docs/getting-started.md and the package README for the full story.

Architecture

Wick runs as an external process -- it does NOT run inside Godot. Communication:

  • stdio -- MCP protocol to the AI client

  • TCP 6505 -- editor bridge (Godot plugin to Wick server)

  • TCP 7777 -- runtime bridge (running game to Wick server)

  • TCP 7878 -- Wick.Runtime companion bridge (in-process to Wick server)

This architecture lets the Wick server and provider projects target .NET 10 while the optional in-process Wick.Runtime companion stays on net8.0 for Godot 4.6.1's current stable .NET runtime.

Attribution

Wick is a clean-room reimplementation inspired by GoPeak (MIT License, (c) 2025 Solomon Elias / HaD0Yun). See ATTRIBUTION.md for detailed credits.

Contributing

We welcome contributions! Please read CONTRIBUTING.md before submitting a PR.

Demo

Clone the repo and open docs/demo/player.html in a browser to watch the demo, or play the cast file directly:

asciinema play docs/demo/wick-demo.cast

License

MIT

Available Tools

17 tools
detect_languageB

Determines the language context for a given file path (GDScript, C#, or Godot resource).

Inputs: filePath (required).

gd_lsp_connectA

Explicitly connects and initializes the GDScript Language Server. (Most other LSP tools will automatically connect if needed).

Inputs: no named parameters.

gd_lsp_definitionA

Finds the definition (source file and line) of the symbol at the given position.

Inputs: filePath (required), line (required), character (required).

gd_lsp_hoverB

Simulates hovering over a symbol at a specific line and character to get documentation and type info.

Inputs: filePath (required), line (required), character (required).

gd_lsp_symbolsB

Gets the document symbols (functions, variables, classes) for a given GDScript file.

Inputs: filePath (required).

gd_script_statusA

Returns GDScript provider status and capabilities.

Inputs: no named parameters.

godot_statusB

Returns Godot Engine provider status and capabilities.

Inputs: no named parameters.

project_infoA

Reads detailed info about a specific Godot project from its project.godot file path.

Inputs: projectGodotPath (required).

project_listB

Discovers Godot projects under a given root directory. Returns project names, paths, C# support status, and scene/script counts.

Inputs: rootPath (required).

scene_listB

Lists all scenes (.tscn files) in a Godot project directory.

Inputs: projectPath (required).

scene_nodesA

Parses a .tscn scene file and returns the node tree structure, properties, and external resources.

Inputs: scenePath (required).

script_createB

Generates a GDScript file template for a node type with proper structure: extends, class_name, lifecycle functions, and signals.

Inputs: className (required), extends, includeReady, includeProcess, +1 more.

script_infoA

Parses a GDScript file and returns its structure: class_name, extends, functions, signals, variables, exports, constants, and enums.

Inputs: filePath (required).

script_listB

Lists all scripts (.gd and .cs files) in a Godot project directory with language detection.

Inputs: projectPath (required).

tool_catalogA

Returns every known Wick tool with its group assignment and whether it is active in this process. Use to discover available functionality.

Inputs: no named parameters.

tool_groupsA

Returns the resolved active tool groups for this Wick process along with descriptions of every available group.

Inputs: no named parameters.

tool_resetA

Placeholder for future dynamic group activation. Not functional in v1: Wick resolves groups once at startup from --groups or WICK_GROUPS. This tool is retained for forward compatibility.

Inputs: no named parameters.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 17 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, from language detection and LSP features to project and script analysis. No overlap or ambiguity among the 17 tools.

    Naming Consistency4/5

    Tools use snake_case and are grouped by domain (e.g., gd_lsp_, project_, scene_, script_, tool_). Minor inconsistencies like 'detect_language' vs. verb-noun pattern in others, but overall predictable.

    Tool Count5/5

    17 tools is well-scoped for a Godot development MCP server, covering project discovery, script analysis, LSP features, and administrative functions without being excessive.

    Completeness4/5

    The tool set covers core workflows: project listing, scene/script inspection, LSP support, and script creation. Missing scene editing or saving, but sufficient for analysis and code assistance.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      An out-of-the-box, zero-dependency Model Context Protocol (MCP) server integration designed specifically for the Godot Engine (4.x).Once connected, your AI agents (Claude, Cursor, Trae, ChatGPT) gain access to a powerful set of tools to interact with your active Godot project directory.
      4
      -
    • A
      license
      A
      quality
      A
      maintenance
      Open-source MCP server connecting AI agents (Claude, Cursor, GitHub Copilot, Gemini, and more) to the Godot Editor and runtime (Godot 4.x, C#). Additionally you can use AI Game Dev app (https://ai-game.dev) to generate images, video, audio, 3D, rig, animation and much more.
      14
      345
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      The most advanced MCP server for Godot Editor that lets AI assistants operate directly inside your running Godot project for scene creation, script generation, UI authoring, and more.
      53
      MIT