Skip to content
Back to search

webgpu-inspector-plugins

MarketplaceWorks with Claude CodeGitHub

Inspection debugger for WebGPU

Safety scan

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

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/brendan-duncan/webgpu_inspector with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/brendan-duncan/webgpu_inspector'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/brendan-duncan--webgpu-inspector/badge.svg)](/listings/brendan-duncan--webgpu-inspector)

HTML

<a href="/listings/brendan-duncan--webgpu-inspector"><img src="/api/listings/brendan-duncan--webgpu-inspector/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

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

[Back to top](#webgpu-inspector)

Chrome Web Store

Install WebGPU Inspector from the [Chrome Web Store](https://chromewebstore.google.com/detail/webgpu-inspector/holcbbnljhkpkjkhgkagjkhhpeochfal).

Firefox Add-Ons Store

Install WebGPU Inspector from the [Firefox Add-Ons Store](https://addons.mozilla.org/en-US/firefox/addon/webgpu-inspector).

Manual Injection

[Back to top](#webgpu-inspector)

If the WebGPU Inspector's automatic injection isn't working to inspect the page (workers inside of iframes cause trouble), you can include `webgpu_inspector.js` directly in a page.

Add the script tag to your page **before** any code that uses WebGPU, so the inspector can patch the WebGPU API before it's used:

<script src="https://cdn.jsdelivr.net/gh/brendan-duncan/webgpu_inspector@main/extensions/chrome/webgpu_inspector.js"></script>

To pin to a specific release instead of tracking `main`, replace `@main` with a version tag (e.g. `@1.2.0`).

When loaded this way, the script wraps the page's WebGPU API and exposes the inspector instance as `webgpuInspector` on the global (`window.webgpuInspector` in a page, `self.webgpuInspector` in a worker).

Once the inspector is loaded, you have two ways to view what it records:

1. Open the WebGPU Inspector DevTools panel from the browser extension. The DevTools panel must be open when the page is loaded (refreshing the page may be necessary) in order to receive all of the WebGPU data from the beginning of the page's execution. 2. Drive capture from the page itself with the **Local Capture API** — no DevTools panel required.

See the **[Manual Injection guide](docs/manual_injection.md)** for the page-side Local Capture API, loading the script from JavaScript / TypeScript, Web Worker setup, and TypeScript type declarations.

Building From Source

[Back to top](#webgpu-inspector)

To get the most up to date version of WebGPU Inspector, you can install the extension from source.

- Download project from Github. - git clone https://github.com/brendan-duncan/webgpu_inspector

Chrome and Firefox don't support the same version of extension plug-ins, so you'll need to load the correct version.

Chrome

- Open **chrome://extensions** - Enable Developer Mode (switch in top-right corner) - Press **Load Unpacked** button - Browse to **<webgpu_inspector directory>/extensions/chrome** and press **Select Folder**

Edge

- Open **edge://extensions** - Enable Developer Mode (switch on left side of page) - Press **Load Unpacked** button - Browse to **<webgpu_inspector directory>/extensions/chrome** and press **Select Folder**

Firefox Nightly

- [Firefox Nightly](https://www.mozilla.org/en-US/firefox/channel/desktop/) has work-in-progress WebGPU support, which you can enable from **Settings / Nightly Experiments / Web API: WebGPU** - Open **about:debugging** - Select **This Nightly** from the left side of the page, depending on which version of Firefox you're using. - Only **Firefox Nightly** has WebGPU support, currently. - Press **Load Temporary Add-On**. - Browse to **<webgpu_inspector directory>/extensions/firefox**, select **manifest.json** and press **Open**. - **Temporary Add-Ons will need to be re-loaded every time you start Firefox.**

Safari Technology Preview

- **Note**: - Safari support is still a work-in-progress and has issues - [Safari Technology Preview](https://developer.apple.com/safari/technology-preview/) has WebGPU support, which you can enable from **Develop / Feature Flags... / WebGPU**. - Safari Extension development is done through Xcode - Open **<webgpu_inspector directory>/extensions/safari/WebGPU_Inspector.xcodeproj** with Xcode - Switch the Scheme to **WebGPU Inspector (macOS)** - Select **Product / Run** - From Safari Technology Preview - Select **Develop / Developer Settings...** - Enable **Allow unsigned extensions**

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.

.claude-plugin/marketplace.json · Manifest · 14 lines

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

  1. {
  2. "name": "webgpu-inspector-plugins",
  3. "owner": {
  4. "name": "Brendan Duncan",
  5. "url": "https://github.com/brendan-duncan/webgpu_inspector"
  6. },
  7. "plugins": [
  8. {
  9. "name": "webgpu-inspector",
  10. "source": "./claude-plugin",
  11. "description": "Capture and analyze WebGPU frames from a live page with Claude."
  12. }
  13. ]
  14. }
README.md · README · 243 lines

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

  1. # WebGPU Inspector
  2. [Inspect](docs/inspect.md) . [Capture](docs/capture.md) . [Record](docs/record.md) . [Shader Debugger](docs/shader_debugger.md) . [Shader Flame Graph](docs/shader_flame_graph.md)
  3. * [Introduction](#introduction)
  4. * [Developer Tools Window](#developer-tools-window)
  5. * [Extension Problem Solving](#extension-problem-solving)
  6. * [Installation](#installation)
  7. * [Chrome Web Store](#chrome-web-store)
  8. * [Firefox Add-Ons Store](#firefox-add-ons-store)
  9. * [Manual Injection](#manual-injection)
  10. * [Building From Source](#building-from-source)
  11. * [Chrome](#chrome)
  12. * [Edge](#edge)
  13. * [Firefox](#firefox-nightly)
  14. * [Safari](#safari-technology-preview)
  15. * [Claude Code Integration](#claude-code-integration)
  16. * [Install the Plugin](#install-the-plugin)
  17. * [Update the Plugin](#update-the-plugin)
  18. * [Automatic Updates](#automatic-updates)
  19. * [Development](#development)
  20. * [External Dependencies](#external-dependencies)
  21. ## Introduction
  22. Inspection, profiling, and graphics debugging browser extension for WebGPU.
  23. WebGPU Inspector is designed to inspect what's happening with WebGPU on the page, independent of the engine.
  24. WebGPU Inspector includes three tools:
  25. * **[Inspect](docs/inspect.md)** — a live view of every GPU object on the page. Inspect their details, plot frame times (with CPU submit and GPU time), detect dropped frames and whether the frame is CPU- or GPU-bound, plot object allocations over time, inspect textures, and [edit](docs/inspect.md#editing-shaders) shaders live on the page.
  26. * **[Capture](docs/capture.md)** — records the GPU commands used to render a frame, with render pass output images, textures, buffer data, and render state, letting you inspect details about each command, including the storage and uniform buffers used for draw and dispatch calls. Includes the ability to interactively [debug shaders](docs/shader_debugger.md).
  27. * **[Record](docs/record.md)** — records all GPU commands and data used to render a set of frames, generating a self-contained HTML or binary file that can play back the render or be used for bug reports.
  28. <a href="docs/images/webgpu_inspector_screen.png">
  29. <img src="docs/images/webgpu_inspector_screen.png" style="width: 512px; border-radius: 10px; box-shadow: 3px 3px 10px rgba(0,0,0,0.5);">
  30. </a>
  31. ### Developer Tools Window
  32. Select __More Tools / Developer Tools__, or press __F12__ or __Shift+CTRL+J__ (__Option + ⌘ + J__ on MacOS). You can also right-click on the page and select __Inspect__. When the WebGPU Inspector extension is enabled in the extension manager, there will be a **WebGPU Inspector** tab.
  33. ![WebGPU Inspector Panel](docs/images/webgpu_inspector_panel.png)
  34. ### Extension Problem Solving
  35. ##### [Back to top](#webgpu-inspector)
  36. #### WebGPU Inspector panel missing from Developer Tools
  37. If the WebGPU Inspector tab is not present on the Developer Tools panel, try closing the Developer Tools window and opening it again. Sometimes the browser doesn't load the extension.
  38. #### Inspect Start, Capture, or Record does not work
  39. Sometimes the browser extension script does not get injected into the page properly. Refresh the page and WebGPU Inspector should start working.
  40. #### Inspect is running but Capture does not work
  41. Some pages will not update if they do not have focus. If Capture is not recording anything, try selecting the page to make sure it has focus.
  42. ## Installation
  43. ##### [Back to top](#webgpu-inspector)
  44. ### Chrome Web Store
  45. Install WebGPU Inspector from the [Chrome Web Store](https://chromewebstore.google.com/detail/webgpu-inspector/holcbbnljhkpkjkhgkagjkhhpeochfal).
  46. ### Firefox Add-Ons Store
  47. Install WebGPU Inspector from the [Firefox Add-Ons Store](https://addons.mozilla.org/en-US/firefox/addon/webgpu-inspector).
  48. ### Manual Injection
  49. ##### [Back to top](#webgpu-inspector)
  50. If the WebGPU Inspector's automatic injection isn't working to inspect the page (workers inside of iframes cause trouble), you can include `webgpu_inspector.js` directly in a page.
  51. Add the script tag to your page **before** any code that uses WebGPU, so the inspector can patch the WebGPU API before it's used:
  52. ```html
  53. <script src="https://cdn.jsdelivr.net/gh/brendan-duncan/webgpu_inspector@main/extensions/chrome/webgpu_inspector.js"></script>
  54. ```
  55. To pin to a specific release instead of tracking `main`, replace `@main` with a version tag (e.g. `@1.2.0`).
  56. When loaded this way, the script wraps the page's WebGPU API and exposes the inspector instance as `webgpuInspector` on the global (`window.webgpuInspector` in a page, `self.webgpuInspector` in a worker).
  57. Once the inspector is loaded, you have two ways to view what it records:
  58. 1. Open the WebGPU Inspector DevTools panel from the browser extension. The DevTools panel must be open when the page is loaded (refreshing the page may be necessary) in order to receive all of the WebGPU data from the beginning of the page's execution.
  59. 2. Drive capture from the page itself with the **Local Capture API** — no DevTools panel required.
  60. See the **[Manual Injection guide](docs/manual_injection.md)** for the page-side Local Capture API, loading the script from JavaScript / TypeScript, Web Worker setup, and TypeScript type declarations.
  61. ### Building From Source
  62. ##### [Back to top](#webgpu-inspector)
  63. To get the most up to date version of WebGPU Inspector, you can install the extension from source.
  64. - Download project from Github.
  65. - git clone https://github.com/brendan-duncan/webgpu_inspector
  66. Chrome and Firefox don't support the same version of extension plug-ins, so you'll need to load the correct version.
  67. #### Chrome
  68. - Open **chrome://extensions**
  69. - Enable Developer Mode (switch in top-right corner)
  70. - Press **Load Unpacked** button
  71. - Browse to **<webgpu_inspector directory>/extensions/chrome** and press **Select Folder**
  72. #### Edge
  73. - Open **edge://extensions**
  74. - Enable Developer Mode (switch on left side of page)
  75. - Press **Load Unpacked** button
  76. - Browse to **<webgpu_inspector directory>/extensions/chrome** and press **Select Folder**
  77. #### Firefox Nightly
  78. - [Firefox Nightly](https://www.mozilla.org/en-US/firefox/channel/desktop/) has work-in-progress WebGPU support, which you can enable from **Settings / Nightly Experiments / Web API: WebGPU**
  79. - Open **about:debugging**
  80. - Select **This Nightly** from the left side of the page, depending on which version of Firefox you're using.
  81. - Only **Firefox Nightly** has WebGPU support, currently.
  82. - Press **Load Temporary Add-On**.
  83. - Browse to **<webgpu_inspector directory>/extensions/firefox**, select **manifest.json** and press **Open**.
  84. - **Temporary Add-Ons will need to be re-loaded every time you start Firefox.**
  85. #### Safari Technology Preview
  86. - **Note**:
  87. - Safari support is still a work-in-progress and has issues
  88. - [Safari Technology Preview](https://developer.apple.com/safari/technology-preview/) has WebGPU support, which you can enable from **Develop / Feature Flags... / WebGPU**.
  89. - Safari Extension development is done through Xcode
  90. - Open **<webgpu_inspector directory>/extensions/safari/WebGPU_Inspector.xcodeproj** with Xcode
  91. - Switch the Scheme to **WebGPU Inspector (macOS)**
  92. - Select **Product / Run**
  93. - From Safari Technology Preview
  94. - Select **Develop / Developer Settings...**
  95. - Enable **Allow unsigned extensions**
  96. - Select the **Extensions** tab in Settings, and make sure WebGPU Inspector is listed as an extension
  97. - WebGPU Inspector should be a tab in the Web Inspector window (**Develop / Show Web Inspector** or right-click on page and select **Inspect element**)
  98. - If you make changes to the WebGPU Inspector source
  99. - From Xcode, select **Product / Build** (**cmd-b**)
  100. ## Claude Code Integration
  101. ##### [Back to top](#webgpu-inspector)
  102. WebGPU Inspector can be integrated with [Claude Code](https://claude.com/claude-code) as a plugin that brings WebGPU frame capture and analysis into a conversation with Claude.
  103. Claude can launch (or attach to) a browser, instrument any page — with no
  104. browser extension and no changes to the page being analyzed — capture one or
  105. more frames, and then analyze the result: command and draw-call counts, the GPU
  106. object graph, shaders, validation errors, and common performance problems. It
  107. builds on the [Local Capture API](docs/manual_injection.md#local-capture-api) and produces the same
  108. capture files the DevTools Capture panel reads.
  109. The plugin lives in [claude-plugin/](claude-plugin/) — see
  110. [claude-plugin/README.md](claude-plugin/README.md) for full usage, the MCP tool
  111. list, and configuration. It installs straight from this repository, which
  112. doubles as a Claude Code plugin marketplace; the bridge server's dependencies
  113. are vendored, so there is no `npm install` step. Requires Node.js 18+ and a
  114. local Chrome or Edge install.
  115. ### Install the Plugin
  116. From any terminal, add this repo as a marketplace and install the plugin:
  117. ```sh
  118. claude plugin marketplace add brendan-duncan/webgpu_inspector
  119. claude plugin install webgpu-inspector@webgpu-inspector-plugins
  120. ```
  121. `webgpu-inspector` is the plugin name; `webgpu-inspector-plugins` is the
  122. marketplace name. The same steps work from inside Claude Code with
  123. `/plugin marketplace add brendan-duncan/webgpu_inspector` then
  124. `/plugin install webgpu-inspector@webgpu-inspector-plugins` (terminal CLI), or
  125. the `/plugins` dialog in the VS Code / JetBrains extension. Claude Code starts
  126. the bundled MCP server automatically once the plugin is enabled.
  127. ### Update the Plugin
  128. Updates are **not** automatic by default. When a new version is released, pull
  129. it in two steps — refresh the marketplace catalog, then update the plugin:
  130. ```sh
  131. claude plugin marketplace update webgpu-inspector-plugins
  132. claude plugin update webgpu-inspector@webgpu-inspector-plugins
  133. ```
  134. Then run `/reload-plugins` (or restart) to load it. Check your installed
  135. version with `claude plugin list`.
  136. #### Automatic Updates
  137. Auto-update is disabled by default for third-party marketplaces like this one.
  138. The easiest way to enable it: open `/plugin` (terminal CLI) or `/plugins`
  139. (VS Code / JetBrains extension), go to the **Marketplaces** tab, select
  140. `webgpu-inspector-plugins`, and choose **Enable auto-update**.
  141. Alternatively, enable it in `~/.claude/settings.json` by declaring the
  142. marketplace under `extraKnownMarketplaces` with `"autoUpdate": true`:
  143. ```json
  144. "extraKnownMarketplaces": {
  145. "webgpu-inspector-plugins": {
  146. "source": {
  147. "source": "github",
  148. "repo": "brendan-duncan/webgpu_inspector"
  149. },
  150. "autoUpdate": true
  151. }
  152. }
  153. ```
  154. ## Development
  155. ##### [Back to top](#webgpu-inspector)
  156. Building the project requires an installation of [Node.js](https://nodejs.org/en/).
  157. - Make sure the dependencies are installed: `npm install`
  158. - Compile the project: `npm run build`.
  159. - Compile on file changes: `npm run watch`.
  160. Update the plugin version from rollup.config.js.
  161. After the project is built:
  162. - If you have the DevTools open, right-click on the WebGPU Inspector DevTools panel, select `Reload frame`.
  163. - Some changes require a full reload. Open **chrome://extensions**, press the refresh button for the WebGPU Inspector extension. With DevTools open for the page, right-click on the refresh button for the page and select "Empty Cache and Hard Reload". Then right-click on the WebGPU Inspector DevTools panel and select "Reload frame". This will make sure Chrome's cache has been fully cleared.
  164. **Notes**
  165. - Sometimes the terser minimizer can make source map debugging problematic. To simplify debugging, edit **rollup.config.js** and comment out the terser entry in plugins.
  166. ## External Dependencies
  167. ##### [Back to top](#webgpu-inspector)
  168. * [WGSL Reflect](https://github.com/brendan-duncan/wgsl_reflect)
  169. * Used for parsing and getting reflection information from WGSL shaders.
  170. * [WebGPU Recorder](https://github.com/brendan-duncan/webgpu_recorder)
  171. * Used for generating recordings of WebGPU content.

Ratings and comments

Sign in to rate this skill.

Sign in

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