Renderdoc MCP
MCP server for RenderDoc β AI-assisted GPU frame capture analysis
Ask AI about Renderdoc MCP
Powered by Claude Β· Grounded in docs
I know everything about Renderdoc MCP. Ask me about installation, configuration, usage, or troubleshooting.
0/500
Reviews
Documentation
renderdoc-mcp
β οΈ Disclaimer
$\Large\color{#ff69b4}{\textsf{This is a personal }}$ $\Large\color{#ff69b4}{\mathtt{β¨ vibe\text{-}coding β¨}}$ $\Large\color{#ff69b4}{\textsf{project β}}$ $\Large\color{#ff69b4}{\textsf{built for fun, not for production use.}}$
$\small\color{gray}{\textsf{I have no idea why this repo has so many stars...}}$
MCP server for RenderDoc β let AI assistants analyze GPU frame captures (.rdc files) for graphics debugging and performance analysis.
Built on the Model Context Protocol, works with Claude Desktop, Claude Code, and any MCP-compatible client.
Features
- 42 tools covering the full RenderDoc analysis workflow
- 10 high-level tools for one-call analysis (draw call state, frame overview, diff, batch export, pixel region sampling, etc.)
- 3 built-in prompts for guided debugging
- Human-readable output β blend modes, depth functions, topology shown as names not numbers
- GPU quirk detection β auto-identifies Adreno/Mali/PowerVR/Apple-specific pitfalls from driver name
- Headless β no GUI needed, runs entirely via RenderDoc's Python replay API
- Pure Python β single
pip install, no build step - Supports D3D11, D3D12, OpenGL, Vulkan, OpenGL ES captures
Quick Start
1. Prerequisites
- Python 3.10+
- RenderDoc installed (download)
- You need the
renderdoc.pyd(Windows) orrenderdoc.so(Linux) Python module - It ships with every RenderDoc installation
- You need the
2. Install
git clone https://github.com/Linkingooo/renderdoc-mcp.git
cd renderdoc-mcp
pip install -e .
3. Find your renderdoc.pyd path
The Python module is in your RenderDoc install directory:
| Platform | Typical path |
|---|---|
| Windows | C:\Program Files\RenderDoc\renderdoc.pyd |
| Linux | /usr/lib/renderdoc/librenderdoc.so or where you built it |
You need the directory containing this file.
4. Configure your MCP client
Claude Desktop
Edit claude_desktop_config.json (Settings β Developer β Edit Config):
{
"mcpServers": {
"renderdoc": {
"command": "python",
"args": ["-m", "renderdoc_mcp"],
"env": {
"RENDERDOC_MODULE_PATH": "C:\\Program Files\\RenderDoc"
}
}
}
}
Claude Code
Add to .claude/settings.json:
{
"mcpServers": {
"renderdoc": {
"command": "python",
"args": ["-m", "renderdoc_mcp"],
"env": {
"RENDERDOC_MODULE_PATH": "C:\\Program Files\\RenderDoc"
}
}
}
}
Run standalone
# Set the module path
export RENDERDOC_MODULE_PATH="/path/to/renderdoc" # Linux/macOS
set RENDERDOC_MODULE_PATH=C:\Program Files\RenderDoc # Windows
# Run
python -m renderdoc_mcp
Usage Examples
Once configured, just talk to your AI assistant:
"Open
frame.rdcand show me what's happening in the frame"
"Find the draw call that renders the character model and check its pipeline state"
"Why is my shadow map rendering black? Check the depth pass"
"Analyze performance β are there any redundant draw calls?"
Typical Tool Flow
open_capture("frame.rdc") # Load the capture
βββ get_capture_info() # API, GPU, known_gpu_quirks
βββ get_frame_overview() # Frame-level stats and render passes
βββ get_draw_call_state(142) # Complete draw call state in one call
βββ diff_draw_calls(140, 142) # Compare two draw calls (with implications)
βββ export_draw_textures(142, "./tex/") # Batch export all bound textures
βββ save_render_target(142, "./rt.png") # Save render target snapshot
βββ analyze_render_passes() # Auto-detect render pass boundaries
βββ find_draws(blend=True, min_vertices=1000) # Search by rendering state
βββ sample_pixel_region(rt_id, 0,0,512,512) # Scan RT region for NaN/Inf/negatives
βββ pixel_history(id, 512, 384) # Debug a specific pixel
βββ export_mesh(142, "./mesh.obj") # Export mesh as OBJ
βββ close_capture() # Clean up
For performance and diagnostic analysis:
get_pass_timing(granularity="pass") # Find most expensive render passes
analyze_overdraw() # Fill-rate pressure estimate
analyze_bandwidth() # Memory bandwidth estimate
analyze_state_changes() # Batching opportunities
diagnose_negative_values() # Find NaN/Inf/negative color values (ηιͺ)
diagnose_precision_issues() # R11G11B10, D16, SRGB mismatches
diagnose_reflection_mismatch() # Reflection artifact diagnosis
diagnose_mobile_risks() # Comprehensive mobile GPU risk check
For lower-level inspection, all granular tools remain available:
set_event(142) # Navigate to a draw call
βββ get_pipeline_state() # Inspect rasterizer/blend/depth
βββ get_shader_bindings("pixel") # Check what textures/buffers are bound
βββ get_cbuffer_contents("pixel", 0, filter="ibl") # Read shader constants (filterable)
βββ disassemble_shader("pixel", search="SampleSH") # Shader code with context search
βββ save_texture(id, "rt.png") # Export a specific texture
Tools
Session Management (4)
| Tool | Description |
|---|---|
open_capture | Open a .rdc file (auto-closes previous) |
close_capture | Close current capture and free resources |
get_capture_info | Capture metadata: API, action count, resolution, known_gpu_quirks (Adreno/Mali/PowerVR/Apple) |
get_frame_overview | Frame-level statistics: action counts by type, texture/buffer memory, render targets, resolution |
Event Navigation (5)
| Tool | Description |
|---|---|
list_actions | List the draw call / action tree β supports filter (name substring) and event_type (draw/clear/copyβ¦) |
get_action | Full detail for a single action |
set_event | Navigate to an event (required before pipeline queries) |
search_actions | Search by name pattern and/or action flags |
find_draws | Search draw calls by rendering state: blend, min vertices, texture/shader/RT binding |
Pipeline Inspection (4)
| Tool | Description |
|---|---|
get_pipeline_state | Full state: topology, viewports, rasterizer, blend, depth, stencil (human-readable enums) |
get_shader_bindings | Constant buffers, SRVs, UAVs, samplers for a shader stage |
get_vertex_inputs | Vertex attributes, vertex/index buffer bindings |
get_draw_call_state | One-call draw analysis: action info, blend formula, depth, stencil, rasterizer, textures with sizes, RTs, shaders |
Resource Analysis (4)
| Tool | Description |
|---|---|
list_textures | All textures (filterable by format, min width) |
list_buffers | All buffers (filterable by min size) |
list_resources | All named resources (filterable by type, name pattern) |
get_resource_usage | Which events read/write a resource |
Data Extraction (8)
| Tool | Description |
|---|---|
save_texture | Export to PNG, JPG, BMP, TGA, HDR, EXR, or DDS |
get_buffer_data | Read buffer bytes (hex dump or float32 array) |
pick_pixel | RGBA value at a coordinate |
get_texture_stats | Per-channel min/max/avg with anomaly detection (NaN/Inf/negative); supports all_slices for cubemaps |
read_texture_pixels | Read a rectangular region of pixels (up to 64Γ64) with per-pixel anomaly flags |
export_draw_textures | Batch export all textures bound to a draw call (auto-names, skips placeholders) |
save_render_target | Save RT snapshot at an event (color + optional depth) |
export_mesh | Export mesh as OBJ with positions, normals, UVs from post-VS data |
Shader Analysis (3)
| Tool | Description |
|---|---|
disassemble_shader | Shader disassembly with auto fallback chain; supports search (keyword + context) and line_range |
get_shader_reflection | Input/output signatures, resource binding layout |
get_cbuffer_contents | Actual constant buffer variable values; supports filter for variable name substring |
Advanced (6)
| Tool | Description |
|---|---|
pixel_history | Full per-pixel modification history across all events |
get_post_vs_data | Post-transform vertex data (VS out / GS out) |
diff_draw_calls | Compare two draw calls β shows state differences with human-readable implications |
analyze_render_passes | Auto-detect render pass boundaries by Clear/RT switches, summarize each pass |
sample_pixel_region | Uniform-grid scan of an RT region β detects NaN/Inf/negative/overexposed hotspots |
debug_shader_at_pixel | Per-pixel shader debug β returns variable trace or pixel value + shader info as fallback |
Performance Analysis (4)
| Tool | Description |
|---|---|
get_pass_timing | Most expensive render passes β uses GPU counters if available, falls back to triangle-count heuristic |
analyze_overdraw | Overdraw estimate per render target group |
analyze_bandwidth | Write/read bandwidth estimate per render target |
analyze_state_changes | Finds redundant state-change patterns and batching opportunities |
Diagnostics (4)
| Tool | Description |
|---|---|
diagnose_negative_values | Scans all float RTs for negative/NaN/Inf β finds first event introducing them, detects TAA accumulation |
diagnose_precision_issues | Checks R11G11B10 sign-bit loss, shallow depth buffers, SRGB/linear mismatches |
diagnose_reflection_mismatch | Compares reflection passes against main scene draws β finds shader/blend/format causes |
diagnose_mobile_risks | Comprehensive check across precision / performance / compatibility / GPU-specific risk categories |
Prompts
Built-in prompt templates to guide AI through common workflows:
| Prompt | Description |
|---|---|
debug_draw_call | Deep-dive a single draw call: pipeline β shaders β cbuffers β outputs |
find_rendering_issue | Systematic diagnosis from a problem description |
analyze_performance | Frame-wide perf analysis: pass timing, overdraw, bandwidth, state changes |
How It Works
AI Assistant ββMCPββ renderdoc-mcp server ββPython APIββ renderdoc.pyd ββ GPU replay
The server uses RenderDoc's headless replay API (renderdoc.pyd) to:
- Open
.rdccapture files without the GUI - Replay frames and query pipeline state at any event
- Extract textures, buffers, shader data, and pixel history
- Return structured JSON for the AI to reason about
Development
# Install in dev mode
pip install -e .
# Run tests (no RenderDoc needed β uses mocks)
python -m pytest tests/ -v
# Project structure
src/renderdoc_mcp/
βββ server.py # FastMCP server, 3 prompt definitions
βββ session.py # Capture lifecycle, resource/texture caches (singleton)
βββ util.py # Serialization, enum maps, blend formula, module loader
βββ tools/
βββ session_tools.py # open/close/info (GPU quirks) + get_frame_overview
βββ event_tools.py # list/get/set/search actions + find_draws
βββ pipeline_tools.py # pipeline state, shader bindings, vertex inputs + get_draw_call_state
βββ resource_tools.py # texture/buffer/resource enumeration
βββ data_tools.py # save/read/pick/stats + read_texture_pixels + export_draw_textures, save_render_target, export_mesh
βββ shader_tools.py # disassembly (fallback chain, search), reflection, cbuffer contents (filter)
βββ advanced_tools.py # pixel history, post-VS data + diff_draw_calls (implications), analyze_render_passes, sample_pixel_region, debug_shader_at_pixel
βββ performance_tools.py # get_pass_timing, analyze_overdraw, analyze_bandwidth, analyze_state_changes
βββ diagnostic_tools.py # diagnose_negative_values, diagnose_precision_issues, diagnose_reflection_mismatch, diagnose_mobile_risks
License
MIT
