# How to Set Up a Development Environment for RenoDX: A Complete Windows Guide

> Set up your RenoDX development environment on Windows with this guide. Install tools, run scripts, configure CMake, and build targets for live shader inspection.

- Repository: [Carlos Lopez/renodx](https://github.com/clshortfuse/renodx)
- Tags: how-to-guide
- Published: 2026-09-06

---

**To set up a development environment for RenoDX, install Visual Studio 2022 Build Tools and the Windows SDK (version 10.0.26100.0 or newer), run `scripts/setup-dev-env.ps1` to bootstrap LLVM and shader compilers into `./bin`, configure a CMake preset such as `clang-x64`, and build the `devkit` and `mcp_bridge` targets to enable live shader inspection.**

RenoDX is a DirectX-modding framework built on the Reshade add-on system, designed for advanced shader modification and real-time graphics debugging. Setting up a proper development environment requires specific toolchain versions and helper scripts provided in the `clshortfuse/renodx` repository. This guide walks through the exact steps to configure your Windows machine for building the core library and live-inspection tools according to the source code.

## Prerequisites and System Requirements

Before running the bootstrap script, ensure your system meets the baseline requirements defined in `cmake/tool-versions.cmake`. This file serves as the central source of truth for minimal versions across the project.

Your system must have:

- Visual Studio 2022 Build Tools with the C++ workload
- CMake 3.20+ and the Ninja build system
- LLVM/Clang 16 or later for compiler support
- Windows SDK 10.0.26100.0 or newer
- Shader compilation utilities (DXC, Slang, glslang, cmd_decompiler)

Detailed installation instructions are documented in [`docs/CONTRIBUTING.md`](https://github.com/clshortfuse/renodx/blob/main/docs/CONTRIBUTING.md).

## Bootstrapping the Development Environment

The repository includes an automated PowerShell script that eliminates manual tool installation. Located at `scripts/setup-dev-env.ps1`, this script reads version requirements from `cmake/tool-versions.cmake` and downloads all necessary binaries into a local `./bin` directory. It can also install the Windows SDK if missing from your system.

Run the bootstrap process from the repository root:

```powershell
git clone https://github.com/clshortfuse/renodx.git
cd renodx
powershell -ExecutionPolicy Bypass -File .\scripts\setup-dev-env.ps1 -Install

```

This command creates the `./bin` folder containing `fxc.exe`, `dxcompiler.dll`, and other shader utilities required for the build process. The script enforces the exact versions specified in the CMake configuration to ensure build reproducibility.

## Configuring the Build System with CMake

RenoDX uses CMake presets defined in [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json) to standardize build configurations across different environments. The available presets include `clang-x64`, `clang-x86`, `ninja-x64`, and `vs-x64`, each targeting specific compiler toolchains and architectures.

Select a preset that matches your development needs. The `clang-x64` preset is recommended for most contributions as it provides enhanced diagnostics and faster compilation:

```powershell
cmake --preset clang-x64

```

This configures the compiler, linker, and tool-chain paths according to the specifications in `cmake/tool-versions.cmake`, ensuring version consistency across the team.

## Building the Core Components

With the project configured, compile the two primary development targets: `devkit` (the in-game inspection add-on) and `mcp_bridge` (the MCP server for external tool communication). Debug builds are recommended while iterating on shaders.

Execute the build command:

```powershell
cmake --build --preset clang-x64-debug --target devkit mcp_bridge

```

Upon successful compilation, the artifacts appear in `build/Debug/`:

- `renodx-devkit.addon64` – The Reshade add-on for live shader inspection
- `renodx-mcp-bridge.exe` – The bridge process implementing the MCP protocol

The MCP bridge source code resides in [`src/apps/mcp_bridge/main.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/apps/mcp_bridge/main.cpp), which initializes the named pipe communication used by external tools.

## Running the Live Inspection Workflow

To activate the development workflow, launch the MCP bridge and load the devkit add-on into a Reshade-enabled game. The bridge listens on a named pipe for commands from clients such as the Codex MCP client.

Start the bridge from your build directory:

```powershell
.\build\Debug\renodx-mcp-bridge.exe

```

In the target game, enable `renodx-devkit.addon64` through the Reshade menu. Once connected, you can use MCP commands to inspect shaders, dump resources, and trigger live reloads. Full protocol documentation is available in [`docs/DEVKIT_MCP.md`](https://github.com/clshortfuse/renodx/blob/main/docs/DEVKIT_MCP.md).

## Iterating on Shaders with the DevKit

The devkit provides a rapid iteration cycle for shader development. After building the tools, you can dump, edit, and reload shaders without restarting the game.

Use the following command sequence to establish a live workflow:

```powershell

# 1. Dump the original shader to disk

renodx_dump_shader <shader_hash> tmp\mygame\original

# 2. Decompile DXBC to HLSL if necessary

.\bin\cmd_Decompiler.exe --decompile tmp\mygame\original\0xABCDEF01.cso

# 3. Edit the generated HLSL in src/games/<yourgame>/

# 4. Configure the devkit paths

renodx_set_tools_path .\bin
renodx_set_live_shader_path src\games\<yourgame>

# 5. Load changes into the running game

renodx_load_live_shaders

# 6. Verify the shader source status

renodx_get_shader <shader_hash>

```

These commands are documented in [`docs/DEVKIT_MCP.md`](https://github.com/clshortfuse/renodx/blob/main/docs/DEVKIT_MCP.md) under the "Live shader iteration" and "Shader inspection and dumping" sections. The workflow allows you to modify `.hlsl` files in `src/games/` and see changes immediately in-game.

## Summary

Setting up a RenoDX development environment involves four main phases:

- Install the Windows toolchain (VS2022 Build Tools, Windows SDK) and run `scripts/setup-dev-env.ps1` to populate `./bin` with shader compilers listed in `cmake/tool-versions.cmake`
- Select a CMake preset from [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json) (e.g., `clang-x64`) to configure the build system with the correct tool paths
- Build the `devkit` and `mcp_bridge` targets to generate `renodx-devkit.addon64` and `renodx-mcp-bridge.exe` in `build/Debug/`
- Launch the MCP bridge, load the add-on in Reshade, and use the command interface to iterate on shaders stored in `src/games/`

## Frequently Asked Questions

### What is the minimum Windows SDK version required for RenoDX development?

According to `cmake/tool-versions.cmake` and the bootstrap script logic in `scripts/setup-dev-env.ps1`, you need Windows SDK version 10.0.26100.0 or newer. The setup script can automatically install this SDK if it detects an older version or missing installation.

### Can I use Visual Studio instead of Clang for building RenoDX?

Yes. While the `clang-x64` preset is recommended for development, [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json) includes Visual Studio configurations such as `vs-x64`. You can select these presets if you prefer the MSVC toolchain, though Clang typically provides faster compile times and better error messages for the shader-heavy codebase.

### Where is the MCP bridge entry point defined in the source code?

The MCP bridge implementation begins in [`src/apps/mcp_bridge/main.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/apps/mcp_bridge/main.cpp), which handles initialization of the named pipe server and protocol handlers. This executable (`renodx-mcp-bridge.exe`) acts as the intermediary between the in-game devkit add-on and external MCP clients.

### How do I update the helper binaries when tool versions change?

When the repository updates `cmake/tool-versions.cmake` with new tool requirements, simply re-run `scripts/setup-dev-env.ps1` from the repository root. The script compares your local `./bin` directory against the version specifications and downloads updated binaries automatically.