# What Applications Can Be Built with RenoDX? A Complete Guide to DirectX Game Modding

> Discover RenoDX's powerful applications for DirectX 11/12 game modding. Build shader injectors HDR upgrades FPS limiters developer tools and runtime UI overlays with this comprehensive guide.

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

---

**RenoDX enables developers to build shader injectors, HDR upgrades, FPS limiters, developer tools, and runtime UI overlays for DirectX 11/12 games through a unified Reshade add-on framework.**

RenoDX (Renovation Engine for DirectX Games) is an open-source framework that extends and modifies DirectX-based games without touching the original executable. By hooking into the Reshade add-on system, it provides low-level graphics pipeline access through a single codebase that works across any Reshade-compatible title.

## Core Capabilities for Application Development

RenoDX's architecture supports six primary extension patterns. Each targets a specific layer of the graphics pipeline and corresponds to real-world applications in the repository.

### Shader Injection and Replacement

Developers can swap existing game shaders with custom HLSL implementations. This powers visual overhaul mods, custom tone mappers, and post-process effects.

In [`src/games/zelda-eow/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/games/zelda-eow/addon.cpp), the framework registers custom shader collections through a macro-driven system:

```cpp
renodx::mods::shader::CustomShaders custom_shaders = { __ALL_CUSTOM_SHADERS };
// ...
renodx::mods::shader::Use(fdw_reason, custom_shaders, &shader_injection);

```

The `__ALL_CUSTOM_SHADERS` macro expands to compiled HLSL bytecode that replaces original shaders at runtime.

### Constant Buffer Modification

Applications can modify or extend uniform data flowing to shaders. This enables dynamic parameters like exposure values, color grading matrices, or custom animation data without recompiling game assets.

### Swap Chain and Texture Upgrades

RenoDX automatically promotes resource formats and dimensions. Common upgrades include:
- **SDR to HDR**: Converting `R8G8B8A8_UNORM` to `R16G16B16A16_FLOAT` for high dynamic range output
- **Resolution upscaling**: Expanding texture dimensions for sharper rendering
- **Precision improvements**: Moving to higher bit-depth formats for color accuracy

The swap chain upgrade logic in [`src/games/zelda-eow/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/games/zelda-eow/addon.cpp) demonstrates automatic format promotion when the add-on detects compatible hardware.

### Runtime UI Overlays

Using ImGui integration, developers build settings panels that appear in-game. The `renodx::utils::settings` system in [`src/utils/settings.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/settings.hpp) handles persistence, value binding, and UI generation.

### Buffer Injection

Applications can inject new vertex buffers, index buffers, or arbitrary GPU resources. This enables custom geometry injection, expanded post-process meshes, or compute shader data sources.

### Settings Persistence

A built-in preset system stores user configurations per-game or globally, with automatic serialization and hot-reloading.

## Types of Applications Built with RenoDX

The `src/games/` directory contains dozens of production add-ons demonstrating four major application categories.

### Visual Enhancement Mods

**HDR Retrofits**: Add HDR output to games with fixed SDR pipelines. The Zelda: Echoes of Wisdom add-on implements full tone-mapping replacement with user-selectable curves.

**Post-Process Injectors**: Custom anti-aliasing, sharpening filters, or film grain overlays that apply after the game's final render pass.

**Color Grading Tools**: Real-time exposure, contrast, and saturation controls with ImGui sliders bound to shader uniforms.

### Performance and Utility Tools

The [`src/addons/fpslimiter/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/addons/fpslimiter/addon.cpp) implements a frame rate cap through direct swap chain manipulation:

```cpp
renodx::utils::settings::Settings settings = {
    new renodx::utils::settings::Setting{
        .key = "FPSLimit",
        .binding = &renodx::utils::swapchain::fps_limit,
        .default_value = 0.f,
        .label = "FPS Limit",
        .min = 0.f,
        .max = 480.f,
    },
};

```

The setting automatically appears in the overlay and writes directly to `renodx::utils::swapchain` internals.

### Developer Tooling

**RenoDX DevKit** ([`src/addons/devkit/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/addons/devkit/addon.cpp)): Assists in building other add-ons with helper utilities and debugging features.

**Shader Decompiler**: The `decomp.exe` tool reverse-engineers shader bytecode for analysis and modification.

**Debug Overlays**: Real-time pipeline inspection showing bound resources, draw call counts, and shader stages.

### Interactive UI Extensions

Applications can expose external integrations through button widgets:

```cpp
new renodx::utils::settings::Setting{
    .value_type = renodx::utils::settings::SettingValueType::BUTTON,
    .label = "RenoDX Discord",
    .section = "Links",
    .group = "button-line-1",
    .tint = 0x5865F2,
    .on_change = []() {
        renodx::utils::platform::LaunchURL("https://discord.gg/kSTf", "EbcCpC");
    },
};

```

This pattern supports web links, file browsers, or custom action triggers.

## Target Game Compatibility

RenoDX applications work with any DirectX 11 or 12 title that supports Reshade add-ons. The repository includes working implementations for:
- *The Legend of Zelda: Echoes of Wisdom*
- *Borderlands 2*
- *Dying Light 2*

Each add-on in `src/games/` demonstrates platform-specific adaptations while sharing core framework utilities.

## Key Implementation Files

| File | Application Relevance |
|------|----------------------|
| [`src/utils/settings.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/settings.hpp) | Core UI and persistence framework |
| [`src/utils/swapchain.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/utils/swapchain.hpp) | Frame pacing and format upgrade APIs |
| [`src/mods/shader.hpp`](https://github.com/clshortfuse/renodx/blob/main/src/mods/shader.hpp) | Shader injection registration |
| [`src/addons/fpslimiter/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/addons/fpslimiter/addon.cpp) | Complete utility add-on reference |
| [`src/addons/devkit/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/addons/devkit/addon.cpp) | Developer tool patterns |
| [`src/games/zelda-eow/addon.cpp`](https://github.com/clshortfuse/renodx/blob/main/src/games/zelda-eow/addon.cpp) | Full-featured visual mod example |

## Summary

RenoDX applications fall into three core patterns:

- **Graphics mods** that replace shaders, upgrade HDR, or inject post-processing
- **Utility tools** including FPS limiters, debug overlays, and performance monitors
- **Developer aids** for building, testing, and deploying additional add-ons

All applications share the Reshade add-on foundation, enabling single-codebase deployment across the DirectX 11/12 ecosystem.

## Frequently Asked Questions

### Does RenoDX work with non-DirectX games?

No. RenoDX specifically targets DirectX 11 and 12 through Reshade hooks. It does not support OpenGL, Vulkan, or proprietary console APIs. According to the source structure in `src/`, all graphics pipeline interactions assume DirectX resource types and swap chain semantics.

### Do RenoDX applications require modifying game files?

No. RenoDX operates as an external add-on loaded by Reshade. It intercepts graphics API calls at runtime without altering the original executable or game assets. This declarative approach—registering hooks and shaders through the framework—keeps modifications reversible.

### What programming knowledge is required to build RenoDX applications?

C++17 proficiency and familiarity with HLSL shaders. The framework uses modern C++ features including structured bindings, lambda expressions, and designated initializers. Developers should understand DirectX 11/12 resource lifecycles, pipeline state objects, and basic graphics debugging.

### Can commercial applications be built on RenoDX?

Yes. The repository uses the BSD 3-Clause license, permitting commercial use with attribution. However, add-ons that modify copyrighted game content may face distribution restrictions under game EULAs. The framework itself places no constraints on commercial deployment.