Skip to content
Back to search

renderdoc-skill

A Claude Code skill for GPU frame debugging with RenderDoc via rdc-cli

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/rudybear--renderdoc-skill/badge.svg)](/listings/rudybear--renderdoc-skill)

HTML

<a href="/listings/rudybear--renderdoc-skill"><img src="/api/listings/rudybear--renderdoc-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Clone this repo into your project

# Option A: Clone into your project directory
cd /path/to/your/project
git clone https://github.com/rudybear/renderdoc-skill .claude/skills/renderdoc-gpu-debug

# Option B: Clone standalone and copy the skill files
git clone https://github.com/rudybear/renderdoc-skill
cp -r renderdoc-skill/.claude/skills/renderdoc-gpu-debug /path/to/your/project/.claude/skills/

2. Install rdc-cli

pip install rdc-cli

3. Set up RenderDoc module path

Set `RENDERDOC_PYTHON_PATH` to the directory containing `renderdoc.pyd` and `renderdoc.dll`:

# In your shell profile (.bashrc, .zshrc, etc.)
export RENDERDOC_PYTHON_PATH=/path/to/renderdoc/module

If you installed RenderDoc from the official installer, this is typically: - **Windows**: `C:/Program Files/RenderDoc/` - **Linux**: `/usr/lib/renderdoc/` or wherever you built it

4. Register the Vulkan layer (Vulkan apps only)

For Vulkan capture, the RenderDoc implicit layer must be registered:

- **Windows**: Add `renderdoc.json` to `HKCU\SOFTWARE\Khronos\Vulkan\ImplicitLayers` (DWORD 0) - **Linux**: Copy `renderdoc.json` to `~/.local/share/vulkan/implicit_layer.d/`

Also set: `export ENABLE_VULKAN_RENDERDOC_CAPTURE=1`

5. Verify

rdc doctor

All checks should pass.

6. Customize CLAUDE.md

Edit the `CLAUDE.md` in this repo to fill in your project-specific paths (application executable, working directory, capture output directory). This tells Claude about your specific setup.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 200 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # renderdoc-skill
  2. A [Claude Code](https://docs.anthropic.com/en/docs/claude-code) skill that gives Claude the ability to capture, inspect, and debug GPU frames using [RenderDoc](https://renderdoc.org). Works with Vulkan, D3D11, D3D12, and OpenGL.
  3. ## Demo
  4. [![Watch the demo](https://img.youtube.com/vi/UkaXPtCWwo4/maxresdefault.jpg)](https://www.youtube.com/watch?v=UkaXPtCWwo4)
  5. ## What This Does
  6. This skill teaches Claude Code how to do GPU debugging. When you describe a rendering problem — broken shadows, wrong colors, missing objects, performance issues — Claude can:
  7. - **Capture GPU frames** from your application using RenderDoc's Python API
  8. - **Inspect pipeline state** at any draw call (shaders, blend, depth, rasterizer, bindings)
  9. - **Export and view render targets** as PNGs (Claude is multimodal — it can see your framebuffer)
  10. - **Debug shaders** line-by-line, tracing pixel/vertex/compute execution
  11. - **Trace pixel history** to find which draw wrote a color and why
  12. - **Edit and replay shaders** without recompiling your application
  13. - **Compare frames** side-by-side to find regressions
  14. It works through [`rdc-cli`](https://github.com/BANANASJIM/rdc-cli), a 66-command CLI that wraps RenderDoc's Python API into shell commands that Claude Code can call.
  15. ## Prerequisites
  16. | Requirement | Notes |
  17. |-------------|-------|
  18. | [RenderDoc](https://renderdoc.org) | Need `renderdoc.pyd` + `renderdoc.dll` (from RenderDoc install or built from source) |
  19. | Python 3.10+ | Must match the Python version `renderdoc.pyd` was built against |
  20. | [rdc-cli](https://github.com/BANANASJIM/rdc-cli) | `pip install rdc-cli` |
  21. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | Anthropic's CLI agent |
  22. ## Installation
  23. ### 1. Clone this repo into your project
  24. ```bash
  25. # Option A: Clone into your project directory
  26. cd /path/to/your/project
  27. git clone https://github.com/rudybear/renderdoc-skill .claude/skills/renderdoc-gpu-debug
  28. # Option B: Clone standalone and copy the skill files
  29. git clone https://github.com/rudybear/renderdoc-skill
  30. cp -r renderdoc-skill/.claude/skills/renderdoc-gpu-debug /path/to/your/project/.claude/skills/
  31. ```
  32. ### 2. Install rdc-cli
  33. ```bash
  34. pip install rdc-cli
  35. ```
  36. ### 3. Set up RenderDoc module path
  37. Set `RENDERDOC_PYTHON_PATH` to the directory containing `renderdoc.pyd` and `renderdoc.dll`:
  38. ```bash
  39. # In your shell profile (.bashrc, .zshrc, etc.)
  40. export RENDERDOC_PYTHON_PATH=/path/to/renderdoc/module
  41. ```
  42. If you installed RenderDoc from the official installer, this is typically:
  43. - **Windows**: `C:/Program Files/RenderDoc/`
  44. - **Linux**: `/usr/lib/renderdoc/` or wherever you built it
  45. ### 4. Register the Vulkan layer (Vulkan apps only)
  46. For Vulkan capture, the RenderDoc implicit layer must be registered:
  47. - **Windows**: Add `renderdoc.json` to `HKCU\SOFTWARE\Khronos\Vulkan\ImplicitLayers` (DWORD 0)
  48. - **Linux**: Copy `renderdoc.json` to `~/.local/share/vulkan/implicit_layer.d/`
  49. Also set: `export ENABLE_VULKAN_RENDERDOC_CAPTURE=1`
  50. ### 5. Verify
  51. ```bash
  52. rdc doctor
  53. ```
  54. All checks should pass.
  55. ### 6. Customize CLAUDE.md
  56. Edit the `CLAUDE.md` in this repo to fill in your project-specific paths (application executable, working directory, capture output directory). This tells Claude about your specific setup.
  57. ## MCP Server (Alternative Installation)
  58. Instead of (or in addition to) the skill, you can use the MCP server. This registers rdc-cli as native Claude Code tools that appear in `/mcp`.
  59. ### 1. Install the MCP dependency
  60. ```bash
  61. pip install -r requirements-mcp.txt
  62. ```
  63. ### 2. Register with Claude Code
  64. ```bash
  65. claude mcp add rdc-tools -- python D:/renderdoc/mcp_server/server.py
  66. ```
  67. ### 3. Verify
  68. In Claude Code, run `/mcp` — you should see `rdc-tools` listed with 13 tools, 2 resources, and 6 prompts.
  69. ### Available tools
  70. | Tool | Commands | Purpose |
  71. |------|----------|---------|
  72. | `rdc_session` | open, close, status | Session lifecycle |
  73. | `rdc_overview` | info, stats, passes, count, gpus | First-look after opening |
  74. | `rdc_draws` | draws, draw | Draw call navigation |
  75. | `rdc_events` | events, event | API event listing |
  76. | `rdc_pipeline` | pipeline, bindings | Pipeline state inspection |
  77. | `rdc_shader` | shader, shaders, search, shader-map | Shader inspection |
  78. | `rdc_export` | rt, texture, thumbnail, mesh, buffer | Visual export (inline image + path) |
  79. | `rdc_pixel` | pixel, pick-pixel, debug pixel/vertex/thread | Pixel debugging |
  80. | `rdc_diff` | diff | Frame comparison |
  81. | `rdc_resources` | resources, resource, usage, tex-stats | Resource inspection |
  82. | `rdc_shader_edit` | shader-build/replace/restore/encodings | Edit-replay |
  83. | `rdc_capture` | capture, attach, trigger, list, copy | Frame capture |
  84. | `rdc_vfs` | ls, tree, cat | Virtual filesystem |
  85. | `rdc_command` | any rdc command | Generic fallback |
  86. ## How It Works
  87. ### Skill trigger
  88. Claude Code loads skills based on YAML frontmatter keywords. When you mention GPU debugging, RenderDoc, shaders, render targets, pipeline state, or visual glitches, Claude activates this skill and gains access to the full `rdc-cli` command vocabulary.
  89. ### Session lifecycle
  90. Every inspection session follows open-work-close:
  91. ```bash
  92. rdc open path/to/capture.rdc # Load a capture
  93. # ... inspection commands ...
  94. rdc close # Release GPU resources
  95. ```
  96. ### Visual inspection pattern
  97. Claude can see images. The core debugging loop is:
  98. 1. **Export** a render target or texture to PNG (`rdc rt EID -o output.png`)
  99. 2. **View** it using Claude Code's Read tool (multimodal — Claude sees the image)
  100. 3. **Correlate** with pipeline state data (`rdc pipeline`, `rdc shader`, `rdc bindings`)
  101. 4. **Diagnose** the issue and suggest fixes
  102. ### Included debugging recipes
  103. The skill includes 6 ready-made debugging workflows:
  104. 1. **Object is invisible** — culling, depth, blend, vertex transform checks
  105. 2. **Colors are wrong** — texture bindings, constants, blend state, shader trace
  106. 3. **Shadows are broken** — shadow map export, depth bias, light matrices, PCF
  107. 4. **Performance is bad** — draw counts, resource sizes, overdraw, GPU counters
  108. 5. **What changed between frames** — frame diff with visual comparison
  109. 6. **Debug this pixel** — pixel history, shader trace, variable inspection
  110. ## File Structure
  111. ```
  112. .claude/skills/renderdoc-gpu-debug/
  113. SKILL.md # Main skill (loaded by Claude Code)
  114. references/
  115. commands-quick-ref.md # All 66 rdc-cli commands with args/options
  116. debugging-recipes.md # 6 extended debugging workflows
  117. CLAUDE.md # Project context (customize for your app)
  118. capture_frame.py # Example: capture a frame via RenderDoc Python API
  119. ```
  120. ## Example Usage
  121. Once installed, just talk to Claude Code naturally:
  122. ```
  123. > The shadows in my scene look blocky and have acne artifacts. Can you debug it?
  124. > Capture a frame and show me what the shadow map looks like.
  125. > Why is the sphere rendering black? It should be red.
  126. > Compare these two captures and tell me what changed.
  127. > Debug pixel (256, 300) — why is it transparent?
  128. ```
  129. Claude will use `rdc-cli` commands, export PNGs to inspect visually, check pipeline state, and trace shader execution to diagnose the issue.
  130. ## Acknowledgments
  131. - **[rdc-cli](https://github.com/BANANASJIM/rdc-cli)** by Jim (BANANASJIM) — the 66-command CLI that makes this skill possible. MIT license.
  132. - **[RenderDoc](https://renderdoc.org)** by Baldur Karlsson — the GPU debugger that powers everything underneath. MIT license.
  133. - **[Claude Code](https://docs.anthropic.com/en/docs/claude-code)** by Anthropic — the AI coding agent that runs the skill.
  134. ## License
  135. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.