# praydog/reframework

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/praydog-reframework).**

4,423 stars · 469 forks · C++ · mit

## Links

- GitHub: https://github.com/praydog/REFramework
- Homepage: https://cursey.github.io/reframework-book/
- awesome-repositories: https://awesome-repositories.com/repository/praydog-reframework.md

## Topics

`cmkr` `cpp` `dmc5` `freecam` `lua` `mhrise` `modding` `mods` `monster-hunter-rise` `monster-hunter-wilds` `re-engine` `re2` `re3` `re4` `re7` `re8` `scripting` `sf6` `virtual-reality` `vr`

## Description

REFramework is a runtime modding framework for games built on the RE Engine, providing a C# plugin system with typed proxy code generation, a Lua scripting interface, an ImGui-based UI system, a runtime debugging toolkit, and a VR integration layer. At its core, it intercepts and modifies internal game engine functions and state at runtime through hooking and scripting APIs, enabling deep inspection and manipulation of live game objects.

The framework distinguishes itself through typed proxy code generation that auto-creates C# interfaces from the game's type database, giving compile-time safe access to engine types and members without string-based reflection. It supports multi-language plugin execution with both JIT-compiled C# and interpreted Lua, runtime function interception with pre and post callbacks, thread-safe hook synchronization, and immediate mode UI overlay rendering. The VR integration layer provides stereoscopic 3D rendering, head tracking, and motion controller input mapping.

Beyond its core capabilities, REFramework offers comprehensive tools for game object manipulation including transform property access, component management, and behavior tree editing. It includes a full suite of debugging and inspection features such as live object browsing, type metadata dumping, and method hooking for debugging. The framework also provides extensive UI widget creation tools, math and geometry operations for vectors and quaternions, and memory management utilities for controlling object and resource lifetimes.

The framework supports loading native DLL plugins alongside scripts, with hot-reload capabilities for C# plugins and version compatibility enforcement through its plugin API.

## Tags

### Game Development

- [Runtime Engine Hooking Frameworks](https://awesome-repositories.com/f/game-development/game-modding-interfaces/runtime-engine-hooking-frameworks.md) — Intercepting and modifying internal game engine functions and state at runtime through hooking and scripting APIs.
- [Function Hooking](https://awesome-repositories.com/f/game-development/function-hooking.md) — REFramework accesses and calls internal game engine methods and fields through the ObjectExplorer and SDK APIs. ([source](https://cursey.github.io/reframework-book/api/sdk.html))
- [Engine Lifecycle Hooks](https://awesome-repositories.com/f/game-development/game-engine-event-streams/engine-lifecycle-hooks.md) — Provides per-frame update and draw event subscriptions for runtime game engine manipulation. ([source](https://cursey.github.io/reframework-book/api_cs/general/index.html))
- [VR Integration Frameworks](https://awesome-repositories.com/f/game-development/vr-integration-frameworks.md) — Adds stereoscopic 3D rendering, head tracking, and motion controller input mapping to games.
- [Custom VR Motion Controls](https://awesome-repositories.com/f/game-development/custom-vr-motion-controls.md) — Provides an in-game menu for mapping controller inputs to actions, complementing runtime bindings. ([source](https://cursey.github.io/reframework-book/troubleshooting/VR-Troubleshooting.html))
- [Singleton Accessors](https://awesome-repositories.com/f/game-development/game-logic-scripting/indexed-object-property-accesses-in-script/singleton-accessors.md) — Provides typed proxy access to singleton game objects for direct manipulation. ([source](https://cursey.github.io/reframework-book/api/sdk.html))
- [Component Manipulators](https://awesome-repositories.com/f/game-development/scene-object-manipulators/component-manipulators.md) — REFramework adds or removes components on game objects at runtime to alter their behavior dynamically. ([source](https://cursey.github.io/reframework-book/api/types/REComponent.html))
- [Value Type Field Setters](https://awesome-repositories.com/f/game-development/value-type-field-setters.md) — REFramework assigns a value to a named field on a local value type object, but does not affect in-game state until the object is passed to a function that consumes it. ([source](https://cursey.github.io/reframework-book/api/types/ValueType.html))
- [VR Input Handling](https://awesome-repositories.com/f/game-development/vr-input-handling.md) — Maps physical VR controller inputs to in-game actions through the VR runtime's binding system. ([source](https://cursey.github.io/reframework-book/print.html))

### Data & Databases

- [Managed Object Field Readers](https://awesome-repositories.com/f/data-databases/data-integration-synchronization/local-document-indexing/document-indexing/field-value-stores/managed-object-field-readers.md) — REFramework reads the data stored in a field of a managed object, supporting static fields and raw pointers. ([source](https://cursey.github.io/reframework-book/api/types/REField.html))
- [Enum Definitions](https://awesome-repositories.com/f/data-databases/enum-definitions.md) — Generates real C# enums from game type definitions, replacing magic integers with named constants. ([source](https://cursey.github.io/reframework-book/api_cs/general/typed-proxies.html))
- [Garbage Collection Inhibitors](https://awesome-repositories.com/f/data-databases/object-persistence/garbage-collection-inhibitors.md) — REFramework marks managed objects as global so the .NET garbage collector does not reclaim them while the game still holds references. ([source](https://cursey.github.io/reframework-book/api_cs/examples/additional-save-slots.html))
- [Game Engine Native Plugins](https://awesome-repositories.com/f/data-databases/sqlite-extensions/native-extension-loading/game-engine-native-plugins.md) — Loads DLL plugins that hook into the framework's rendering, input, and game code callbacks. ([source](https://cursey.github.io/reframework-book/index.html))
- [Keyboard State Queries](https://awesome-repositories.com/f/data-databases/state-query-interfaces/keyboard-state-queries.md) — REFramework checks whether a specified key is down, pressed, or released during the current frame. ([source](https://cursey.github.io/reframework-book/api/imgui.html))

### Development Tools & Productivity

- [Game Object Debugging Toolkits](https://awesome-repositories.com/f/development-tools-productivity/3d-debugging-toolkits/game-object-debugging-toolkits.md) — A toolkit for inspecting live game objects, visualizing motion chains, and editing behavior trees.
- [Game Object Browsers](https://awesome-repositories.com/f/development-tools-productivity/object-inspection-tools/game-object-browsers.md) — Browses live game objects, singletons, and their fields and methods through an interactive explorer. ([source](https://cursey.github.io/reframework-book/print.html))
- [Runtime Manipulators](https://awesome-repositories.com/f/development-tools-productivity/object-inspection-tools/game-object-browsers/runtime-manipulators.md) — Provides runtime read/write access to game object fields and methods through the Type Database. ([source](https://cursey.github.io/reframework-book/print.html))
- [Style Stacks](https://awesome-repositories.com/f/development-tools-productivity/configuration-updates/real-time-push-updates/ui-push-updates/style-stacks.md) — REFramework pushes or pops style colors and variables onto a stack to temporarily alter widget appearance. ([source](https://cursey.github.io/reframework-book/api/imgui.html))
- [Cross-Phase Hook Storage](https://awesome-repositories.com/f/development-tools-productivity/post-processing-hooks/cross-phase-hook-storage.md) — Provides temporary storage containers that persist between pre and post hooks, automatically cleaned up. ([source](https://cursey.github.io/reframework-book/api/thread.html))

### Graphics & Multimedia

- [Managed Resource Holders](https://awesome-repositories.com/f/graphics-multimedia/graphics-resource-wrapping/managed-resource-holders.md) — Creates typed resource holders that automatically manage reference counts of wrapped game engine resources. ([source](https://cursey.github.io/reframework-book/api/types/REResource.html))
- [3D World Overlays](https://awesome-repositories.com/f/graphics-multimedia/screen-overlays/3d-world-overlays.md) — Provides 3D world-space overlay rendering for debugging and visualizing game objects and collisions. ([source](https://cursey.github.io/reframework-book/print.html))

### Hardware & IoT

- [AngelScript and Lua Game Scripting](https://awesome-repositories.com/f/hardware-iot/standalone-rfid-operations/lua-scripting-engines/angelscript-and-lua-game-scripting.md) — Provides an embedded Lua scripting engine for writing game logic and manipulating engine state at runtime. ([source](https://cursey.github.io/reframework-book/api_cs/general/benchmarks.html))
- [Runtime Scripting Interfaces](https://awesome-repositories.com/f/hardware-iot/standalone-rfid-operations/lua-scripting-engines/angelscript-and-lua-game-scripting/runtime-scripting-interfaces.md) — An interpreted scripting interface for controlling engine behavior and game state without compilation.

### Operating Systems & Systems Programming

- [Managed Heap Object Reflection](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/heap-allocation-strategies/dynamic-heap-allocators/managed-heaps/managed-heap-object-reflection.md) — Reflects on the managed heap to create, read, and modify game objects and value types.
- [Native Game Function Invocations](https://awesome-repositories.com/f/operating-systems-systems-programming/native-function-invocations/native-game-function-invocations.md) — REFramework invokes a native method on a game object by its type definition and name. ([source](https://cursey.github.io/reframework-book/api/sdk.html))

### Programming Languages & Runtimes

- [JIT-Compiled Script Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/c-based-scripting-engines/jit-compiled-script-runtimes.md) — Runs modding scripts using C# with JIT compilation for faster execution and true multi-threading. ([source](https://cursey.github.io/reframework-book/api_cs/general/benchmarks.html))
- [Typed Proxies](https://awesome-repositories.com/f/programming-languages-runtimes/class-member-access/object-member-access/typed-proxies.md) — Auto-generates C# interfaces from the game's type database for compile-time safe access to engine types.
- [Direct Native Method Mapping](https://awesome-repositories.com/f/programming-languages-runtimes/direct-native-method-mapping.md) — REFramework maps game type methods to C# methods with typed arguments and return values for compile-time safety. ([source](https://cursey.github.io/reframework-book/api_cs/general/typed-proxies.html))
- [Dynamic Method Invokers](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-method-invokers.md) — REFramework calls a method on a game type by name or reference and reads its return value from a union struct that overlays all primitive types. ([source](https://cursey.github.io/reframework-book/api_cs/general/type-system.html))
- [C# Plugin Architectures](https://awesome-repositories.com/f/programming-languages-runtimes/high-performance-c-libraries/c-engine-extensions/c-plugin-architectures.md) — Loads and executes modding code in C# and Lua with JIT compilation and interpreted execution.
- [Managed Object Instantiation](https://awesome-repositories.com/f/programming-languages-runtimes/managed-object-interaction/managed-object-instantiation.md) — REFramework instantiates a managed object, string, array, delegate, resource, or user data from a type name. ([source](https://cursey.github.io/reframework-book/api/sdk.html))
- [Type Definition Caches](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-overrides/method-cache-and-hierarchy-lookups/type-definition-caches.md) — Stores resolved type definitions to speed up repeated calls and field accesses. ([source](https://cursey.github.io/reframework-book/print.html))
- [Hot Path Caches](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-overrides/method-cache-and-hierarchy-lookups/type-definition-lookups/hot-path-caches.md) — Stores resolved method and field definitions in static fields to avoid repeated string-based lookups. ([source](https://cursey.github.io/reframework-book/api_cs/general/api-reference.html))
- [Plugin Assembly Distributions](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/pre-compiled-distributions/plugin-assembly-distributions.md) — Loads DLL assemblies from a designated folder for distributing production-ready mods. ([source](https://cursey.github.io/reframework-book/api_cs/general/index.html))
- [Object Lifetime Management](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/c-c-tutorials/object-management/object-lifetime-management.md) — Manually controls reference counts and garbage collection for game resources and managed objects.
- [Runtime Type Inspection](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-type-inspection.md) — Reflects on any RE Engine type to list methods, fields, and properties at runtime. ([source](https://cursey.github.io/reframework-book/api_cs/general/type-system.html))
- [Runtime Object Casts](https://awesome-repositories.com/f/programming-languages-runtimes/type-conversion-and-casting/runtime-object-casts.md) — Provides typed proxy casting for live game objects via .As() method. ([source](https://cursey.github.io/reframework-book/api_cs/general/typed-proxies.html))

### Software Engineering & Architecture

- [Hook Synchronization Primitives](https://awesome-repositories.com/f/software-engineering-architecture/background-thread-dispatchers/thread-safe-dispatchers/thread-safe-state-transitions/hook-synchronization-primitives.md) — Uses locks and thread-local storage to protect shared state when hooked methods execute on multiple threads. ([source](https://cursey.github.io/reframework-book/api_cs/general/hooks.html))
- [Dynamic Function Interception](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-function-interception.md) — Hooks into game engine methods at runtime to intercept, inspect, and modify function calls.
- [Thread-Safe Function Interception](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-function-interception/thread-safe-function-interception.md) — Hooks functions in a non-blocking manner so multiple threads can execute the same hook simultaneously. ([source](https://cursey.github.io/reframework-book/api_cs/general/Notes-On-Threading.html))
- [Method Lookups by Name](https://awesome-repositories.com/f/software-engineering-architecture/function-naming-structures/function-name-retrieval-utilities/method-lookups-by-name.md) — REFramework invokes methods on a managed engine object by name, supporting overloaded functions through full prototype strings. ([source](https://cursey.github.io/reframework-book/api/types/REManagedObject.html))
- [Post-Execution Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/method-interception-proxies/post-execution-interceptors.md) — Runs custom code after game methods return to inspect or modify return values. ([source](https://cursey.github.io/reframework-book/api_cs/general/hooks.html))
- [Pre-Execution Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/method-interception-proxies/pre-execution-interceptors.md) — Runs custom code before game methods execute to inspect or modify arguments and optionally skip the original. ([source](https://cursey.github.io/reframework-book/api_cs/general/hooks.html))
- [Game Resource Reference Counts](https://awesome-repositories.com/f/software-engineering-architecture/reference-counted-resource-coordination/game-resource-reference-counts.md) — Manually manages reference counts of game engine resources to control their lifetime. ([source](https://cursey.github.io/reframework-book/api/types/REResource.html))
- [SDK Metadata Exports](https://awesome-repositories.com/f/software-engineering-architecture/in-memory-code-analysis/memory-dump-parsers/text-dump-generation-tools/sdk-metadata-exports.md) — Exports the full type database to JSON and C++ headers for offline reference and tooling. ([source](https://cursey.github.io/reframework-book/print.html))
- [Native Plugin Development](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/ecosystem-tooling/native-plugin-development.md) — Loads DLL plugins that access the full SDK to perform tasks beyond scripting capabilities. ([source](https://cursey.github.io/reframework-book/print.html))
- [Virtual Machine Reference Flushing](https://awesome-repositories.com/f/software-engineering-architecture/memory-usage-analysis/memory-leak-prevention/virtual-machine-reference-flushing.md) — Manually clears the RE Engine VM's local reference frame on custom threads to prevent heap corruption. ([source](https://cursey.github.io/reframework-book/api_cs/general/api-reference.html))
- [Call Counting Hooks](https://awesome-repositories.com/f/software-engineering-architecture/method-hooking-frameworks/call-counting-hooks.md) — Attaches to any method to count calls and optionally skip the original function for debugging. ([source](https://cursey.github.io/reframework-book/print.html))

### Testing & Quality Assurance

- [Game Function Invocations](https://awesome-repositories.com/f/testing-quality-assurance/method-call-profiling/method-call-spies/game-function-invocations.md) — REFramework invokes a method on a game object by its definition, passing arguments and receiving the return value. ([source](https://cursey.github.io/reframework-book/api/types/REMethodDefinition.html))
- [Managed Method Invocations](https://awesome-repositories.com/f/testing-quality-assurance/method-call-profiling/method-call-spies/managed-method-invocations.md) — REFramework invokes a managed method on a game object by its name and returns the method's result. ([source](https://cursey.github.io/reframework-book/api/sdk.html))

### User Interface & Experience

- [ImGui Extensions](https://awesome-repositories.com/f/user-interface-experience/c-gui-toolkits/imgui-extensions.md) — Provides an ImGui-based window system for creating titled, configurable windows within the game overlay. ([source](https://cursey.github.io/reframework-book/api/imgui.html))
- [In-Game Overlay Builders](https://awesome-repositories.com/f/user-interface-experience/c-gui-toolkits/imgui-extensions/in-game-overlay-builders.md) — Building custom in-game user interfaces with windows, widgets, and node editors using the ImGui library.
- [In-Game Overlay Systems](https://awesome-repositories.com/f/user-interface-experience/c-gui-toolkits/imgui-extensions/in-game-overlay-systems.md) — A custom UI system built on ImGui for creating overlays, menus, and node editors within games.
- [Pre and Post Hook Combinations](https://awesome-repositories.com/f/user-interface-experience/font-rasterizers/api-interception-hooks/method-hooking/pre-and-post-hook-combinations.md) — Attaches both pre and post hooks to the same game method, capturing context between phases. ([source](https://cursey.github.io/reframework-book/api_cs/general/hooks.html))
- [Immediate Mode UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/immediate-mode-ui-frameworks.md) — Renders a debug and modding UI overlay using ImGui with widgets for inspection and editing.
- [Per-Object Virtual Method Hooks](https://awesome-repositories.com/f/user-interface-experience/font-rasterizers/api-interception-hooks/method-hooking/per-object-virtual-method-hooks.md) — REFramework intercepts virtual method calls on a specific object instance rather than globally for all objects. ([source](https://cursey.github.io/reframework-book/api/sdk.html))
- [Node-Based UI Editors](https://awesome-repositories.com/f/user-interface-experience/node-based-ui-editors.md) — Provides a node-based graph editor using ImNodes for editing behavior trees and state machines within games. ([source](https://cursey.github.io/reframework-book/api/imnodes.html))

### Web Development

- [Managed Object Field Accessors](https://awesome-repositories.com/f/web-development/json-apis/dot-notation-field-accessors/managed-object-field-accessors.md) — REFramework accesses and modifies fields of a managed engine object using dot notation with automatic reference counting. ([source](https://cursey.github.io/reframework-book/api/types/REManagedObject.html))

### Artificial Intelligence & ML

- [Visual Editors](https://awesome-repositories.com/f/artificial-intelligence-ml/decision-trees/behavior-trees/visual-editors.md) — Provides a visual editor for modifying behavior trees and finite state machines in games. ([source](https://cursey.github.io/reframework-book/bhvt_editor/bhvt_editor.html))
- [Transform Position Setters](https://awesome-repositories.com/f/artificial-intelligence-ml/machine-learning/frameworks/reinforcement-learning-environments/grid-world-simulation-frameworks/game-world-pathfinding/transform-position-setters.md) — REFramework sets the world position of a transform, optionally skipping dirty marking when the scene is locked. ([source](https://cursey.github.io/reframework-book/api/types/RETransform.html))
- [Hot-Reloaded Plugin Development](https://awesome-repositories.com/f/artificial-intelligence-ml/ml-visualization-libraries/custom-plugin-development/plugin-creation-from-templates/hot-reloaded-plugin-development.md) — Compiles and reloads C# plugins from source files without restarting the application. ([source](https://cursey.github.io/reframework-book/api_cs/general/index.html))

### Part of an Awesome List

- [Motion Chain Visualization](https://awesome-repositories.com/f/awesome-lists/devtools/animations-and-motion/motion-parameter-debugging/motion-chain-visualization.md) — Displays active chain objects and their collision data to aid in modding chain files. ([source](https://cursey.github.io/reframework-book/chain_viewer/chain_viewer.html))

### Security & Cryptography

- [Hook Synchronization Locks](https://awesome-repositories.com/f/security-cryptography/row-level-security/concurrent-shared-map-access/hook-synchronization-locks.md) — Ships thread-safe hook synchronization using locks to protect shared state during concurrent method interception. ([source](https://cursey.github.io/reframework-book/api_cs/general/Notes-On-Threading.html))
- [Transform Rotation Setters](https://awesome-repositories.com/f/security-cryptography/security/operations-and-incident-response/quaternion-rotation-utilities/transform-rotation-setters.md) — REFramework sets the world rotation of a transform using a quaternion. ([source](https://cursey.github.io/reframework-book/api/types/RETransform.html))