System Requirements for RenoDX: Complete Windows Development Setup

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, this SDK provides the necessary headers and tools for DirectX development.

To install the required SDK via command line:

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 (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, 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, with specific configuration files included in the repository.

Configure the project using one of the provided CMake presets:

# 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 -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 and represents a runtime requirement distinct from the build‑time prerequisites.

Building the Project

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

# 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.
• 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 and the swap‑chain management in 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}