# System Requirements for RenoDX: Complete Windows Development Setup

> Discover RenoDX system requirements: Windows 10+, SDK, MSVC 2022 Build Tools, CMake, and a DirectX compatible GPU are essential for development. Build and run smoothly.

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

---

**RenoDX requires Windows 10 or newer, the Windows 10 SDK (minimum version 10.0.26100.0), MSVC 2022 Build Tools, CMake, and a DirectX 11/12 compatible GPU to build and run.**

RenoDX is a Windows‑only graphics engine developed by clshortfuse that modifies DirectX 11/12 games via the ReShade add‑on system. Understanding the system requirements for RenoDX is essential before compiling the source or deploying the add‑on. The following sections detail the hardware prerequisites, toolchain dependencies, and exact SDK versions enforced by the build system.

## Operating System and Windows SDK

RenoDX targets exclusively the Windows platform and requires specific SDK components for HLSL compilation.

**Windows Version**: Windows 10 or newer is mandatory. The build system explicitly checks for the Windows 10 SDK, which provides `fxc.exe` and other legacy compiler components.

**Windows SDK Version**: Minimum version `10.0.26100.0` is required. This version constraint is documented in the repository's setup scripts and ensures compatibility with the shader compilation pipeline. According to [`docs/CONTRIBUTING.md`](https://github.com/clshortfuse/renodx/blob/main/docs/CONTRIBUTING.md), this SDK provides the necessary headers and tools for DirectX development.

To install the required SDK via command line:

```powershell
winget install --id Microsoft.WindowsSDK -e --silent

```

## Graphics API and Hardware

The engine interfaces directly with DirectX device objects and requires compatible hardware.

**GPU Requirements**: A DirectX 11 or DirectX 12 compatible graphics card is necessary. The runtime detects available graphics APIs through helper functions defined in [`src/utils/device.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/device.hpp) (specifically the `IsDirectX` checks) and integrates with ReShade's DirectX hooks.

**Swap Chain Support**: DirectX‑specific swap‑chain handling logic resides in [`src/utils/swapchain.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/swapchain.hpp), confirming the engine's tight integration with the Windows graphics subsystem.

## Build Tools and Compilers

Compiling RenoDX from source requires a modern C++ toolchain and specific build automation tools.

**MSVC 2022 Build Tools**: The `vs_buildTools.exe` installer must include the C/C++ compiler. The project relies on MSVC‑specific intrinsics and Windows SDK integration.

**CMake**: Any recent CMake release serves as the primary build system generator. The repository provides multiple presets for different compiler configurations.

**LLVM**: Required for code linting and formatting, used extensively by the repository's CI pipelines.

**Ninja**: Optional but recommended for faster incremental builds.

**Visual Studio Code**: Listed as the recommended IDE in [`docs/CONTRIBUTING.md`](https://github.com/clshortfuse/renodx/blob/main/docs/CONTRIBUTING.md), with specific configuration files included in the repository.

Configure the project using one of the provided CMake presets:

```bash

# Available presets: clang-x64, ninja-x64, vs-x64, clang-x86, etc.

cmake --preset clang-x64

```

## Shader Toolchain

RenoDX manipulates shader code at runtime and requires a complete suite of command‑line compilers. These tools are referenced in `scripts/setup-dev-env.ps1` and version‑checked via `cmake/tool-versions.cmake`.

**DirectXShaderCompiler**: `dxc.exe` and `dxcompiler.dll` compile Shader Model 6.x shaders and handle DXIL operations.

**glslang**: `glslang.exe` compiles `.gl.glsl` and `.vk.glsl` source files to SPIR‑V for Vulkan compatibility layers.

**slangc**: `slangc.exe` compiles `.slang` shaders to multiple targets including DXBC, DXIL, and SPIR‑V.

**cmd_decompiler.exe**: Decompiles SM 5.0 shaders back to HLSL for analysis and modification.

Run the automated setup script to fetch these binaries into the `./bin` directory:

```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\setup-dev-env.ps1 -Install

```

Version requirements for these tools are strictly enforced in `cmake/tool-versions.cmake`, ensuring reproducible builds across development environments.

## ReShade Runtime Dependency

RenoDX operates as a ReShade add‑on and cannot function independently. A compatible ReShade installation is required for the add‑on to load into target applications. This dependency is noted in the repository's [`README.md`](https://github.com/clshortfuse/renodx/blob/main/README.md) and represents a runtime requirement distinct from the build‑time prerequisites.

## Building the Project

Once prerequisites are installed, build the engine and associated tools:

```bash

# Build core libraries in release mode

cmake --build --preset clang-x64-release

# Build the live-inspection devkit and MCP bridge in debug mode

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

```

These commands compile the full RenoDX suite, including the graphics hooks and development utilities.

## Summary

- **RenoDX requires Windows 10+** with the Windows 10 SDK (minimum 10.0.26100.0) installed.
- **Graphics hardware** must support DirectX 11 or 12, with API detection handled in [`src/utils/device.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/device.hpp).
- **MSVC 2022, CMake, and optionally Ninja** form the core build toolchain.
- **Specialized shader compilers** (DXC, glslang, slangc) are mandatory and version‑locked in `cmake/tool-versions.cmake`.
- **ReShade** must be present at runtime for the add‑on to function.
- Use `scripts/setup-dev-env.ps1` to automate SDK and toolchain installation.

## Frequently Asked Questions

### Can I build RenoDX on Linux or macOS?

No. RenoDX is strictly Windows‑only infrastructure. The codebase relies on Windows‑specific APIs, the Windows 10 SDK, and DirectX hooks that have no cross‑platform equivalents. The `IsDirectX` detection logic in [`src/utils/device.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/device.hpp) and the swap‑chain management in [`src/utils/swapchain.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/swapchain.hpp) are tightly coupled to the Windows graphics driver model.

### What happens if my Windows SDK version is older than 10.0.26100.0?

The build will fail during configuration or shader compilation. The `cmake/tool-versions.cmake` file enforces minimum version checks for the SDK and shader compilers. The setup script `scripts/setup-dev-env.ps1` will attempt to install the correct SDK version automatically, but manual installation via `winget` or the Visual Studio Installer may be required on older systems.

### Is Visual Studio required, or can I use command‑line tools only?

Visual Studio itself is not required, but the **MSVC 2022 Build Tools** are mandatory. You can compile using only the command line with CMake and Ninja. The repository provides presets for various toolchains (clang‑x64, ninja‑x64, vs‑x64) that function without the full IDE, though Visual Studio Code is recommended for development.

### Why does RenoDX need both DXC and glslang if it only targets DirectX?

While RenoDX primarily hooks DirectX 11/12 games, it maintains cross‑compilation capabilities for shader analysis and potential Vulkan translation layers. The `slangc` compiler also generates SPIR‑V output, requiring glslang for certain pipeline stages. This toolchain diversity allows RenoDX to process and analyze shaders from multiple graphics APIs during live debugging sessions.