# ReShade Addon Development with RenoDX: A DirectX Modding Toolkit Guide

> Discover RenoDX, a DirectX modding toolkit. Leverage ReShade's addon system to modify shaders, textures & more in DirectX games without patching the executable.

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

---

**RenoDX is a "Renovation Engine for DirectX Games" that lets you modify shaders, buffers, textures, and swap chains in DirectX-based games without patching the original executable, using ReShade's add-on system as its foundation.**

If you're looking to extend or customize how modern PC games render graphics, understanding what RenoDX is and how it works opens up powerful modding capabilities. Built as a **ReShade add-on**, RenoDX hooks into DirectX pipelines across D3D9, D3D11, D3D12, and Vulkan to give modders control over the entire graphics pipeline — all while keeping compatibility headaches to a minimum.

## What Is RenoDX and How Does It Work?

RenoDX stands for **"Renovation Engine for DirectX Games"**. Rather than requiring binary patches to game executables, it leverages **ReShade's injection hooks** to intercept and modify graphics API calls at runtime. This architecture means any game that loads ReShade can also load RenoDX modules — no version-specific cracking or memory patching required.

According to the [RenoDX README.md](https://github.com/clshortfuse/renodx/blob/main/README.md), the toolkit provides six core capabilities:

- **Shader replacement** — swap original game shaders with custom HLSL implementations
- **Buffer injection** — add or replace constant and unordered-access buffers feeding data to shaders
- **Overlay creation** — render custom UI or debug information on top of game frames
- **Swap-chain upgrades** — replace native swap chains with HDR-aware or high-refresh alternatives
- **Texture-resource upgrades** — substitute in-game textures with higher-resolution or reformatted versions
- **Persistent user settings** — automatically save and load configuration from disk

## RenoDX Architecture and Source Structure

The codebase is organized into distinct layers that separate ReShade integration from game-specific logic. Understanding this structure helps when contributing mods or debugging issues.

| Layer | Responsibility | Key Files |
|-------|---------------|-----------|
| **ReShade Integration** | Hooks D3D9/D3D11/D3D12/Vulkan via ReShade's plugin API | [`src/reshade/reshade_compat.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/reshade/reshade_compat.cpp) |
| **Core Engine** | Abstract interfaces for shader, buffer, texture, swap-chain manipulation | [`src/engine/engine.h`](https://github.com/clshortfuse/renodx/blob/main/src/engine/engine.h), [`src/engine/engine.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/engine/engine.cpp) |
| **Game-Specific Glue** | Per-game memory layouts and resource handles | [`src/games/borderlands2/shared.h`](https://github.com/clshortfuse/renodx/blob/main/src/games/borderlands2/shared.h), [`src/games/zelda-eow/shared.h`](https://github.com/clshortfuse/renodx/blob/main/src/games/zelda-eow/shared.h) |
| **Utilities** | Standalone development tools | `renodx-fpslimiter.addon64`, `renodx-devkit.addon64`, `decomp.exe` |
| **Configuration** | Persistent INI/JSON settings management | [`src/config/config_manager.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/config/config_manager.cpp) |

The **engine** in [`src/engine/engine.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/engine/engine.cpp) communicates with game-specific code only through well-defined structs. This abstraction allows a single codebase to support hundreds of titles, with each game residing in its own `src/games/<title>/` directory.

## How RenoDX Mods Work at Runtime

The execution flow follows a predictable pattern once the add-on loads:

1. **ReShade loads** the RenoDX add-on (`renodx-devkit.addon64`)
2. The add-on registers callbacks for the DirectX device (e.g., `ID3D11Device`)
3. When the game creates a **shader**, RenoDX captures the creation call, hashes the bytecode, and checks against user-defined replacements
4. Before each **draw call**, the engine can inject constant buffers or bind replacement textures based on [`shared.h`](https://github.com/clshortfuse/renodx/blob/main/shared.h) definitions
5. After rendering, **overlays** draw (if enabled) and updated settings persist to disk

This hook-based approach in [`src/engine/engine.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/engine/engine.cpp) ensures that shader substitutions happen transparently to the game — the original engine continues running unchanged while RenoDX intercepts and modifies specific pipeline stages.

## Practical RenoDX Code Examples

### Shader Replacement via Dev-Kit Add-On

The most common RenoDX workflow is replacing game shaders with custom HLSL. Create an INI file alongside your ReShade configuration:

```ini
; renodx-devkit.ini — placed alongside the game's ReShade.ini
[ShaderReplacements]
; Map original shader hash to custom HLSL file
; OriginalHash   = Path/To/YourShader.hlsl
0xAB12CD34      = shaders/custom_lighting.hlsl

```

When the game requests the shader whose bytecode hashes to `0xAB12CD34`, RenoDX compiles `shaders/custom_lighting.hlsl` using the same shader model profile and substitutes the resulting bytecode. The original game continues executing normally, unaware that its lighting calculations now run your custom code.

For complete options, see the [RenoDX Mods wiki](https://github.com/clshortfuse/renodx/wiki/Mods).

### FPS Overlay and Limiter Configuration

The `renodx-fpslimiter.addon64` utility provides both performance display and frame rate control:

```ini
; renodx-fpslimiter.ini
[Overlay]
Enabled = true
Position = 10,10          ; screen coordinates
Color    = 255,255,255    ; white text

[Limiter]
TargetFPS = 60            ; optional frame rate cap

```

This add-on draws at the specified screen coordinates and can throttle rendering to reduce GPU load or match display refresh.

Download: [renodx-fpslimiter.addon64](https://clshortfuse.github.io/renodx/renodx-fpslimiter.addon64)

### Shader Reverse Engineering with decomp.exe

Before replacing shaders, you often need to understand what the original does. The `decomp.exe` utility reconstructs readable HLSL from compiled bytecode:

```bash

# Decompile a compiled shader blob (e.g., from .dds or .bin file)

decomp.exe -i compiled_shader.bin -o extracted_shader.hlsl

```

This tool supports **Shader Model 6.0+** and emits human-readable HLSL that reveals the original game's lighting calculations, texture sampling logic, and vertex transformations — essential knowledge before writing compatible replacements.

Download: [decomp.exe](https://clshortfuse.github.io/renodx/decomp.exe)

## Key Development Resources

| Resource | Purpose | Location |
|----------|---------|----------|
| Project overview and feature list | High-level RenoDX introduction | [[`README.md`](https://github.com/clshortfuse/renodx/blob/main/README.md)](https://github.com/clshortfuse/renodx/blob/main/README.md) |
| Contribution guidelines | Coding standards and PR process | [[`docs/CONTRIBUTING.md`](https://github.com/clshortfuse/renodx/blob/main/docs/CONTRIBUTING.md)](https://github.com/clshortfuse/renodx/blob/main/docs/CONTRIBUTING.md) |
| Dev-kit workflow documentation | Live development and MCP setup | [[`docs/DEVKIT_MCP.md`](https://github.com/clshortfuse/renodx/blob/main/docs/DEVKIT_MCP.md)](https://github.com/clshortfuse/renodx/blob/main/docs/DEVKIT_MCP.md) |
| Core engine interface | Shader/texture/buffer API | [`src/engine/engine.h`](https://github.com/clshortfuse/renodx/blob/main/src/engine/engine.h) |
| Core engine implementation | Runtime logic | [`src/engine/engine.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/engine/engine.cpp) |
| Game-specific definitions | Memory layouts per title | `src/games/<game>/shared.h` |
| Primary add-on binary | Main modding features | [`renodx-devkit.addon64`](https://clshortfuse.github.io/renodx/renodx-devkit.addon64) |

The [`shared.h`](https://github.com/clshortfuse/renodx/blob/main/shared.h) headers are particularly critical — they expose game-specific memory offsets, texture handles, and constant buffer layouts that the engine needs to inject data correctly. For example, [[`src/games/borderlands2/shared.h`](https://github.com/clshortfuse/renodx/blob/main/src/games/borderlands2/shared.h)](https://github.com/clshortfuse/renodx/blob/main/src/games/borderlands2/shared.h) defines how to access Borderlands 2's camera matrices and render targets.

## Summary

- **RenoDX** is a ReShade-based toolkit for runtime modification of DirectX games without executable patching
- The architecture separates **ReShade integration** (`src/reshade/`), **core engine** (`src/engine/`), and **game-specific glue** (`src/games/*/shared.h`)
- **Shader replacement** works by hashing original bytecode and mapping to custom HLSL files via INI configuration
- **Utility add-ons** provide FPS limiting, overlays, and development tools without requiring full mod builds
- **`decomp.exe`** enables reverse engineering of Shader Model 6.0+ bytecode to understand original game rendering
- Any ReShade-compatible game automatically supports RenoDX mods, offering broad engine coverage

## Frequently Asked Questions

### What games are compatible with RenoDX?

Any title that loads ReShade can run RenoDX — this includes most DirectX 9, 11, 12, and Vulkan games on Windows. The limiting factor is typically whether someone has created the [`shared.h`](https://github.com/clshortfuse/renodx/blob/main/shared.h) definitions mapping that game's specific memory layouts and resource handles. Popular supported titles include Borderlands 2 and The Legend of Zelda: Echoes of Wisdom, with new games added via community contributions.

### How does RenoDX differ from ReShade filters?

Standard ReShade filters operate as **post-processing effects** on the final rendered frame. RenoDX operates at the **pipeline level**, letting you replace individual game shaders, modify constant buffers feeding the GPU, upgrade texture formats, and swap the underlying swap chain. This enables modifications that change how the game itself calculates lighting, shadows, and materials — not just how the finished image looks.

### Do I need to know DirectX programming to use RenoDX?

For basic usage like FPS limiting or applying existing mods, no — just configure INI files. To create custom shader replacements, you'll need working knowledge of **HLSL** and the graphics pipeline stage you're targeting (vertex, pixel, compute shaders). The `decomp.exe` tool helps by showing you the original game's shader code as a starting point.

### Where does RenoDX store mod configurations?

Settings persist to disk via the configuration manager in [`src/config/config_manager.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/config/config_manager.cpp). Each add-on loads its own INI or JSON file — typically named `renodx-<addon>.ini` and placed alongside the game's [`ReShade.ini`](https://github.com/clshortfuse/renodx/blob/main/ReShade.ini). Changes made through in-game overlays write back to these files automatically for persistence across sessions.