Skip to main content
affpapa.org
RU EN
skill CX Codex

cli-anything-renderdoc — Claude Code skill: RenderDoc CLI

A skill that lets your agent inspect RenderDoc frame captures from the terminal: draw call tree, pipeline state, textures and buffers inside .rdc files.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓ 
npx skills add HKUDS/CLI-Anything --skill cli-anything-renderdoc -a claude-code
Open on GitHub

What cli-anything-renderdoc does

This skill hands the agent a command-line harness for RenderDoc captures (.rdc). It reads capture metadata, lists the action tree and filters it to draw calls only, searches actions by marker name, dumps pipeline state at a given event, picks pixels from textures, decodes constant buffers, shows vertex shader inputs and outputs, and pulls GPU counters. Every command takes --json when the agent needs parseable output.

Groups are split by job: capture, actions, textures, pipeline, resources, mesh, counters. pipeline shader-export returns a shader you can read: for DXBC and SPIR-V it writes the embedded HLSL or GLSL, and falls back to disassembly when there is no source. pipeline diff compares two events, including events across captures via -b. The preview mode builds a bundle with output-target images and pipeline_state.json.

One thing to check before installing: PYTHONPATH has to include your RenderDoc installation, since the harness runs on RenderDoc's Python bindings. Miss that and nothing loads. It also wants click>=8.0 and prompt-toolkit>=3.0, while the CLI itself comes from pip install cli-anything-renderdoc. Note that pipeline state needs an event ID, so run actions list first.

What it helps with

  • find a single draw call by marker name in a large capture
  • get a readable shader out of a DXBC or SPIR-V blob
  • diff pipeline state between two events
  • save a captured texture as EXR or DDS
  • read a constant buffer as float32

Example prompts for the agent

  • Open frame.rdc, summarize the actions, then list draw calls with Shadow in the name.
  • Export the fragment shader from event 42 into ./shaders/ and dump the constant buffer at index 0.
  • Compare pipeline state at events 100 and 200 and tell me what changed.

How to install cli-anything-renderdoc

1Skills CLI (Vercel)

npx skills add HKUDS/CLI-Anything --skill cli-anything-renderdoc -a claude-code

2Manually: put the files in place

~/.claude/skills/cli-anything-renderdoc/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cli-anything-renderdoc/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about cli-anything-renderdoc

How do I install cli-anything-renderdoc in Claude Code?

Run npx skills add HKUDS/CLI-Anything --skill cli-anything-renderdoc -a claude-code. The skill file lands at ~/.claude/skills/cli-anything-renderdoc/SKILL.md.

What does cli-anything-renderdoc do?

It analyzes RenderDoc captures from the command line: action tree, pipeline state at a chosen event, textures, buffers, shaders and GPU counters. The agent works with a capture without opening the GUI.

What do I need for it to work?

Python bindings from an installed RenderDoc, with that path on PYTHONPATH. It also needs click>=8.0 and prompt-toolkit>=3.0, otherwise the CLI will not start.

Source text

SKILL.md · Apache-2.0 
---
name: "cli-anything-renderdoc"
description: CLI harness for RenderDoc graphics debugger capture analysis
version: 0.1.0
command: cli-anything-renderdoc
install: pip install cli-anything-renderdoc
requires:
  - renderdoc (Python bindings from RenderDoc installation)
  - click>=8.0
  - prompt-toolkit>=3.0
categories:
  - graphics
  - debugging
  - gpu
  - rendering
---

# RenderDoc CLI Skill

Headless command-line analysis of RenderDoc GPU frame captures (`.rdc` files).

## Capabilities

- **Capture inspection**: metadata, sections, thumbnails, format conversion
- **Action tree**: list/search/filter draw calls, clears, dispatches, markers
- **Texture operations**: list, inspect, export (PNG/JPG/DDS/HDR/EXR), pixel picking
- **Pipeline state**: full shader/RT/viewport state at any event
- **Shader analysis**: export shader in human-readable form (HLSL/GLSL/disasm), constant buffer readback
- **Resource inspection**: buffer/texture enumeration, raw data reading
- **Mesh data**: vertex shader input/output decoding
- **GPU counters**: enumerate and fetch hardware performance counters

## Command Groups

### capture
```bash
cli-anything-renderdoc -c frame.rdc capture info          # Metadata + sections
cli-anything-renderdoc -c frame.rdc capture thumb -o t.png # Extract thumbnail
cli-anything-renderdoc -c frame.rdc capture convert -o out.rdc --format rdc
```

### actions
```bash
cli-anything-renderdoc -c frame.rdc actions list           # All actions
cli-anything-renderdoc -c frame.rdc actions list --draws-only  # Draw calls only
cli-anything-renderdoc -c frame.rdc actions summary        # Counts by type
cli-anything-renderdoc -c frame.rdc actions find "Shadow"  # Search by name
cli-anything-renderdoc -c frame.rdc actions get 42         # Single action
```

### textures
```bash
cli-anything-renderdoc -c frame.rdc textures list
cli-anything-renderdoc -c frame.rdc textures get <id>
cli-anything-renderdoc -c frame.rdc textures save <id> -o out.png --format png
cli-anything-renderdoc -c frame.rdc textures save-outputs 42 -o ./renders/
cli-anything-renderdoc -c frame.rdc textures pick <id> 100 200
```

### pipeline
```bash
cli-anything-renderdoc -c frame.rdc pipeline state 42

# Export shader in human-readable form
# Text shaders (GLSL/HLSL) → saved directly
# Binary shaders (DXBC/SPIR-V) → embedded source (HLSL/GLSL) or disassembly
cli-anything-renderdoc -c frame.rdc pipeline shader-export 42 --stage Fragment
cli-anything-renderdoc -c frame.rdc pipeline shader-export 42 --stage Vertex -o ./shaders/

cli-anything-renderdoc -c frame.rdc pipeline cbuffer 42 --stage Vertex --index 0

# Compare pipeline state between two events
# Default output: same directory as the capture file  ;  use -o to override
cli-anything-renderdoc -c a.rdc pipeline diff 100 200 -b b.rdc
cli-anything-renderdoc -c frame.rdc pipeline diff 100 200              # same capture
cli-anything-renderdoc -c a.rdc pipeline diff 100 200 -b b.rdc -o result.json
cli-anything-renderdoc -c a.rdc pipeline diff 100 200 -b b.rdc --no-compact
```

### resources
```bash
cli-anything-renderdoc -c frame.rdc resources list
cli-anything-renderdoc -c frame.rdc resources buffers
cli-anything-renderdoc -c frame.rdc resources read-buffer <id> --format float32
```

### mesh
```bash
cli-anything-renderdoc -c frame.rdc mesh inputs 42 --max-vertices 10
cli-anything-renderdoc -c frame.rdc mesh outputs 42
```

### counters
```bash
cli-anything-renderdoc -c frame.rdc counters list
cli-anything-renderdoc -c frame.rdc counters fetch --ids 1,2,3
```

## Preview Bundles

RenderDoc preview support is for truthful capture inspection rather than live
creative preview.

```bash
# List preview recipes
cli-anything-renderdoc -c frame.rdc --json preview recipes

# Capture a preview bundle for the active capture or a specific event
cli-anything-renderdoc -c frame.rdc --json preview capture --recipe quick --event-id 42

# Capture a diff preview bundle for two events or captures
cli-anything-renderdoc -c frame.rdc --json preview diff 100 200
cli-anything-renderdoc -c a.rdc --json preview diff 100 200 --capture-b b.rdc

# Return the latest existing bundle for the capture
cli-anything-renderdoc -c frame.rdc --json preview latest --recipe quick
```

Typical preview bundle contents:

- capture thumbnail
- output-target images
- `pipeline_state.json`
- `action_summary.json`

Diff bundles additionally include:

- A/B thumbnails
- A/B output-target images
- `pipeline_diff.json`

RenderDoc does not currently expose live preview sessions. Instead, each
capture/diff bundle appends to a stable recipe-level `trajectory.json`.

Viewer commands:

```bash
cli-hub previews inspect /path/to/bundle
cli-hub previews html /path/to/bundle -o page.html
cli-hub previews open /path/to/bundle
```

## JSON Mode

All commands support `--json` for machine-readable output:
```bash
cli-anything-renderdoc -c frame.rdc --json actions summary
```

## Environment Variables

| Variable              | Description                  |
|----------------------|------------------------------|
| `RENDERDOC_CAPTURE`  | Default capture file path   |
| `PYTHONPATH`         | Must include RenderDoc path |

## Agent Usage Notes

- **Use `pipeline shader-export` to extract shaders** — for binary shaders (DXBC/SPIR-V) it auto-exports embedded HLSL/GLSL source or falls back to disassembly; for text shaders (GLSL/HLSL) it saves the raw source directly
- **Shader formats by capture API**:
  - D3D11 → DXBC binary, exported as embedded HLSL source (`.hlsl`) or bytecode asm (`.dxbc.asm`)
  - OpenGL/GLES → GLSL source text (`.glsl`), already human-readable
  - Vulkan → SPIR-V binary, exported as embedded GLSL source (`.glsl`) or SPIR-V asm (`.spv.asm`)
- **Use `pipeline diff` to compare two events** — it writes a JSON file and prints only the path; use `-b` for a second capture
- Always specify `--json` for programmatic consumption
- Use `actions summary` first to understand capture complexity
- Use `actions list --draws-only` to focus on actual rendering
- Use `preview capture` or `preview diff` when the agent needs a portable,
  honest inspection bundle rather than raw replay calls alone
- Read `_trajectory_path` from preview JSON if you need persistent capture/diff history
- Use `cli-hub previews ...` only to inspect/open already-generated bundles
- Pipeline state requires an event ID from the action list
- Texture save supports: png, jpg, bmp, tga, hdr, exr, dds
- Buffer data can be decoded as hex, float32, uint32, or raw bytes

© HKUDS · Apache-2.0 · HKUDS/CLI-Anything

Similar skills

Everything for Game dev and 3D: Unity, Unreal, Godot, Blender →
shader-programming gamedev-skills A skill that teaches the parts of shader work that carry between engines, then builds tint, dissolve, outline and fresnel effects on top of them. CX Codex +1 6,900installs shader-dev MiniMax-AI GLSL reference skill covering 36 real-time shader techniques for ShaderToy and WebGL2. Helpful for ray marching, SDF scenes, fluids, and visual effects. CX Codex +1 2,500installs glsl martinholovsky A GLSL skill for holographic HUD effects: scanline panels, energy fields, post-processing. Useful when you write WebGL shaders and want to hold 60 FPS. CX Codex +1 369installs axiom-graphics CharlesWiltgen A router skill for GPU work: Metal migration, shader conversion, RealityKit, USD/USDZ files and display frame rate. CX Codex +1 1,200installs webgl martinholovsky A WebGL skill for custom shaders and visual effects: holograms, post-processing, particle systems. Useful when you're building a 3D interface. CX Codex +1 555installs metal-shader-expert curiositech Gives your agent Metal shader expertise for Apple GPUs: MSL, PBR, tile-based deferred rendering, ray tracing. Useful when graphics performance on Apple Silicon becomes the bottleneck. CX Codex +1 512installs

From the same set55

cli-anything-dify-workflow A skill that hands the agent commands for building, checking and editing Dify workflow YAML. Useful when a hand-written workflow breaks on import. CX Codex +1 493installs cli-anything-pm2 A skill that brings PM2 CLI into Claude Code for managing Node.js processes. Start, stop, restart applications and tail logs directly from the editor. CX Codex +1 491installs cli-anything-exa Connects the Exa neural search engine to your agent for deep web searches and page retrieval. Useful for gathering research papers, news, and company intelligence. CX Codex +1 491installs cli-anything-safari Controls real Safari on macOS via a Python Click CLI wrapping the safari-mcp server. Useful for running browser automations while preserving existing logins. CX Codex +1 483installs cli-anything-cloudcompare CLI harness for CloudCompare point cloud and mesh processing across 41 commands. Automates subsampling, normal computation, SOR filtering, and conversions for AI agents. CX Codex +1 478installs cli-anything-anygen Provides a CLI wrapper around the AnyGen OpenAPI to build slides and diagrams. Useful when automating document workflows in AI agents. CX Codex +1 471installs cli-anything-slay-the-spire-ii Ships a CLI that drives the real Slay the Spire 2 through a local bridge mod, so the agent can read game state and issue moves. CX Codex +1 472installs cli-anything-wiremock A skill that hands your agent a terminal wrapper over the WireMock Admin API: stubs, request counts, scenario states. CX Codex +1 469installs

Project sponsors

Companies that keep this analytics open
Gold sponsor
Nutra.Club

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor