focus-creative-games/hybridclr

Features

• Runtime Logic Hot-Updates - Updates game logic and scripts across all platforms at runtime without requiring users to reinstall the application.
• Mixed-Mode Execution - Runs unmodified functions via native compilation and updated functions via an interpreter for high performance.
• Assembly Encryption - Secures binaries and library files used during loading to protect proprietary source code from decompilation.
• Hot-Patching Tools - Loads assemblies dynamically into a hybrid runtime to update logic across all platforms without rebuilding the binary.
• Assembly Loading - Imports compiled DLLs as byte arrays to update logic at runtime without requiring a binary rebuild.
• Native-Interpreted Bridging - Facilitates bidirectional communication between pre-compiled native code and dynamically loaded interpreted modules.
• Generic Types - Supports the execution of C# generics in dynamically loaded code without restrictions on implementation.
• Compiled Generic Preservation - Maintains the availability of compiled generic types and functions for use within interpreted code segments.
• Hybrid C# Execution Engines - Combines native execution for unmodified code with a high-performance interpreter for updated functions.
• Interpreter Performance Optimizations - Uses specialized execution engines to reduce interpreted code overhead and approach native speeds.
• Metadata Memory Optimizations - Reduces the memory footprint required to load assembly metadata for memory-constrained environments.
• Mixed-Mode Execution Engines - Runs unmodified functions at native speed while using a high-performance interpreter for updated logic.
• Metadata Encryption - Secures global metadata and hardens code to prevent unauthorized access and reverse engineering.
• Generic Type Resolution - Provides runtime generic type resolution to allow hot-updated code to use any generic class regardless of pre-instantiation.
• .NET Assembly Loaders - Dynamically loads and unloads C# assemblies into a running Unity process using byte arrays.
• Assembly Unloading - Completely unloads existing assemblies from memory to allow for clean replacement of updated code.
• Game Component Patching - Enables attaching scripts to game objects via code or asset loading to update behavior without rebuilding.
• Loading Performance Optimizations - Reduces the time spent loading assemblies into the runtime to increase startup and update speeds.
• Native Performance Logic - Combines native compiled code and interpreted scripts to maintain high execution speed during runtime updates.
• Dynamic Entity Updates - Adds and manages scripts and data objects on game entities dynamically during runtime.
• Dynamic Method Invocation - Invokes methods and logic from hot-patched assemblies via reflection from the static main binary.
• Native Function Bridge Definitions - Provides a mechanism for defining native functions that can be called from hot-updated scripts.
• Managed-to-Native Callbacks - Facilitates high-speed data exchange between the managed runtime and native languages via a specialized bridge.
• Native Callbacks - Implements high-performance callbacks to allow native libraries to trigger logic within the managed runtime.
• Multithreaded Runtime Support - Executes hot-updated code across multiple threads using volatile, ThreadStatic, and async Task patterns.
• Native-Managed Interop Callbacks - Deno X enables bidirectional data exchange between managed code and native languages using a dedicated callback system.
• Runtime Assembly Unloading - Completely removes assemblies from memory to allow for a clean replacement and refreshing of logic during execution.
• Code Obfuscators - Protects proprietary source code and metadata from reverse engineering through encryption and logic masking.
• Mobile-Optimized Memory Management - Reduces the memory footprint of assembly metadata to ensure stability on memory-constrained mobile devices.
• Interpreter Stack Traces - Injects detailed virtual stack information into crash logs to pinpoint errors within interpreted code.

Star history