Complete Guide to Renodx Development Dependencies: Build Tools, SDKs, and Libraries

Renodx development requires CMake ≥ 3.20, Visual Studio 2022 or Clang, the Vulkan SDK, DirectX SDK, Reshade SDK, and additional libraries including spdlog and fmt pinned in cmake/tool-versions.cmake to compile the C++ modding framework and execute the test suite.

Renodx is a C++‑based modding framework that injects shaders and enhances games through the Reshade API. Configuring a proper renodx development environment demands specific compilers, graphics SDKs, and build automation tools explicitly referenced throughout the repository source code and CI configuration files.

Core Build System and Compilers

CMake Configuration (Minimum Version 3.20)

The project relies on CMake as its primary build system generator. The root CMakeLists.txt drives the entire compilation process, defining project structure, compiler flags, and dependency fetching logic. Developers must install CMake version 3.20 or higher to process the configuration files correctly.

cmake -B build -S . -G "Visual Studio 17 2022" -A x64

Visual Studio 2022 and MSVC

Visual Studio 2022 serves as the primary development environment on Windows. The repository includes make-sln.cmd, a batch script that generates Visual Studio solution (.sln) files from the CMake configuration. The MSVC compiler is strictly required for DirectX SDK integration and for building the core Reshade hooks located in src/games/*.

Clang Compiler Support

For developers preferring alternative toolchains, the repository supports Clang through dedicated CI workflows defined in .github/workflows/clang-x64.yml. Clang is also employed for static analysis during continuous integration builds.

Graphics SDKs and Rendering APIs

Vulkan SDK

The test suite requires the Vulkan SDK to validate swap-chain upgrades and resource handling. Test project configurations such as test/resource_upgrade_transfer/CMakeLists.txt explicitly invoke the following CMake command:

find_package(Vulkan QUIET)

This makes the Vulkan SDK mandatory for executing the verification tests that ensure proper graphics resource management.

DirectX 11 and DirectX 12 SDKs

DirectX SDKs provide the headers and runtime libraries essential for the core Reshade integration and game-specific modules. Source files under src/games/* and test applications such as dx12_app.cpp rely on these SDKs to interface with DirectX graphics pipelines and compile DirectX-specific test apps.

Reshade SDK

Renodx builds upon the Reshade SDK to inject shaders, buffers, and overlays into target games. The project compiles add-ons (.addon64 binaries) that conform to this SDK's API specifications, as evidenced by the add-on source structure and generated binary outputs in the build directory.

Shader Compilation Toolchain

GLSLang and HLSL Compilers

Shader compilation requires GLSLang and HLSL compilers to process source files with extensions .glsl, .hlsl, and .slang. These tools compile test shaders and game-specific shader modules stored in src/games/* and associated test directories, ensuring the modded shaders are valid for runtime injection.

Scripting and Build Automation Dependencies

Python 3.8 or Higher

Python 3.8+ powers utility scripts that manage release manifests and development environment setup. Files such as scripts/setup-dev-env.ps1 and the helper logic in scripts/generate-release-manifest.mjs require Python to execute environment validation and build preparation tasks correctly.

Node.js for JavaScript Automation

The repository uses Node.js to execute .mjs scripts that generate release manifests and perform build-time automation. These JavaScript modules handle versioning and packaging workflows alongside the Python utilities.

Version-Pinned C++ Libraries

Third-party C++ dependencies are strictly version-controlled in cmake/tool-versions.cmake. This file pins exact versions to ensure reproducible builds across different development machines:

• spdlog: High-performance logging library
• fmt: Modern formatting library
• tinyxml2: XML parsing for shader metadata
• Boost: Utility helpers for core framework functionality

CMake automatically fetches and links these libraries during the configuration phase based on the versions specified in cmake/tool-versions.cmake.

Source Control and Optional Build Tools

Git for Submodule Management

Git is required to clone the repository and initialize submodules tracked in .gitmodules. Several dependencies and external references are managed through Git submodules rather than system package managers, making Git essential for a complete source tree.

Ninja Build System

While optional, Ninja serves as a fast backend for CMake builds and is used in CI workflows located in .github/workflows/. Ninja provides faster incremental builds compared to the default MSBuild generator on Windows and can be invoked via:

cmake -B build -G Ninja

Environment Verification

The repository includes scripts/setup-dev-env.ps1, a PowerShell script that validates the presence of required SDKs and tools on fresh development machines. Running this script verifies that Vulkan, DirectX, Python, Node.js, and compiler toolchains are properly installed and accessible before attempting compilation.

Summary

• CMake ≥ 3.20 is mandatory, configured via the root CMakeLists.txt
• Visual Studio 2022 (MSVC) is the primary Windows compiler, though Clang is supported via CI workflows
• Vulkan SDK and DirectX SDK provide essential graphics headers for the rendering pipeline and test suite
• Reshade SDK enables the core injection functionality that defines the renodx framework
• Python 3.8+ and Node.js execute build scripts and release automation utilities
• Third-party libraries (spdlog, fmt, tinyxml2, Boost) are version-pinned in cmake/tool-versions.cmake
• Git manages submodules, while Ninja offers an optional fast build backend for CMake

Frequently Asked Questions

What is the minimum CMake version required for renodx?

The repository requires CMake 3.20 or higher, as specified in the root CMakeLists.txt. This version ensures compatibility with the modern CMake features used for dependency management and compiler flag configuration.

Can I build renodx without Visual Studio?

Yes, though Visual Studio 2022 is the primary supported environment. The repository includes CI workflows for Clang in .github/workflows/clang-x64.yml, allowing compilation with alternative compilers. However, you still need the Windows SDK and DirectX headers regardless of the compiler choice.

Where are third-party dependency versions defined in renodx?

Exact versions of C++ libraries like spdlog, fmt, tinyxml2, and Boost are pinned in cmake/tool-versions.cmake. This file ensures reproducible builds across different development machines by constraining dependency versions rather than using floating ranges.

Is the Reshade SDK bundled with the renodx repository?

The Reshade SDK is a required external dependency, not bundled source code. The renodx build system expects the SDK to be available for linking against the add-on interface, enabling the compilation of .addon64 binaries that inject shaders and overlays into games.

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