# How to Build renodx from Source: Complete CMake Guide for ReShade Add-ons

> Learn to build renodx from source using CMake. Follow this guide to clone, configure with presets, and compile your own ReShade add-ons for DirectX applications.

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

---

**Building renodx from source requires cloning the repository with submodules, selecting a CMake preset for your toolchain (Ninja, Visual Studio, or Clang), and running `cmake --build` to generate `.addon64` or `.addon32` modules that ReShade can load into DirectX applications.**

The renodx project provides a CMake-driven build system that automates the compilation of DirectX-compatible add-ons. Understanding how to build renodx from source allows developers to customize shaders, modify hooking behavior, and create game-specific modifications. The build pipeline handles tool detection, shader compilation, binary embedding, and architecture-specific linking through configurations defined in [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) and [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json).

## Prerequisites

Before you build renodx from source, ensure your development environment includes:

- **CMake 3.20 or higher** for generating build scripts
- **Visual Studio 2019 or newer**, **Clang**, or **Ninja** as your toolchain
- **Windows SDK** (provides `fxc.exe` and `dxc.exe` for shader compilation)
- **Git** with submodule support (to fetch `external/Detours` and other dependencies)

## Step-by-Step Build Instructions

Follow these commands to compile the project from a clean state:

1. **Clone the repository recursively** to fetch all submodules including the Detours library:

```bash
git clone --recursive https://github.com/clshortfuse/renodx.git
cd renodx

```

2. **Configure the build** using a CMake preset. For 64-bit release builds with Ninja:

```bash
cmake --preset=ninja-x64-release

```

For Visual Studio users, use `vs-x64` instead. Available presets are defined in [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json) (lines 21‑86).

3. **Compile the add-ons**:

```bash
cmake --build --preset=ninja-x64-release

```

4. **Run tests** (optional):

```bash
cmake --build --preset=ninja-x64-debug -t test
ctest --preset=ninja-x64-debug

```

The build outputs `.addon64` files (or `.addon32` for 32-bit presets) into the build directory, ready for deployment with ReShade.

## Understanding the CMake Build Pipeline

The [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) file orchestrates a complex pipeline that transforms shader source code into embedded binary modules.

### Tool Discovery

The build script locates shader compilers in the repository `bin/` folder or via the Windows SDK (lines 12‑34). It searches for `fxc.exe` (DirectX 11), `dxc.exe` (DirectX 12), `slangc.exe` (Slang shaders), and optionally `glslangValidator` (Vulkan/OpenGL).

### Architecture Detection

The system inspects `CMAKE_SIZEOF_VOID_P` to determine whether to produce 64-bit (`.addon64`) or 32-bit (`.addon32`) binaries (lines 29‑41). This automatic detection ensures the correct memory pointer size for the target ReShade host application.

### Detours Library Compilation

The Microsoft Detours library—used for function hooking—is compiled as a static dependency using the VC++ environment via `vcvarsall.bat` (lines 60‑73). The resulting static library is imported as a CMake target and linked against every add-on module.

### Shader Compilation Stages

The build system supports three shader languages, each processed by dedicated compiler logic:

- **HLSL shaders**: Compiled with `fxc` for DX11 targets or `dxc` for DX12+ using profiles specified in [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) (lines 94‑155)
- **Slang shaders**: Processed by `slangc` with options to emit either DXBC or DXIL bytecode (lines 200‑260)
- **GLSL shaders**: Translated to SPIR-V binaries using `glslangValidator` for Vulkan compatibility (lines 370‑440)

### Binary Embedding and Header Generation

Compiled shader binaries are converted into C++ header files by the `embed_file` utility (located at [`src/embed_file.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/embed_file.cpp)). The [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) invokes this tool (lines 310‑380) to aggregate all shaders into a single [`shaders.h`](https://github.com/clshortfuse/renodx/blob/main/shaders.h) file containing macro tables that the runtime uses to discover custom shaders.

### Add-on Target Generation

For every [`addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/addon.cpp) file discovered under `src/**/**/addon.cpp`, CMake creates a dedicated module target (lines 76‑133). Each target links against the Detours static library and receives the appropriate suffix (`.addon64` or `.addon32`) based on the architecture detected earlier.

## CMake Presets and Toolchains

The [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json) file (lines 21‑86) defines pre-configured environments that abstract toolchain differences. Presets include:

- **ninja-x64-release** and **ninja-x86-release**: Fast builds using the Ninja generator
- **vs-x64**: Visual Studio project generation for IDE-based development
- **clang-x64**: LLVM/Clang toolchain support for alternative compiler optimization

Each preset specifies the generator, architecture, and build type (Debug or Release), eliminating manual configuration of `CMAKE_GENERATOR` and `CMAKE_BUILD_TYPE`.

## Summary

- **Build renodx from source** using CMake with presets defined in [`CMakePresets.json`](https://github.com/clshortfuse/renodx/blob/main/CMakePresets.json) to handle toolchain selection automatically
- The pipeline compiles shaders using `fxc`, `dxc`, `slangc`, or `glslangValidator` depending on the target graphics API
- Binary shader data is embedded into headers via [`src/embed_file.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/embed_file.cpp) to create self-contained add-on modules
- Output files use the `.addon64` or `.addon32` extension based on `CMAKE_SIZEOF_VOID_P` detection (lines 29‑41)
- Every add-on links against the Detours library compiled from `external/Detours` using `vcvarsall.bat` (lines 60‑73)

## Frequently Asked Questions

### What tools are required to build renodx from source?

You need CMake, a C++ compiler (MSVC, Clang, or GCC via Ninja), and the Windows SDK. The build system specifically requires `fxc.exe` or `dxc.exe` for HLSL compilation, which the [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) locates in either the repository `bin/` folder or system SDK paths (lines 12‑34). Git must be configured to fetch submodules recursively to obtain the Detours dependency.

### How do I compile 32-bit add-ons instead of 64-bit?

Select a preset containing `x86` instead of `x64`. For example, run `cmake --preset=ninja-x86-release` followed by `cmake --build --preset=ninja-x86-release`. The architecture detection logic in [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) (lines 29‑41) checks `CMAKE_SIZEOF_VOID_P` and automatically assigns the `.addon32` suffix to the output files.

### Where does the build system locate shader compilers?

The [`CMakeLists.txt`](https://github.com/clshortfuse/renodx/blob/main/CMakeLists.txt) searches for `fxc.exe`, `dxc.exe`, and `slangc.exe` in the repository's local `bin/` directory first, then falls back to the Windows SDK installation paths (lines 12‑34). This allows the project to ship specific compiler versions while remaining compatible with system-wide SDK installations.

### What is the purpose of the embed_file utility?

The `embed_file` executable (source at [`src/embed_file.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/embed_file.cpp)) converts compiled shader binaries into C++ header files containing byte arrays. During the build process (lines 310‑380), CMake invokes this tool to generate [`shaders.h`](https://github.com/clshortfuse/renodx/blob/main/shaders.h), which aggregates all shader data into macro tables that the ReShade add-on runtime queries at initialization time.