home / mcp / shaderc-vkrunner mcp server
Provides a self-contained local Vulkan shader sandbox with compile, run, and visualize capabilities via MCP.
Configuration
View docs{
"mcpServers": {
"mehmetoguzderin-shaderc-vkrunner-mcp": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"-v",
"${workspaceFolder}:/work",
"shaderc-vkrunner-mcp",
"--work-dir",
"/work"
]
}
}
}You can safely develop, compile, optimize, and visualize Vulkan shaders locally with the shaderc-vkrunner-mcp server. It runs entirely on your machine in a contained environment, enabling AI agents to work with shader code without risking your hardware or driver stability.
Connect to the server from an MCP client to start compiling, running, and visualizing shaders inside a CPU-based sandbox. The server exposes a simple, local interface that your client can invoke to perform shader-related tasks. When you start the server via its local runtime, you work entirely within a containerized environment, which keeps shader execution isolated and safe.
To use it with a VS Code Copilot setup, configure the MCP client to run the container and bind your workspace so you can work with shader files directly. You reference the connection profile in your client so Copilot can issue shader-related commands against the server.
For debugging or quick checks, you can start the MCP inspector to connect to the same server instance and inspect shader behavior in a lightweight, interactive way.
run --rm -i -v ${workspaceFolder}:/work shaderc-vkrunner-mcp --work-dir /workPrerequisites: you need Docker installed on your machine. You also need an MCP-capable AI agent to connect to the server.
Clone the project and build the Docker image locally. Run these commands in your terminal.
git clone https://github.com/mehmetoguzderin/shaderc-vkrunner-mcp
cd shaderc-vkrunner-mcp
docker build -t shaderc-vkrunner-mcp -f Dockerfile .Safety is achieved by CPU-based emulation using Mesa's software Vulkan implementation, ensuring shaders run without interacting with real GPUs. The approach emphasizes cross-platform compatibility by avoiding CUDA or specialized GPU hardware, and it provides a monolithic interface for shader development, optimization, and visualization. The project leverages Rust for a type-safe implementation and composes a self-contained environment suitable for local testing.
Key principles include safety through CPU emulation, cross-platform Vulkan support, a minimal yet capable feature set for testing advanced shader technologies, and a monolithic design to streamline development and usage.
You can explore shader features safely on CPU, including subgroup operations and atomic operations, enabling experiments with parallelism and memory behavior without needing a physical GPU.
Development is streamlined with a Devcontainer option that provides a productive environment including Vulkan tooling and virtual framebuffer support for screenshots. This setup helps you iterate on the codebase efficiently.
The project includes VkRunner as a git subtree to ensure a specific, compatible version is always available without external dependencies.
Run code quality checks to enforce strict style and correctness during development.
cargo clippy -- \
-W clippy::pedantic \
-W clippy::nursery \
-A clippy::missing-errors-doc \
-A clippy::wildcard-imports \
-A clippy::unused-self \
-A clippy::unnecessary-wraps \
-A clippy::needless-pass-by-valueThe project is released under the Creative Commons CC0 1.0 Universal license. Some dependencies may have separate licenses; review those in the respective repositories for licensing details.
Thanks to the Model Context Protocol community, Shaderc for shader compilation, VkRunner for shader execution, and Mesa for the software Vulkan implementation that enables GPU-less operation.
Compile and optimize GPU shader code using Vulkan within the CPU-based sandbox.
Visualize shader execution results and debug outputs inside the local environment.