diff --git a/CMakeLists.txt b/CMakeLists.txt
index b423f91e6..d14f29826 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -55,6 +55,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 set(ASMJIT_STATIC ON CACHE BOOL "" FORCE)
 set(DYNAMIC_LOADER ON CACHE BOOL "" FORCE) # OpenXR
 set(BUILD_TOOLS OFF CACHE BOOL "" FORCE) # DirectXTK
+set(SAFETYHOOK_FETCH_ZYDIS ON)
 
 if ("${CMAKE_BUILD_TYPE}" MATCHES "Release")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MT")
@@ -113,6 +114,16 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(directxtk12)
 
+message(STATUS "Fetching safetyhook (44200343bf803f78862426e301e9382e5b28ea2c)...")
+FetchContent_Declare(
+	safetyhook
+	GIT_REPOSITORY
+		https://github.com/cursey/safetyhook
+	GIT_TAG
+		44200343bf803f78862426e301e9382e5b28ea2c
+)
+FetchContent_MakeAvailable(safetyhook)
+
 message(STATUS "Fetching bddisasm (v1.34.10)...")
 FetchContent_Declare(
 	bddisasm
@@ -490,9 +501,13 @@ set(CMKR_TARGET utility)
 set(utility_SOURCES "")
 
 list(APPEND utility_SOURCES
+	"shared/utility/Exceptions.cpp"
 	"shared/utility/FunctionHook.cpp"
+	"shared/utility/FunctionHookMinHook.cpp"
 	"shared/utility/Relocate.cpp"
+	"shared/utility/Exceptions.hpp"
 	"shared/utility/FunctionHook.hpp"
+	"shared/utility/FunctionHookMinHook.hpp"
 	"shared/utility/Relocate.hpp"
 )
 
@@ -520,6 +535,7 @@ target_compile_options(utility PUBLIC
 target_link_libraries(utility PUBLIC
 	spdlog
 	minhook
+	safetyhook
 	kananlib
 )
 
@@ -12804,7 +12820,7 @@ if(REF_BUILD_FRAMEWORK AND CMAKE_SIZEOF_VOID_P EQUAL 8) # build-framework
 	source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${example_plugin_SOURCES})
 
 	target_compile_features(example_plugin PUBLIC
-		cxx_std_20
+		cxx_std_23
 	)
 
 	target_include_directories(example_plugin PUBLIC
@@ -12859,7 +12875,7 @@ if(REF_BUILD_FRAMEWORK AND CMAKE_SIZEOF_VOID_P EQUAL 8) # build-framework
 	source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${weapon_stay_big_plugin_SOURCES})
 
 	target_compile_features(weapon_stay_big_plugin PUBLIC
-		cxx_std_20
+		cxx_std_23
 	)
 
 	target_include_directories(weapon_stay_big_plugin PUBLIC
diff --git a/cmake.toml b/cmake.toml
index c6d34a4af..d377ca8b2 100644
--- a/cmake.toml
+++ b/cmake.toml
@@ -14,6 +14,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 set(ASMJIT_STATIC ON CACHE BOOL "" FORCE)
 set(DYNAMIC_LOADER ON CACHE BOOL "" FORCE) # OpenXR
 set(BUILD_TOOLS OFF CACHE BOOL "" FORCE) # DirectXTK
+set(SAFETYHOOK_FETCH_ZYDIS ON)
 
 if ("${CMAKE_BUILD_TYPE}" MATCHES "Release")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MT")
@@ -111,6 +112,9 @@ include-directories = [
 ]
 condition = "build-framework-dependencies"
 
+[fetch-content.safetyhook]
+git = "https://github.com/cursey/safetyhook"
+tag = "44200343bf803f78862426e301e9382e5b28ea2c"
 
 [target.imgui]
 type = "static"
@@ -182,6 +186,7 @@ compile-features = ["cxx_std_23"]
 link-libraries = [
     "spdlog",
     "minhook",
+    "safetyhook",
     "kananlib"
 ]
 
@@ -342,7 +347,7 @@ type = "game"
 [template.plugin]
 type = "shared"
 include-directories = ["include/"]
-compile-features = ["cxx_std_20"]
+compile-features = ["cxx_std_23"]
 condition = "build-framework"
 
 [template.plugin.properties]
diff --git a/shared/sdk/REContext.cpp b/shared/sdk/REContext.cpp
index 21e583a73..898201c64 100644
--- a/shared/sdk/REContext.cpp
+++ b/shared/sdk/REContext.cpp
@@ -1,8 +1,12 @@
+#include <windows.h>
+#include <dbghelp.h>
+
 #include <shared_mutex>
 #include <spdlog/spdlog.h>
 
 #include "utility/Scan.hpp"
 #include "utility/Module.hpp"
+#include "utility/Exceptions.hpp"
 
 #include "reframework/API.hpp"
 #include "ReClass.hpp"
@@ -397,9 +401,37 @@ namespace sdk {
         spdlog::info("VMContext: Caught exception code {:x}", code);
 
         switch (code) {
-        case EXCEPTION_ACCESS_VIOLATION:
-            spdlog::info("VMContext: Attempting to handle access violation.");
-
+        case EXCEPTION_ACCESS_VIOLATION: {
+            spdlog::info("VMContext: Attempting to handle access violation. Attempting to dump callstack...");
+
+            spdlog::error("RIP: {:x}", exc->ContextRecord->Rip);
+            spdlog::error("RSP: {:x}", exc->ContextRecord->Rsp);
+            spdlog::error("RCX: {:x}", exc->ContextRecord->Rcx);
+            spdlog::error("RDX: {:x}", exc->ContextRecord->Rdx);
+            spdlog::error("R8: {:x}", exc->ContextRecord->R8);
+            spdlog::error("R9: {:x}", exc->ContextRecord->R9);
+            spdlog::error("R10: {:x}", exc->ContextRecord->R10);
+            spdlog::error("R11: {:x}", exc->ContextRecord->R11);
+            spdlog::error("R12: {:x}", exc->ContextRecord->R12);
+            spdlog::error("R13: {:x}", exc->ContextRecord->R13);
+            spdlog::error("R14: {:x}", exc->ContextRecord->R14);
+            spdlog::error("R15: {:x}", exc->ContextRecord->R15);
+            spdlog::error("RAX: {:x}", exc->ContextRecord->Rax);
+            spdlog::error("RBX: {:x}", exc->ContextRecord->Rbx);
+            spdlog::error("RBP: {:x}", exc->ContextRecord->Rbp);
+            spdlog::error("RSI: {:x}", exc->ContextRecord->Rsi);
+            spdlog::error("RDI: {:x}", exc->ContextRecord->Rdi);
+            spdlog::error("EFLAGS: {:x}", exc->ContextRecord->EFlags);
+            spdlog::error("CS: {:x}", exc->ContextRecord->SegCs);
+            spdlog::error("DS: {:x}", exc->ContextRecord->SegDs);
+            spdlog::error("ES: {:x}", exc->ContextRecord->SegEs);
+            spdlog::error("FS: {:x}", exc->ContextRecord->SegFs);
+            spdlog::error("GS: {:x}", exc->ContextRecord->SegGs);
+            spdlog::error("SS: {:x}", exc->ContextRecord->SegSs);
+
+            utility::exceptions::dump_callstack(exc);
+
+        } break;
         default:
             break;
         }
@@ -445,7 +477,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_sbyte(int8_t value)  {
         static auto sbyte_type = ::sdk::find_type_definition("System.SByte");
-        static auto value_field = sbyte_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = sbyte_type->get_field("mValue");
+            if (f == nullptr) {
+                f = sbyte_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = sbyte_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -458,7 +498,14 @@ namespace sdk {
 
     ::REManagedObject* VM::create_byte(uint8_t value) {
         static auto byte_type = ::sdk::find_type_definition("System.Byte");
-        static auto value_field = byte_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = byte_type->get_field("mValue");
+            if (f == nullptr) {
+                f = byte_type->get_field("m_value");
+            }
+
+            return f;
+        }();
         auto new_obj = byte_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -471,7 +518,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_int16(int16_t value) {
         static auto int16_type = ::sdk::find_type_definition("System.Int16");
-        static auto value_field = int16_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = int16_type->get_field("mValue");
+            if (f == nullptr) {
+                f = int16_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = int16_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -484,7 +539,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_uint16(uint16_t value) {
         static auto uint16_type = ::sdk::find_type_definition("System.UInt16");
-        static auto value_field = uint16_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = uint16_type->get_field("mValue");
+            if (f == nullptr) {
+                f = uint16_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+        
         auto new_obj = uint16_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -497,7 +560,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_int32(int32_t value) {
         static auto int32_type = ::sdk::find_type_definition("System.Int32");
-        static auto value_field = int32_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = int32_type->get_field("mValue");
+            if (f == nullptr) {
+                f = int32_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = int32_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -510,7 +581,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_uint32(uint32_t value) {
         static auto uint32_type = ::sdk::find_type_definition("System.UInt32");
-        static auto value_field = uint32_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = uint32_type->get_field("mValue");
+            if (f == nullptr) {
+                f = uint32_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = uint32_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -523,7 +602,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_int64(int64_t value) {
         static auto int64_type = ::sdk::find_type_definition("System.Int64");
-        static auto value_field = int64_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = int64_type->get_field("mValue");
+            if (f == nullptr) {
+                f = int64_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = int64_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -536,7 +623,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_uint64(uint64_t value) {
         static auto uint64_type = ::sdk::find_type_definition("System.UInt64");
-        static auto value_field = uint64_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = uint64_type->get_field("mValue");
+            if (f == nullptr) {
+                f = uint64_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = uint64_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -550,7 +645,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_single(float value) {
         static auto float_type = ::sdk::find_type_definition("System.Single");
-        static auto value_field = float_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = float_type->get_field("mValue");
+            if (f == nullptr) {
+                f = float_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = float_type->create_instance_full();
 
         if (new_obj == nullptr) {
@@ -563,7 +666,15 @@ namespace sdk {
 
     ::REManagedObject* VM::create_double(double value) {
         static auto double_type = ::sdk::find_type_definition("System.Double");
-        static auto value_field = double_type->get_field("mValue");
+        static auto value_field = [&]() {
+            auto f = double_type->get_field("mValue");
+            if (f == nullptr) {
+                f = double_type->get_field("m_value");
+            }
+
+            return f;
+        }();
+
         auto new_obj = double_type->create_instance_full();
 
         if (new_obj == nullptr) {
diff --git a/shared/sdk/RETypeDB.cpp b/shared/sdk/RETypeDB.cpp
index ea697e03c..7292e1bcd 100644
--- a/shared/sdk/RETypeDB.cpp
+++ b/shared/sdk/RETypeDB.cpp
@@ -392,6 +392,9 @@ const char* REMethodDefinition::get_name() const {
     return tdb->get_string(name_offset);
 }
 
+std::unordered_set<REMethodDefinition*> logged_encoded_0_methods{};
+std::shared_mutex logged_encoded_0_methods_mtx{};
+
 void* REMethodDefinition::get_function() const {
 #if TDB_VER >= 71
     if (this->encoded_offset == 0) {
@@ -416,6 +419,17 @@ void* REMethodDefinition::get_function() const {
             }
         }*/
 
+        {
+            std::shared_lock _{ logged_encoded_0_methods_mtx };
+
+            if (logged_encoded_0_methods.contains(const_cast<REMethodDefinition*>(this))) {
+                return nullptr;
+            }
+        }
+
+        std::unique_lock _{ logged_encoded_0_methods_mtx };
+        logged_encoded_0_methods.insert(const_cast<REMethodDefinition*>(this));
+
         auto decl_type = this->get_declaring_type();
         auto name = decl_type != nullptr ? decl_type->get_full_name() : std::string{"null"};
         spdlog::error("[REMethodDefinition::get_function] Encoded offset is 0 (vindex {}) (method: {}.{})", this->get_virtual_index(), name, this->get_name());
diff --git a/shared/utility/Exceptions.cpp b/shared/utility/Exceptions.cpp
new file mode 100644
index 000000000..cf9ec4415
--- /dev/null
+++ b/shared/utility/Exceptions.cpp
@@ -0,0 +1,101 @@
+#include <windows.h>
+#include <dbghelp.h>
+#include <spdlog/spdlog.h>
+
+#include <utility/Module.hpp>
+
+#include "Exceptions.hpp"
+
+namespace utility {
+namespace exceptions{
+static bool symbols_initialized = false;
+static HANDLE process{};
+
+void dump_callstack(EXCEPTION_POINTERS* exception) {
+    const auto dbghelp = LoadLibraryA("dbghelp.dll");
+
+    if (dbghelp == nullptr) {
+        spdlog::error("Failed to load dbghelp.dll");
+    }
+
+    const auto sym_initialize = (decltype(&SymInitialize))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymInitialize") : nullptr);
+    const auto sym_from_addr = (decltype(&SymFromAddr))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymFromAddr") : nullptr);
+    const auto sym_set_options = (decltype(&SymSetOptions))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymSetOptions") : nullptr);
+    const auto sym_get_line_from_addr64 = (decltype(&SymGetLineFromAddr))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymGetLineFromAddr64") : nullptr);
+    
+    const auto pid = GetCurrentProcessId();
+
+    if (process == nullptr) {
+        process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
+    }
+
+    if (sym_set_options != nullptr) {
+        sym_set_options(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
+    }
+
+    if (!symbols_initialized && sym_initialize != nullptr) {
+        symbols_initialized = sym_initialize(process, NULL, TRUE);
+        if (!symbols_initialized) {
+            spdlog::error("Failed to initialize symbol handler");
+        }
+    }
+
+    constexpr auto max_stack_depth = 100;
+    uintptr_t stack[max_stack_depth]{};
+
+    const auto depth = RtlCaptureStackBackTrace(0, max_stack_depth, (void**)stack, nullptr);
+
+    char symbol_data[sizeof(SYMBOL_INFO) + (256 * sizeof(char))]{};
+    SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbol_data;
+
+    symbol->MaxNameLen = 255;
+    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+
+    spdlog::error("Call stack:");
+    std::string stack_message{"\n"};
+    for (auto i = 0; i < depth; ++i) {
+        bool symbol_found = false;
+        const auto module_within = utility::get_module_within(stack[i]);
+
+        if (sym_from_addr != nullptr && symbols_initialized) {
+            symbol_found = sym_from_addr(process, (DWORD64)stack[i], 0, symbol);
+        }
+
+        std::string symbol_name = symbol_found ? symbol->Name : "Unknown symbol";
+
+        if (sym_get_line_from_addr64 != nullptr && symbols_initialized && symbol_found) {
+            DWORD displacement = 0;
+            IMAGEHLP_LINE64 line{};
+
+            line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+
+            if (sym_get_line_from_addr64(process, (DWORD64)stack[i], &displacement, &line)) {
+                symbol_name += " (";
+                symbol_name += line.FileName;
+                symbol_name += ":";
+                symbol_name += std::to_string(line.LineNumber);
+                symbol_name += ")";
+            }
+        }
+        
+        if (module_within) {
+            const auto module_path = utility::get_module_path(*module_within);
+            const auto relative = stack[i] - (uintptr_t)*module_within;
+
+            if (module_path) {
+                stack_message += fmt::format(" {}\n  {} + 0x{:x}\n\n", symbol_name, *module_path, relative);
+                continue;
+            }
+
+            stack_message += fmt::format(" {}\n  0x{:x} + 0x{:x}\n\n", symbol_name, (uintptr_t)*module_within, relative);
+            continue;
+        }
+
+        stack_message += fmt::format(" {}\n  0x{:x}\n\n", symbol_name, stack[i]);
+    }
+
+    spdlog::error(stack_message);
+    //CloseHandle(process);
+}
+}
+}
\ No newline at end of file
diff --git a/shared/utility/Exceptions.hpp b/shared/utility/Exceptions.hpp
new file mode 100644
index 000000000..3f6a99c5b
--- /dev/null
+++ b/shared/utility/Exceptions.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+namespace utility {
+namespace exceptions {
+void dump_callstack(struct ::_EXCEPTION_POINTERS* exception);
+}
+}
\ No newline at end of file
diff --git a/shared/utility/FunctionHook.cpp b/shared/utility/FunctionHook.cpp
index 514e0e69f..9b007afbc 100644
--- a/shared/utility/FunctionHook.cpp
+++ b/shared/utility/FunctionHook.cpp
@@ -1,76 +1,66 @@
 #include <spdlog/spdlog.h>
-#include <MinHook.h>
+#include <safetyhook/inline_hook.hpp>
 
 #include "FunctionHook.hpp"
 
 using namespace std;
 
 
-bool g_isMinHookInitialized{ false };
-
 FunctionHook::FunctionHook(Address target, Address destination)
-    : m_target{ 0 },
-    m_destination{ 0 },
-    m_original{ 0 }
+    : m_target{ target },
+    m_destination{ destination }
 {
     spdlog::info("Attempting to hook {:p}->{:p}", target.ptr(), destination.ptr());
 
-    // Initialize MinHook if it hasn't been already.
-    if (!g_isMinHookInitialized && MH_Initialize() == MH_OK) {
-        g_isMinHookInitialized = true;
+    try {
+        auto expect = safetyhook::InlineHook::create(safetyhook::Allocator::global(), m_target, m_destination);
+
+        if (!expect) {
+            std::string error = "";
+            switch (expect.error().type) {
+                case safetyhook::InlineHook::Error::BAD_ALLOCATION:
+                    error = "bad allocation";
+                    break;
+                case safetyhook::InlineHook::Error::FAILED_TO_DECODE_INSTRUCTION:
+                    error = "failed to decode instruction";
+                    break;
+                case safetyhook::InlineHook::Error::SHORT_JUMP_IN_TRAMPOLINE:
+                    error = "short jump in trampoline";
+                    break;
+                case safetyhook::InlineHook::Error::IP_RELATIVE_INSTRUCTION_OUT_OF_RANGE:
+                    error = "IP relative instruction out of range";
+                    break;
+                case safetyhook::InlineHook::Error::UNSUPPORTED_INSTRUCTION_IN_TRAMPOLINE:
+                    error = "unsupported instruction in trampoline";
+                    break;
+                case safetyhook::InlineHook::Error::FAILED_TO_UNPROTECT:
+                    error = "failed to unprotect memory";
+                    break;
+                case safetyhook::InlineHook::Error::NOT_ENOUGH_SPACE:
+                    error = "not enough space";
+                    break;
+                default:
+                    error = std::format("unknown error {}", (int32_t)expect.error().type);
+                    break;
+            };
+
+            spdlog::error("Failed to hook {:x}: {}", m_target, error);
+            return;
+        }
+
+        m_inline_hook = std::move(*expect);
+    } catch (const std::exception& e) {
+        spdlog::error("Failed to hook {:x}: {}", m_target, e.what());
+    } catch (...) {
+        spdlog::error("Failed to hook {:x}: unknown exception", m_target);
     }
 
-    // Create the hook. Call create afterwards to prevent race conditions accessing FunctionHook before it leaves its constructor.
-    if (auto status = MH_CreateHook(target.as<LPVOID>(), destination.as<LPVOID>(), (LPVOID*)&m_original); status == MH_OK) {
-        m_target = target;
-        m_destination = destination;
-
-        spdlog::info("Hook init successful {:p}->{:p}", target.ptr(), destination.ptr());
-    }
-    else {
-        spdlog::error("Failed to hook {:p}: {}", target.ptr(), MH_StatusToString(status));
+    if (m_inline_hook) {
+        spdlog::info("Hooked {:x}->{:x}", m_target, m_destination);
+    } else {
+        spdlog::error("Failed to hook {:x}", m_target);
     }
 }
 
 FunctionHook::~FunctionHook() {
-    remove();
-}
-
-bool FunctionHook::create() {
-    if (m_target == 0 || m_destination == 0 || m_original == 0) {
-        spdlog::error("FunctionHook not initialized");
-        return false;
-    }
-
-    if (auto status = MH_EnableHook((LPVOID)m_target); status != MH_OK) {
-        m_original = 0;
-        m_destination = 0;
-        m_target = 0;
-
-        spdlog::error("Failed to hook {:x}: {}", m_target, MH_StatusToString(status));
-        return false;
-    }
-
-    spdlog::info("Hooked {:x}->{:x}", m_target, m_destination);
-    return true;
 }
-
-bool FunctionHook::remove() {
-    // Don't try to remove invalid hooks.
-    if (m_original == 0) {
-        return true;
-    }
-
-    // Disable then remove the hook.
-    if (MH_DisableHook((LPVOID)m_target) != MH_OK ||
-        MH_RemoveHook((LPVOID)m_target) != MH_OK) {
-        return false;
-    }
-
-    // Invalidate the members.
-    m_target = 0;
-    m_destination = 0;
-    m_original = 0;
-
-    return true;
-}
\ No newline at end of file
diff --git a/shared/utility/FunctionHook.hpp b/shared/utility/FunctionHook.hpp
index 1bdcc7456..9813139b0 100644
--- a/shared/utility/FunctionHook.hpp
+++ b/shared/utility/FunctionHook.hpp
@@ -5,6 +5,8 @@
 
 #include <utility/Address.hpp>
 
+#include <safetyhook.hpp>
+
 class FunctionHook {
 public:
     FunctionHook() = delete;
@@ -13,30 +15,25 @@ class FunctionHook {
     FunctionHook(Address target, Address destination);
     virtual ~FunctionHook();
 
-    bool create();
-
-    // Called automatically by the destructor, but you can call it explicitly
-    // if you need to remove the hook.
-    bool remove();
-
     auto get_original() const {
-        return m_original;
+        return m_inline_hook.trampoline().address();
     }
 
     template <typename T>
     T* get_original() const {
-        return (T*)m_original;
+        return m_inline_hook.original<T*>();
     }
 
     auto is_valid() const {
-        return m_original != 0;
+        return m_inline_hook.operator bool();
     }
 
     FunctionHook& operator=(const FunctionHook& other) = delete;
     FunctionHook& operator=(FunctionHook&& other) = delete;
 
 private:
+    SafetyHookInline m_inline_hook;
+
     uintptr_t m_target{ 0 };
     uintptr_t m_destination{ 0 };
-    uintptr_t m_original{ 0 };
 };
\ No newline at end of file
diff --git a/shared/utility/FunctionHookMinHook.cpp b/shared/utility/FunctionHookMinHook.cpp
new file mode 100644
index 000000000..2718e7c59
--- /dev/null
+++ b/shared/utility/FunctionHookMinHook.cpp
@@ -0,0 +1,76 @@
+#include <spdlog/spdlog.h>
+#include <MinHook.h>
+
+#include "FunctionHookMinHook.hpp"
+
+using namespace std;
+
+
+bool g_isMinHookInitialized{ false };
+
+FunctionHookMinHook::FunctionHookMinHook(Address target, Address destination)
+    : m_target{ 0 },
+    m_destination{ 0 },
+    m_original{ 0 }
+{
+    spdlog::info("Attempting to hook {:p}->{:p}", target.ptr(), destination.ptr());
+
+    // Initialize MinHook if it hasn't been already.
+    if (!g_isMinHookInitialized && MH_Initialize() == MH_OK) {
+        g_isMinHookInitialized = true;
+    }
+
+    // Create the hook. Call create afterwards to prevent race conditions accessing FunctionHookMinHook before it leaves its constructor.
+    if (auto status = MH_CreateHook(target.as<LPVOID>(), destination.as<LPVOID>(), (LPVOID*)&m_original); status == MH_OK) {
+        m_target = target;
+        m_destination = destination;
+
+        spdlog::info("Hook init successful {:p}->{:p}", target.ptr(), destination.ptr());
+    }
+    else {
+        spdlog::error("Failed to hook {:p}: {}", target.ptr(), MH_StatusToString(status));
+    }
+}
+
+FunctionHookMinHook::~FunctionHookMinHook() {
+    remove();
+}
+
+bool FunctionHookMinHook::create() {
+    if (m_target == 0 || m_destination == 0 || m_original == 0) {
+        spdlog::error("FunctionHookMinHook not initialized");
+        return false;
+    }
+
+    if (auto status = MH_EnableHook((LPVOID)m_target); status != MH_OK) {
+        m_original = 0;
+        m_destination = 0;
+        m_target = 0;
+
+        spdlog::error("Failed to hook {:x}: {}", m_target, MH_StatusToString(status));
+        return false;
+    }
+
+    spdlog::info("Hooked {:x}->{:x}", m_target, m_destination);
+    return true;
+}
+
+bool FunctionHookMinHook::remove() {
+    // Don't try to remove invalid hooks.
+    if (m_original == 0) {
+        return true;
+    }
+
+    // Disable then remove the hook.
+    if (MH_DisableHook((LPVOID)m_target) != MH_OK ||
+        MH_RemoveHook((LPVOID)m_target) != MH_OK) {
+        return false;
+    }
+
+    // Invalidate the members.
+    m_target = 0;
+    m_destination = 0;
+    m_original = 0;
+
+    return true;
+}
\ No newline at end of file
diff --git a/shared/utility/FunctionHookMinHook.hpp b/shared/utility/FunctionHookMinHook.hpp
new file mode 100644
index 000000000..b9a48d83b
--- /dev/null
+++ b/shared/utility/FunctionHookMinHook.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <windows.h>
+#include <cstdint>
+
+#include <utility/Address.hpp>
+
+class FunctionHookMinHook {
+public:
+    FunctionHookMinHook() = delete;
+    FunctionHookMinHook(const FunctionHookMinHook& other) = delete;
+    FunctionHookMinHook(FunctionHookMinHook&& other) = delete;
+    FunctionHookMinHook(Address target, Address destination);
+    virtual ~FunctionHookMinHook();
+
+    bool create();
+
+    // Called automatically by the destructor, but you can call it explicitly
+    // if you need to remove the hook.
+    bool remove();
+
+    auto get_original() const {
+        return m_original;
+    }
+
+    template <typename T>
+    T* get_original() const {
+        return (T*)m_original;
+    }
+
+    auto is_valid() const {
+        return m_original != 0;
+    }
+
+    FunctionHookMinHook& operator=(const FunctionHookMinHook& other) = delete;
+    FunctionHookMinHook& operator=(FunctionHookMinHook&& other) = delete;
+
+private:
+    uintptr_t m_target{ 0 };
+    uintptr_t m_destination{ 0 };
+    uintptr_t m_original{ 0 };
+};
\ No newline at end of file
diff --git a/src/DInputHook.cpp b/src/DInputHook.cpp
index 875f1bcb8..2e96dd093 100644
--- a/src/DInputHook.cpp
+++ b/src/DInputHook.cpp
@@ -81,7 +81,7 @@ bool DInputHook::hook() {
     // Hook them.
     m_get_device_state_hook = make_unique<FunctionHook>(get_device_state, (uintptr_t)&DInputHook::get_device_state);
 
-    return m_get_device_state_hook->create();
+    return m_get_device_state_hook->is_valid();
 }
 
 HRESULT DInputHook::get_device_state_internal(IDirectInputDevice* device, DWORD size, LPVOID data) {
diff --git a/src/ExceptionHandler.cpp b/src/ExceptionHandler.cpp
index 642fb160f..3e39d81d3 100644
--- a/src/ExceptionHandler.cpp
+++ b/src/ExceptionHandler.cpp
@@ -8,95 +8,11 @@
 #include "utility/Scan.hpp"
 #include "utility/Patch.hpp"
 
+#include "utility/Exceptions.hpp"
+
 #include "REFramework.hpp"
 #include "ExceptionHandler.hpp"
 
-void dump_call_stack(EXCEPTION_POINTERS* exception) {
-    const auto dbghelp = LoadLibraryA("dbghelp.dll");
-
-    if (dbghelp == nullptr) {
-        spdlog::error("Failed to load dbghelp.dll");
-    }
-
-    const auto sym_initialize = (decltype(&SymInitialize))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymInitialize") : nullptr);
-    const auto sym_from_addr = (decltype(&SymFromAddr))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymFromAddr") : nullptr);
-    const auto sym_set_options = (decltype(&SymSetOptions))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymSetOptions") : nullptr);
-    const auto sym_get_line_from_addr64 = (decltype(&SymGetLineFromAddr))(dbghelp != nullptr ? GetProcAddress(dbghelp, "SymGetLineFromAddr64") : nullptr);
-    
-    const auto pid = GetCurrentProcessId();
-    const auto process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
-
-    if (sym_set_options != nullptr) {
-        sym_set_options(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
-    }
-
-    bool initialized = false;
-
-    if (sym_initialize != nullptr) {
-        initialized = sym_initialize(process, NULL, TRUE);
-        if (!initialized) {
-            spdlog::error("Failed to initialize symbol handler");
-        }
-    }
-
-    constexpr auto max_stack_depth = 100;
-    uintptr_t stack[max_stack_depth]{};
-
-    const auto depth = RtlCaptureStackBackTrace(0, max_stack_depth, (void**)stack, nullptr);
-
-    char symbol_data[sizeof(SYMBOL_INFO) + (256 * sizeof(char))]{};
-    SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbol_data;
-
-    symbol->MaxNameLen = 255;
-    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
-
-    spdlog::error("Call stack:");
-    std::string stack_message{"\n"};
-    for (auto i = 0; i < depth; ++i) {
-        bool symbol_found = false;
-        const auto module_within = utility::get_module_within(stack[i]);
-
-        if (sym_from_addr != nullptr && initialized) {
-            symbol_found = sym_from_addr(process, (DWORD64)stack[i], 0, symbol);
-        }
-
-        std::string symbol_name = symbol_found ? symbol->Name : "Unknown symbol";
-
-        if (sym_get_line_from_addr64 != nullptr && initialized && symbol_found) {
-            DWORD displacement = 0;
-            IMAGEHLP_LINE64 line{};
-
-            line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
-
-            if (sym_get_line_from_addr64(process, (DWORD64)stack[i], &displacement, &line)) {
-                symbol_name += " (";
-                symbol_name += line.FileName;
-                symbol_name += ":";
-                symbol_name += std::to_string(line.LineNumber);
-                symbol_name += ")";
-            }
-        }
-        
-        if (module_within) {
-            const auto module_path = utility::get_module_path(*module_within);
-            const auto relative = stack[i] - (uintptr_t)*module_within;
-
-            if (module_path) {
-                stack_message += fmt::format(" {}\n  {} + 0x{:x}\n\n", symbol_name, *module_path, relative);
-                continue;
-            }
-
-            stack_message += fmt::format(" {}\n  0x{:x} + 0x{:x}\n\n", symbol_name, (uintptr_t)*module_within, relative);
-            continue;
-        }
-
-        stack_message += fmt::format(" {}\n  0x{:x}\n\n", symbol_name, stack[i]);
-    }
-
-    spdlog::error(stack_message);
-    CloseHandle(process);
-}
-
 LONG WINAPI reframework::global_exception_handler(struct _EXCEPTION_POINTERS* ei) {
     static std::recursive_mutex mtx{};
     std::scoped_lock _{ mtx };
@@ -129,7 +45,7 @@ LONG WINAPI reframework::global_exception_handler(struct _EXCEPTION_POINTERS* ei
     spdlog::error("GS: {:x}", ei->ContextRecord->SegGs);
     spdlog::error("SS: {:x}", ei->ContextRecord->SegSs);
 
-    dump_call_stack(ei);
+    utility::exceptions::dump_callstack(ei);
 
     const auto module_within = utility::get_module_within(ei->ContextRecord->Rip);
 
diff --git a/src/HookManager.cpp b/src/HookManager.cpp
index f6a15a196..16186561b 100644
--- a/src/HookManager.cpp
+++ b/src/HookManager.cpp
@@ -57,11 +57,16 @@ HookManager::HookedFn::~HookedFn() {
 }
 
 HookManager::PreHookResult HookManager::HookedFn::on_pre_hook() {
+    std::shared_lock _{this->access_mux};
+
     auto any_skipped = false;
 
+    auto storage = get_storage(this);
+    const auto ret_addr_pre = storage->ret_addr_pre;
+
     for (const auto& cb : cbs) {
         if (cb.pre_fn) {
-            if (cb.pre_fn(args, arg_tys, ret_addr_pre) == PreHookResult::SKIP_ORIGINAL) {
+            if (cb.pre_fn(storage->args_impl, arg_tys, ret_addr_pre) == PreHookResult::SKIP_ORIGINAL) {
                 any_skipped = true;
             }
         }
@@ -71,6 +76,12 @@ HookManager::PreHookResult HookManager::HookedFn::on_pre_hook() {
 }
 
 void HookManager::HookedFn::on_post_hook() {
+    std::shared_lock _{this->access_mux};
+
+    auto storage = get_storage(this);
+    auto& ret_val = storage->ret_val;
+    auto& ret_addr = storage->ret_addr;
+
     for (const auto& cb : cbs) {
         if (cb.post_fn) {
             cb.post_fn(ret_val, ret_ty, ret_addr);
@@ -79,7 +90,7 @@ void HookManager::HookedFn::on_post_hook() {
 }
 
 void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedFn>& hook, sdk::REMethodDefinition* fn, std::function<uintptr_t ()> hook_initialization, std::function<void ()> hook_create) {
-    auto& args = hook->args;
+    auto& args = hook->get_storage(hook.get())->args_impl;
     auto& arg_tys = hook->arg_tys;
     auto& fn_hook = hook->fn_hook;
 
@@ -96,33 +107,42 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
     // + 2 for the thread context + this pointer.
     // Another + 2 for hidden arguments that we may not know about.
     constexpr auto HIDDEN_ARGUMENT_COUNT = 2;
-    args.resize(size_t(2) + HIDDEN_ARGUMENT_COUNT + fn->get_num_params());
+    //args.resize(size_t(2) + HIDDEN_ARGUMENT_COUNT + fn->get_num_params());
 
     // Generate the facilitator function that will store the arguments, call on_hook, 
     // restore the arguments, and call the original function.
     auto hook_label = a.newLabel();
-    auto args_label = a.newLabel();
-    auto this_label = a.newLabel();
     auto on_pre_hook_label = a.newLabel();
     auto on_post_hook_label = a.newLabel();
-    auto ret_addr_pre_label = a.newLabel();
-    auto ret_addr_label = a.newLabel();
-    auto ret_val_label = a.newLabel();
     auto orig_label = a.newLabel();
+    auto get_storage_label = a.newLabel();
     auto lock_label = a.newLabel();
     auto unlock_label = a.newLabel();
 
+
+    constexpr size_t STACK_STORAGE_AMOUNT = 80;
+
     // Save state.
+    a.push(rbx);
+
     a.push(rcx);
     a.push(rdx);
     a.push(r8);
     a.push(r9);
-
     // Lock context.
+
+
+    // Fix stack.
+    a.mov(rbx, rsp);
+    a.sub(rsp, STACK_STORAGE_AMOUNT);
+    a.and_(rsp, -16);
+
+    //a.call(ptr(lock_label));
     a.mov(rcx, ptr(hook_label));
-    a.sub(rsp, 40);
-    a.call(ptr(lock_label));
-    a.add(rsp, 40);
+    a.call(ptr(get_storage_label));
+
+    // restore stack
+    a.mov(rsp, rbx);
 
     // Restore state.
     a.pop(r9);
@@ -130,15 +150,28 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
     a.pop(rdx);
     a.pop(rcx);
 
+    // restore rbx
+    a.pop(rbx);
+
+    // store original rbx in storage so we can continue to use it as rsp storage.
+    constexpr auto rbx_offset = offsetof(HookedFn::HookStorage, rbx);
+    a.mov(ptr(rax, rbx_offset), rbx);
+
+
     // Save return address (pre-hook).
     // Cannot modify the post version as it will corrupt the stack if the hook is recursive.
     a.mov(r10, ptr(rsp));
-    a.mov(rax, ptr(ret_addr_pre_label));
-    a.mov(ptr(rax), r10);
+    //a.mov(rax, ptr(ret_addr_pre_label));
+    a.mov(ptr(rax, offsetof(HookedFn::HookStorage, ret_addr_pre)), r10);
+    a.mov(r10, rax); // save storage ptr for later.
+    a.mov(rax, ptr(rax)); // args ptr now.
+
+    constexpr auto hook_args_offset = offsetof(HookedFn::HookStorage, args);
+    static_assert(hook_args_offset == 0, "HookedFn::HookStorage::args offset is not 0");
 
     // Store args.
     // TODO: Handle all the arguments the function takes.
-    a.mov(rax, ptr(args_label));
+    //a.mov(rax, ptr(args_label));
     a.mov(ptr(rax), rcx); // current thread context.
 
     auto args_start_offset = 8;
@@ -177,8 +210,8 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
         default:
             // stack args
             if (args_offset >= 32) {
-                a.mov(r10, ptr(rsp, sizeof(void*) + (args_offset)));
-                a.mov(ptr(rax, args_offset), r10);
+                a.mov(r11, ptr(rsp, sizeof(void*) + (args_offset)));
+                a.mov(ptr(rax, args_offset), r11);
             }
 
             break;
@@ -206,15 +239,24 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
 
     // Call on_pre_hook.
     a.mov(rcx, ptr(hook_label));
-    a.sub(rsp, 40);
+
+    // fix stack
+    a.push(r10); // push storage
+    a.mov(rbx, rsp);
+    a.sub(rsp, STACK_STORAGE_AMOUNT);
+    a.and_(rsp, -16);
+
     a.call(ptr(on_pre_hook_label));
-    a.add(rsp, 40);
 
     // Save the return value so we can see if we need to call the original later.
     a.mov(r11, rax);
+    
+    // restore rsp
+    a.mov(rsp, rbx);
+    a.pop(r10); // restore storage
 
     // Restore args.
-    a.mov(rax, ptr(args_label));
+    a.mov(rax, ptr(r10)); // set up args ptr from storage.
     a.mov(rcx, ptr(rax)); // current thread context.
 
     if (!fn->is_static()) {
@@ -249,8 +291,10 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
 
         default:
             if (args_offset >= 32) {
-                a.mov(r10, ptr(rax, args_offset));
-                a.mov(ptr(rsp, sizeof(void*) + (args_offset)), r10);
+                a.mov(rax, ptr(r10));
+                a.mov(rax, ptr(rax, args_offset));
+                a.mov(ptr(rsp, sizeof(void*) + (args_offset)), rax);
+                //a.mov(rax, ptr(r10)); // deref storage.
             }
 
             // TODO: handle stack args.
@@ -280,14 +324,20 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
     auto skip_label = a.newLabel();
 
     // Save return address.
-    a.mov(r10, ptr(rsp));
-    a.mov(rax, ptr(ret_addr_label));
-    a.mov(ptr(rax), r10);
+    a.mov(rax, ptr(rsp));
+    //a.mov(rax, ptr(ret_addr_label));
+    constexpr auto ret_addr_offset = offsetof(HookedFn::HookStorage, ret_addr);
+    a.mov(ptr(r10, ret_addr_offset), rax);
+    //a.mov(r10, rax); // save storage ptr for later.
 
     // Overwrite return address.
     a.lea(rax, ptr(ret_label));
     a.mov(ptr(rsp), rax);
 
+    // Store off our HookStorage in RBX.
+    // RBX is safe if the called function respects the ABI.
+    a.mov(rbx, r10);
+
     // Determine if we need to skip the original function or not.
     a.cmp(r11, (int)PreHookResult::CALL_ORIGINAL);
     a.jnz(skip_label);
@@ -300,69 +350,61 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
 
     a.bind(ret_label);
 
-    // Save return value.
-    a.mov(rcx, ptr(ret_val_label));
+    // Set hook storage back to R10.
+    a.mov(r10, rbx);
+
+    constexpr auto ret_val_offset = offsetof(HookedFn::HookStorage, ret_val);
+    //a.lea(rcx, ptr(r10, ret_val_offset));
 
     auto is_ret_ty_float = hook->ret_ty->get_full_name() == "System.Single";
 
     if (is_ret_ty_float) {
-        a.movq(ptr(rcx), xmm0);
+        a.movq(ptr(r10, ret_val_offset), xmm0);
     } else {
-        a.mov(ptr(rcx), rax);
+        a.mov(ptr(r10, ret_val_offset), rax);
     }
 
+    a.push(r10);
+
     // Call on_post_hook.
+    a.mov(rbx, rsp);
+    a.sub(rsp, STACK_STORAGE_AMOUNT);
+    a.and_(rsp, -16);
+
     a.mov(rcx, ptr(hook_label));
     a.call(ptr(on_post_hook_label));
+    
+    a.mov(rsp, rbx);
+    
+    a.pop(r10);
 
-    // Restore return value.
-    a.mov(rcx, ptr(ret_val_label));
+    // Restore return value and RBX.
+    //a.mov(rcx, ptr(ret_val_label));
+    a.mov(rbx, ptr(r10, rbx_offset));
 
     if (is_ret_ty_float) {
-        a.movq(xmm0, ptr(rcx));
+        a.movq(xmm0, ptr(r10, ret_val_offset));
     } else {
-        a.mov(rax, ptr(rcx));
+        a.mov(rax, ptr(r10, ret_val_offset));
     }
 
-    // Store state.
-    a.push(rax);
-    a.mov(r10, ptr(ret_addr_label));
-    a.mov(r10, ptr(r10));
-    a.push(r10);
-
-    // Unlock context.
-    a.mov(rcx, ptr(hook_label));
-    a.sub(rsp, 32);
-    a.call(ptr(unlock_label));
-    a.add(rsp, 32);
-
-    // Restore state.
-    a.pop(r10);
-    a.pop(rax);
+    a.mov(r10, ptr(r10, ret_addr_offset)); // ret addr
 
     // Return.
     a.jmp(r10);
 
     a.bind(hook_label);
     a.dq((uint64_t)hook.get());
-    a.bind(args_label);
-    a.dq((uint64_t)args.data());
-    a.bind(this_label);
-    a.dq((uint64_t)this);
     a.bind(on_pre_hook_label);
     a.dq((uint64_t)&HookedFn::on_pre_hook_static);
     a.bind(on_post_hook_label);
     a.dq((uint64_t)&HookedFn::on_post_hook_static);
+    a.bind(get_storage_label);
+    a.dq((uint64_t)&HookedFn::get_storage);
     a.bind(lock_label);
     a.dq((uint64_t)&HookedFn::lock_static);
     a.bind(unlock_label);
     a.dq((uint64_t)&HookedFn::unlock_static);
-    a.bind(ret_addr_pre_label);
-    a.dq((uint64_t)&hook->ret_addr_pre);
-    a.bind(ret_addr_label);
-    a.dq((uint64_t)&hook->ret_addr);
-    a.bind(ret_val_label);
-    a.dq((uint64_t)&hook->ret_val);
     a.bind(orig_label);
     // Can't do the following because the hook hasn't been created yet.
     //a.dq(fn_hook->get_original());
@@ -371,11 +413,6 @@ void HookManager::create_jitted_facilitator(std::unique_ptr<HookManager::HookedF
     m_jit.add(&hook->facilitator_fn, &code);
 
     *(uintptr_t*)(hook->facilitator_fn + code.labelOffsetFromBase(orig_label)) = hook_initialization();
-
-    // because FunctionHook isn't RAII
-    if (hook_create) {
-        hook_create();
-    }
 }
 
 HookManager::HookId HookManager::add(sdk::REMethodDefinition* fn, HookManager::PreHookFn pre_fn, HookManager::PostHookFn post_fn, bool ignore_jmp) {
@@ -399,6 +436,7 @@ HookManager::HookId HookManager::add(sdk::REMethodDefinition* fn, HookManager::P
 
         auto& hook = search->second;
         std::scoped_lock _{hook->mux};
+        std::unique_lock __{hook->access_mux};
         auto hook_id = m_next_hook_id++;
 
         spdlog::info("[HookManager] Hook assigned ID {}", hook_id);
@@ -413,6 +451,7 @@ HookManager::HookId HookManager::add(sdk::REMethodDefinition* fn, HookManager::P
     spdlog::info("[HookManager] Creating a new hook...");
 
     auto hook = std::make_unique<HookedFn>(*this);
+    hook->fn_def = fn;
     hook->next_hook_id = m_next_hook_id++;
 
     auto hook_id = m_next_hook_id++;
@@ -425,8 +464,8 @@ HookManager::HookId HookManager::add(sdk::REMethodDefinition* fn, HookManager::P
     hook->ret_ty = fn->get_return_type();
     
 
-    auto& args = hook->args;
-    auto& arg_tys = hook->arg_tys;
+    //auto& args = hook->args_impl;
+    //auto& arg_tys = hook->arg_tys;
     auto& fn_hook = hook->fn_hook;
 
     // Create the facilitator! this really important!
@@ -436,7 +475,6 @@ HookManager::HookId HookManager::add(sdk::REMethodDefinition* fn, HookManager::P
             return fn_hook->get_original();
         },
         [&]() {
-            fn_hook->create();
         }
     );
 
@@ -503,6 +541,8 @@ HookManager::HookId HookManager::add_vtable(::REManagedObject* obj, sdk::REMetho
 
         auto& hook_fn = it->second;
 
+        std::unique_lock _{hook_fn->access_mux};
+
         auto hook_id = m_next_hook_id++;
         hook_fn->cbs.emplace_back(hook_id, std::move(pre_fn), std::move(post_fn));
 
@@ -516,6 +556,7 @@ HookManager::HookId HookManager::add_vtable(::REManagedObject* obj, sdk::REMetho
     hook->hooked_fns[fn] = std::make_unique<HookedFn>(*this);
 
     auto& hook_fn = hook->hooked_fns[fn];
+    hook_fn->fn_def = fn;
     hook_fn->next_hook_id = m_next_hook_id++;
     auto hook_id = m_next_hook_id++;
 
@@ -527,8 +568,8 @@ HookManager::HookId HookManager::add_vtable(::REManagedObject* obj, sdk::REMetho
     hook_fn->ret_ty = fn->get_return_type();
     
 
-    auto& args = hook_fn->args;
-    auto& arg_tys = hook_fn->arg_tys;
+    //auto& args = hook_fn->args;
+    //auto& arg_tys = hook_fn->arg_tys;
 
     // Create the facilitator! this really important!
     create_jitted_facilitator(hook_fn, fn,
@@ -558,6 +599,7 @@ void HookManager::remove(sdk::REMethodDefinition* fn, HookId id) {
         auto& hook = search->second;
         auto& cbs = hook->cbs;
         std::scoped_lock _{hook->mux};
+        std::unique_lock __{hook->access_mux};
         cbs.erase(std::remove_if(cbs.begin(), cbs.end(), [id](const HookCallback& cb) { return cb.id == id; }));
     } else {
         std::vector<::REManagedObject*> queued_vtable_deletions{};
diff --git a/src/HookManager.hpp b/src/HookManager.hpp
index 7f1c3bb55..4a8c2425d 100644
--- a/src/HookManager.hpp
+++ b/src/HookManager.hpp
@@ -49,23 +49,58 @@ class HookManager {
         HookId next_hook_id{};
         std::unique_ptr<FunctionHook> fn_hook{};
         uintptr_t facilitator_fn{};
-        std::vector<uintptr_t> args{};
+        //std::vector<uintptr_t> args{};
         std::vector<sdk::RETypeDefinition*> arg_tys{};
-        uintptr_t ret_addr_pre{};
-        uintptr_t ret_addr{};
-        uintptr_t ret_val{};
+        //uintptr_t ret_addr_pre{};
+        //uintptr_t ret_addr{};
+        //uintptr_t ret_val{};
+        sdk::REMethodDefinition* fn_def{};
         sdk::RETypeDefinition* ret_ty{};
         std::recursive_mutex mux{};
+        std::shared_mutex access_mux{};
 
         bool is_virtual{false};
         HookedVTable* vtable{nullptr};
 
+        struct HookStorage {
+            size_t* args{};
+            uintptr_t This{};
+            uintptr_t ret_addr_pre{};
+            uintptr_t ret_addr{};
+            uintptr_t ret_val{};
+            uintptr_t rbx{};
+            std::vector<size_t> args_impl{};
+        };
+
+        // Thread->storage
+        std::unordered_map<size_t, std::unique_ptr<HookStorage>> thread_storage{};
+        std::shared_mutex storage_mux{};
+
         HookedFn(HookManager& hm);
         ~HookedFn();
 
         PreHookResult on_pre_hook();
         void on_post_hook();
 
+        __declspec(noinline) static HookStorage* get_storage(HookedFn* fn) {
+            auto tid = std::hash<std::thread::id>{}(std::this_thread::get_id());
+            {
+                std::shared_lock _{fn->storage_mux};
+
+                if (auto it = fn->thread_storage.find(tid); it != fn->thread_storage.end()) {
+                    return it->second.get();
+                }
+            }
+
+            std::unique_lock _{fn->storage_mux};
+            auto& ts = fn->thread_storage[tid];
+            ts = std::make_unique<HookStorage>();
+            ts->args_impl.resize(size_t(2) + 2 + fn->fn_def->get_num_params());
+            ts->args = ts->args_impl.data();
+
+            return ts.get();
+        }
+
         __declspec(noinline) static void lock_static(HookedFn* fn) {
             fn->mux.lock();
 
diff --git a/src/Main.cpp b/src/Main.cpp
index e5c3b03c2..e54eb5205 100644
--- a/src/Main.cpp
+++ b/src/Main.cpp
@@ -7,6 +7,8 @@
 #include <utility/Module.hpp>
 #include <utility/Thread.hpp>
 
+#include <safetyhook/allocator.hpp>
+
 #include "mods/IntegrityCheckBypass.hpp"
 #include "ExceptionHandler.hpp"
 #include "REFramework.hpp"
@@ -76,12 +78,29 @@ void startup_thread(HMODULE reframework_module) {
             utility::spoof_module_paths_in_exe_dir();
             utility::unlink(*our_dll);
         }
+#elif defined (DD2)
+        utility::spoof_module_paths_in_exe_dir();
 #endif
     }
 }
 
 BOOL APIENTRY DllMain(HANDLE handle, DWORD reason, LPVOID reserved) {
     if (reason == DLL_PROCESS_ATTACH) {
+        const auto game = utility::get_executable();
+        const auto module_size = utility::get_module_size(game).value_or(0);
+        const auto halfway_module = (uintptr_t)game + (module_size / 2);
+
+        // Need to pin the safetyhook allocator because it destroys itself
+        static auto sh_allocator = safetyhook::Allocator::global();
+        // 1MB
+        intptr_t requested_size = 1 * 1024 * 1024;
+        // Keep attempting to allocate and reduce requested size by 1 page until successful
+        // 1MB is just the higher end of the range, it will allocate less if it can
+        // even 10kb would be enough for a decent amount of hooks, but we want as much as we can near the middle
+        while (requested_size > 0 && !sh_allocator->allocate_near({(uint8_t*)halfway_module}, requested_size)) {
+            requested_size -= 0x1000; // Size of page
+        }
+
         IntegrityCheckBypass::setup_pristine_syscall();
 
         CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)startup_thread, handle, 0, nullptr);
diff --git a/src/REFramework.cpp b/src/REFramework.cpp
index ba341f7cb..e6f8a375d 100644
--- a/src/REFramework.cpp
+++ b/src/REFramework.cpp
@@ -1556,7 +1556,7 @@ bool REFramework::initialize_game_data() {
         std::scoped_lock _{this->m_startup_mutex};
 
         try {
-#if defined(MHRISE)
+#if defined(MHRISE) || defined(DD2)
             utility::spoof_module_paths_in_exe_dir();
 #endif
             reframework::initialize_sdk();
@@ -1623,7 +1623,7 @@ bool REFramework::initialize_game_data() {
             spdlog::error("Initialization of mods failed. Reason: exception thrown.");
         }
 
-#if defined(MHRISE)
+#if defined(MHRISE) || defined(DD2)
         utility::spoof_module_paths_in_exe_dir();
 #endif
         spdlog::info("Game data initialization thread finished");
diff --git a/src/mods/Hooks.cpp b/src/mods/Hooks.cpp
index cb792f168..4cfd0e9c1 100644
--- a/src/mods/Hooks.cpp
+++ b/src/mods/Hooks.cpp
@@ -195,7 +195,7 @@ std::optional<std::string> Hooks::hook_update_transform() {
     // Can be found by breakpointing RETransform's worldTransform
     m_update_transform_hook = std::make_unique<FunctionHook>(update_transform, &update_transform_hook);
 
-    if (!m_update_transform_hook->create()) {
+    if (!m_update_transform_hook->is_valid()) {
         //return "Failed to hook UpdateTransform";
         spdlog::error("Failed to hook UpdateTransform");
         return std::nullopt; // who cares
@@ -231,7 +231,7 @@ std::optional<std::string> Hooks::hook_update_camera_controller() {
     // Can be found by breakpointing camera controller's worldPosition
     m_update_camera_controller_hook = std::make_unique<FunctionHook>(update_camera_controller, &update_camera_controller_hook);
 
-    if (!m_update_camera_controller_hook->create()) {
+    if (!m_update_camera_controller_hook->is_valid()) {
         return "Failed to hook UpdateCameraController";
     }
 #endif
@@ -258,7 +258,7 @@ std::optional<std::string> Hooks::hook_update_camera_controller2() {
     // Can be found by breakpointing camera controller's worldRotation
     m_update_camera_controller2_hook = std::make_unique<FunctionHook>(update_camera_controller2, &update_camera_controller2_hook);
 
-    if (!m_update_camera_controller2_hook->create()) {
+    if (!m_update_camera_controller2_hook->is_valid()) {
         return "Failed to hook Updatecamera_controller2";
     }
 #endif
@@ -306,7 +306,7 @@ std::optional<std::string> Hooks::hook_gui_draw() {
 
     m_gui_draw_hook = std::make_unique<FunctionHook>(gui_draw, &gui_draw_hook);
 
-    if (!m_gui_draw_hook->create()) {
+    if (!m_gui_draw_hook->is_valid()) {
         return "Failed to hook GUI::draw";
     }
 
@@ -337,7 +337,7 @@ std::optional<std::string> Hooks::hook_application_entry(std::string name, std::
 
     hook = std::make_unique<FunctionHook>(func, hook_fn);
 
-    if (!hook->create()) {
+    if (!hook->is_valid()) {
         return "Failed to hook via::Application::" + name;
     }
     
@@ -469,7 +469,7 @@ std::optional<std::string> Hooks::hook_all_application_entries() {
     }
 
     /*for (auto& entry : m_application_entry_hooks) {
-        if (!entry.second->create()) {
+        if (!entry.second->is_valid()) {
             return "Failed to hook via::Application::" + std::string{entry.first};
         }
     }*/
@@ -489,7 +489,7 @@ std::optional<std::string> Hooks::hook_update_before_lock_scene() {
 
     m_update_before_lock_scene_hook = std::make_unique<FunctionHook>(update_before_lock_scene, &update_before_lock_scene_hook);
 
-    if (!m_update_before_lock_scene_hook->create()) {
+    if (!m_update_before_lock_scene_hook->is_valid()) {
         return "Failed to hook via::render::EntityRenderer::updateBeforeLockScene";
     }
 
@@ -532,7 +532,7 @@ std::optional<std::string> Hooks::hook_lightshaft_draw() {
 
     m_lightshaft_draw_hook = std::make_unique<FunctionHook>((uintptr_t)draw, (uintptr_t)&lightshaft_draw_hook);
 
-    if (!m_lightshaft_draw_hook->create()) {
+    if (!m_lightshaft_draw_hook->is_valid()) {
         return "Failed to hook via::render::LightShaft::draw";
     }
 #endif
@@ -563,7 +563,7 @@ std::optional<std::string> Hooks::hook_view_get_size() {
     // Hook the native function
     m_view_get_size_hook = std::make_unique<FunctionHook>(native_func, view_get_size_hook);
 
-    if (!m_view_get_size_hook->create()) {
+    if (!m_view_get_size_hook->is_valid()) {
         return "Hook init failed: via.SceneView.get_Size native function hook failed.";
     }
 
@@ -593,7 +593,7 @@ std::optional<std::string> Hooks::hook_camera_get_projection_matrix() {
     // Hook the native function
     m_camera_get_projection_matrix_hook = std::make_unique<FunctionHook>(native_func, camera_get_projection_matrix_hook);
 
-    if (!m_camera_get_projection_matrix_hook->create()) {
+    if (!m_camera_get_projection_matrix_hook->is_valid()) {
         return "Hook init failed: via.Camera.get_ProjectionMatrix native function hook failed.";
     }
 
@@ -623,7 +623,7 @@ std::optional<std::string> Hooks::hook_camera_get_view_matrix() {
     // Hook the native function
     m_camera_get_view_matrix_hook = std::make_unique<FunctionHook>(native_func, camera_get_view_matrix_hook);
 
-    if (!m_camera_get_view_matrix_hook->create()) {
+    if (!m_camera_get_view_matrix_hook->is_valid()) {
         return "Hook init failed: via.Camera.get_ViewMatrix native function hook failed.";
     }
 
diff --git a/src/mods/Hooks.hpp b/src/mods/Hooks.hpp
index b1c05141d..9546fb693 100644
--- a/src/mods/Hooks.hpp
+++ b/src/mods/Hooks.hpp
@@ -47,12 +47,12 @@ class Hooks : public Mod {
 
         virtual bool hook_draw(Address target) {
             draw_hook = std::make_unique<FunctionHook>(target, &RenderLayerHook<T>::draw);
-            return draw_hook->create();
+            return draw_hook->is_valid();
         }
 
         virtual bool hook_update(Address target) {
             update_hook = std::make_unique<FunctionHook>(target, &RenderLayerHook<T>::update);
-            return update_hook->create();
+            return update_hook->is_valid();
         }
 
         operator RenderLayerHook<sdk::renderer::RenderLayer>&() {
diff --git a/src/mods/IntegrityCheckBypass.cpp b/src/mods/IntegrityCheckBypass.cpp
index 34ec26ccd..1856885ac 100644
--- a/src/mods/IntegrityCheckBypass.cpp
+++ b/src/mods/IntegrityCheckBypass.cpp
@@ -612,7 +612,7 @@ void IntegrityCheckBypass::fix_virtual_protect() try {
     setup_pristine_syscall(); // Called earlier in DllMain
 
     // Hook VirtualProtect
-    s_virtual_protect_hook = std::make_unique<FunctionHook>(VirtualProtect, (uintptr_t)virtual_protect_hook);
+    s_virtual_protect_hook = std::make_unique<FunctionHookMinHook>(VirtualProtect, (uintptr_t)virtual_protect_hook);
     if (!s_virtual_protect_hook->create()) {
         spdlog::error("[IntegrityCheckBypass]: Could not hook VirtualProtect!");
         return;
diff --git a/src/mods/IntegrityCheckBypass.hpp b/src/mods/IntegrityCheckBypass.hpp
index c9ac76ec7..ec035e8ee 100644
--- a/src/mods/IntegrityCheckBypass.hpp
+++ b/src/mods/IntegrityCheckBypass.hpp
@@ -6,6 +6,7 @@
 #include "Mod.hpp"
 #include "utility/Patch.hpp"
 #include "utility/FunctionHook.hpp"
+#include "utility/FunctionHookMinHook.hpp"
 
 // Always on for RE3
 // Because we use hooks that modify the integrity of the executable
@@ -32,10 +33,10 @@ class IntegrityCheckBypass : public Mod {
     
     using NtProtectVirtualMemory_t =  NTSTATUS(NTAPI*)(HANDLE ProcessHandle, PVOID* BaseAddress, SIZE_T* NumberOfBytesToProtect, ULONG NewAccessProtection, PULONG OldAccessProtection);
     static inline NtProtectVirtualMemory_t s_pristine_protect_virtual_memory{ nullptr };
-    static inline NtProtectVirtualMemory_t s_og_protect_virtual_memory{ nullptr };
+    static inline NtProtectVirtualMemory_t s_og_protect_virtual_memory{ nullptr };;
 
-    static inline std::unique_ptr<FunctionHook> s_get_proc_address_hook{};
-    static inline std::unique_ptr<FunctionHook> s_virtual_protect_hook{};
+    // Using minhook because safetyhook crashes on trying to hook VirtualProtect
+    static inline std::unique_ptr<FunctionHookMinHook> s_virtual_protect_hook{};
 
 #ifdef RE3
     // This is what the game uses to bypass its integrity checks altogether or something
diff --git a/src/mods/VR.cpp b/src/mods/VR.cpp
index 5115861d2..f42e8a3c6 100644
--- a/src/mods/VR.cpp
+++ b/src/mods/VR.cpp
@@ -1126,7 +1126,7 @@ std::optional<std::string> VR::hijack_input() {
     // Hook the native function
     g_input_hook = std::make_unique<FunctionHook>(func, inputsystem_update_hook);
 
-    if (!g_input_hook->create()) {
+    if (!g_input_hook->is_valid()) {
         return "VR init failed: InputSystem.update native function hook failed.";
     }
 #endif
@@ -1157,7 +1157,7 @@ std::optional<std::string> VR::hijack_camera() {
                 // Hook the native function
                 g_projection_matrix_hook2 = std::make_unique<FunctionHook>(native_func, gui_camera_get_projection_matrix_hook);
 
-                if (g_projection_matrix_hook2->create()) {
+                if (g_projection_matrix_hook2->is_valid()) {
                     spdlog::info("Hooked via.gui.GUICamera.get_ProjectionMatrix");
                 }
             } else {
@@ -1232,7 +1232,7 @@ std::optional<std::string> VR::hijack_wwise_listeners() {
 
     g_wwise_listener_update_hook = std::make_unique<FunctionHook>(update_native, wwise_listener_update_hook);
 
-    if (!g_wwise_listener_update_hook->create()) {
+    if (!g_wwise_listener_update_hook->is_valid()) {
         return "VR init failed: via.wwise.WwiseListener update native function hook failed.";
     }
 #endif
diff --git a/src/mods/tools/ObjectExplorer.cpp b/src/mods/tools/ObjectExplorer.cpp
index 42e56e372..101ac212d 100644
--- a/src/mods/tools/ObjectExplorer.cpp
+++ b/src/mods/tools/ObjectExplorer.cpp
@@ -645,7 +645,7 @@ void ObjectExplorer::on_frame() {
         // on_frame is just going to be a way to display
         // the pinned objects in a separate window
 
-        ImGui::SetNextWindowSize(ImVec2(400, 400), ImGuiCond_::ImGuiCond_Once);
+        ImGui::SetNextWindowSize(ImVec2(400, 800), ImGuiCond_::ImGuiCond_Once);
         if (ImGui::Begin("Hooked methods", &open)) {
             display_hooks();
 
@@ -726,11 +726,21 @@ void ObjectExplorer::display_hooks() {
             return a->call_count > b->call_count;
         });
         break;
-    case HooksContext::SortMethod::CALL_TIME:
+    case HooksContext::SortMethod::CALL_TIME_LAST:
         std::sort(hooks_to_iterate.begin(), hooks_to_iterate.end(), [](const auto& a, const auto& b) {
             return a->last_call_time > b->last_call_time;
         });
         break;
+    case HooksContext::SortMethod::CALL_TIME_DELTA:
+        std::sort(hooks_to_iterate.begin(), hooks_to_iterate.end(), [](const auto& a, const auto& b) {
+            return a->last_call_delta > b->last_call_delta;
+        });
+        break;
+    case HooksContext::SortMethod::CALL_TIME_TOTAL:
+        std::sort(hooks_to_iterate.begin(), hooks_to_iterate.end(), [](const auto& a, const auto& b) {
+            return a->total_call_time > b->total_call_time;
+        });
+        break;
     case HooksContext::SortMethod::METHOD_NAME:
         std::sort(hooks_to_iterate.begin(), hooks_to_iterate.end(), [](const auto& a, const auto& b) {
             return a->name < b->name;
@@ -756,30 +766,79 @@ void ObjectExplorer::display_hooks() {
         if (made_node) {
             ImGui::Checkbox("Skip function call", &h.skip);
             ImGui::TextWrapped("Call count: %i", h.call_count);
-            if (ImGui::TreeNode("Callers")) {
-                for (auto& caller : h.callers) {
-                    const auto& context = h.callers_context[caller];
-                    const auto declaring_type = caller->get_declaring_type();
-                    //auto method_name = declaring_type != nullptr ? declaring_type->get_full_name() + "." + caller->get_name() : caller->get_name();
-                    //method_name += " [" + std::to_string(context.call_count) + "]";
-                    const auto call_count = std::string("[") + std::to_string(context.call_count) + "]";
-
-                    ImGui::TextUnformatted(call_count.c_str());
-                    ImGui::SameLine();
-                    this->attempt_display_method(nullptr, *caller, true);
-                }
 
-                ImGui::TreePop();
-            }
+            ImGui::SameLine();
+            const float delta_ms = std::chrono::duration_cast<std::chrono::duration<float, std::milli>>(h.last_call_delta).count();
+            const float total_ms = std::chrono::duration_cast<std::chrono::duration<float, std::milli>>(h.total_call_time).count();
+            ImGui::TextWrapped("Time (ms): Delta %f, Total %f", delta_ms, total_ms);
+
+            if (ImGui::TreeNode("Info")) {
+                ImGui::SetNextItemOpen(true, ImGuiCond_::ImGuiCond_Once);
+                if (ImGui::TreeNode("Callers")) {
+                    // sort callers combo
+                    if (ImGui::BeginCombo("Sort Callers by", HookedMethod::s_sort_callers_names[(uint8_t)h.sort_callers_method])) {
+                        for (int i = 0; i < HookedMethod::s_sort_callers_names.size(); i++) {
+                            const bool is_selected = (h.sort_callers_method == (HookedMethod::SortCallersMethod)i);
+
+                            if (ImGui::Selectable(HookedMethod::s_sort_callers_names[i], is_selected)) {
+                                h.sort_callers_method = (HookedMethod::SortCallersMethod)i;
+                            }
+
+                            if (is_selected) {
+                                ImGui::SetItemDefaultFocus();
+                            }
+                        }
+
+                        ImGui::EndCombo();
+                    }
+
+                    std::vector<sdk::REMethodDefinition*> callers_to_iterate{};
+
+                    for (auto& caller : h.callers) {
+                        callers_to_iterate.push_back(caller);
+                    }
+
+                    switch (h.sort_callers_method) {
+                    case HookedMethod::SortCallersMethod::CALL_COUNT:
+                        std::sort(callers_to_iterate.begin(), callers_to_iterate.end(), [&h](const auto& a, const auto& b) {
+                            return h.callers_context[a].call_count > h.callers_context[b].call_count;
+                        });
+                        break;
+                    case HookedMethod::SortCallersMethod::METHOD_NAME:
+                        std::sort(callers_to_iterate.begin(), callers_to_iterate.end(), [&h](const auto& a, const auto& b) {
+                            return a->get_name() < b->get_name();
+                        });
+                        break;
+                    default:
+                        break;
+                    };
+
+                    for (auto& caller : callers_to_iterate) {
+                        const auto& context = h.callers_context[caller];
+                        const auto declaring_type = caller->get_declaring_type();
+                        //auto method_name = declaring_type != nullptr ? declaring_type->get_full_name() + "." + caller->get_name() : caller->get_name();
+                        //method_name += " [" + std::to_string(context.call_count) + "]";
+                        const auto call_count = std::string("[") + std::to_string(context.call_count) + "]";
+
+                        ImGui::TextUnformatted(call_count.c_str());
+                        ImGui::SameLine();
+                        this->attempt_display_method(nullptr, *caller, true);
+                    }
+
+                    ImGui::TreePop();
+                }
 
-            if (ImGui::TreeNode("Return Addresses")) {
-                for (auto addr : h.return_addresses) {
-                    ImGui::Text("0x%p", addr);
+                if (ImGui::TreeNode("Return Addresses")) {
+                    for (auto addr : h.return_addresses) {
+                        ImGui::Text("0x%p", addr);
 
-                    if (ImGui::IsItemClicked()) {
-                        ImGui::SetClipboardText((std::stringstream{} << std::hex << addr).str().c_str());
+                        if (ImGui::IsItemClicked()) {
+                            ImGui::SetClipboardText((std::stringstream{} << std::hex << addr).str().c_str());
+                        }
                     }
+                    ImGui::TreePop();
                 }
+
                 ImGui::TreePop();
             }
 
@@ -3041,7 +3100,70 @@ void ObjectExplorer::display_native_fields(REManagedObject* obj, sdk::RETypeDefi
 //#endif
 }
 
+void ObjectExplorer::populate_method_meta_info(sdk::REMethodDefinition& m) {
+    const auto method_ptr = m.get_function();
+
+    if (method_ptr == nullptr) {
+        return;
+    }
+
+    if (m_method_meta_infos.contains((uintptr_t)method_ptr)) {
+        return;
+    }
+
+    m_method_meta_infos[(uintptr_t)method_ptr] = std::make_unique<MethodMetaInfo>();
+
+    if (IsBadReadPtr(method_ptr, sizeof(void*))) {
+        return;
+    }
+
+    std::unordered_set<sdk::REMethodDefinition*> called_functions{};
+
+    // Disassemble the function's instructions looking for calls to other functions, and add them to the list of methods this function calls
+    utility::exhaustive_decode((uint8_t*)method_ptr, 5000, [&](utility::ExhaustionContext& ctx) -> utility::ExhaustionResult {
+        if (ctx.addr != (uintptr_t)method_ptr) {
+            if (auto it = m_method_map.find(ctx.addr); it != m_method_map.end()) {
+                called_functions.insert(it->second);
+            }
+        }
+
+        if (std::string_view{ctx.instrux.Mnemonic}.starts_with("CALL")) {
+            const auto resolved_addr = utility::resolve_displacement(ctx.addr);
+
+            if (resolved_addr) {
+                if (auto it = m_method_map.find(*resolved_addr); it != m_method_map.end()) {
+                    called_functions.insert(it->second);
+                }
+            }
+
+            // Step over all calls, we don't want to go down a rabbit hole that freezes the program
+            return utility::ExhaustionResult::STEP_OVER;
+        }
+
+        return utility::ExhaustionResult::CONTINUE;
+    });
+
+    for (auto& called_function : called_functions) {
+        m_method_meta_infos[(uintptr_t)method_ptr]->called_functions.push_back(called_function);
+    }
+
+    std::sort(
+        m_method_meta_infos[(uintptr_t)method_ptr]->called_functions.begin(), 
+        m_method_meta_infos[(uintptr_t)method_ptr]->called_functions.end(), 
+        [](sdk::REMethodDefinition* a, sdk::REMethodDefinition* b) 
+    {
+        const auto decltype_a = a->get_declaring_type();
+        const auto decltype_b = b->get_declaring_type();
+        const auto fullname_a = decltype_a != nullptr ? decltype_a->get_full_name() + "." + a->get_name() : a->get_name();
+        const auto fullname_b = decltype_b != nullptr ? decltype_b->get_full_name() + "." + b->get_name() : b->get_name();
+        
+        return fullname_a < fullname_b;
+    });
+}
+
 void ObjectExplorer::attempt_display_method(REManagedObject* obj, sdk::REMethodDefinition& m, bool use_full_name) {
+    populate_method_meta_info(m);
+
     const auto declaring_type = m.get_declaring_type();
     const auto method_name = (use_full_name && declaring_type != nullptr) ? declaring_type->get_full_name() + "." + m.get_name() : m.get_name();
     const auto method_return_type = m.get_return_type();
@@ -3181,6 +3303,21 @@ void ObjectExplorer::attempt_display_method(REManagedObject* obj, sdk::REMethodD
             }
         }
 
+        if (ImGui::BeginTable("##calls", 1,  ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable)) {
+            ImGui::TableNextColumn();
+            ImGui::Text("Called Method");
+
+            // Show a list of methods this method calls
+            if (m_method_meta_infos.contains((uintptr_t)method_ptr)) {
+                for (const auto& called_m : m_method_meta_infos[(uintptr_t)method_ptr]->called_functions) {
+                    ImGui::TableNextColumn();
+                    attempt_display_method(nullptr, *called_m, true);
+                }
+            }
+
+            ImGui::EndTable();
+        }
+
         if (ImGui::BeginTable("##disassembly", 3,  ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable)) {
             ImGui::TableNextColumn();
             ImGui::Text("Address");
@@ -3923,32 +4060,47 @@ void ObjectExplorer::hook_method(sdk::REMethodDefinition* method, std::optional<
     }
 
     auto& hooked = m_hooked_methods.emplace_back();
+    hooked.method = method;
+
+    if (name) {
+        hooked.name = method->get_declaring_type()->get_full_name() + "." + *name;
+    } else {
+        hooked.name = method->get_declaring_type()->get_full_name() + "." + method->get_name();
+    }
 
     using namespace asmjit;
     using namespace asmjit::x86;
 
-    CodeHolder code{};
-    code.init(m_jit_runtime.environment());
+    // Pre
+    {
+        CodeHolder code{};
+        code.init(m_jit_runtime.environment());
+        Assembler a{&code};
 
-    Assembler a{&code};
+        a.mov(r9, method);
+        a.movabs(r10, &ObjectExplorer::pre_hooked_method);
+        a.jmp(r10);
 
-    a.mov(r9, method);
-    a.movabs(r10, &ObjectExplorer::pre_hooked_method);
-    a.jmp(r10);
-
-    m_jit_runtime.add(&hooked.jitted_function, &code);
+        m_jit_runtime.add(&hooked.jitted_function, &code);
+    }
 
-    using MT = HookManager::PreHookResult(*)(std::vector<uintptr_t>& args, std::vector<sdk::RETypeDefinition*>& arg_tys, uintptr_t ret_addr);
+    // Post
+    {
+        CodeHolder code{};
+        code.init(m_jit_runtime.environment());
+        Assembler a{&code};
 
-    hooked.method = method;
+        a.mov(r9, method);
+        a.movabs(r10, &ObjectExplorer::post_hooked_method);
+        a.jmp(r10);
 
-    if (name) {
-        hooked.name = method->get_declaring_type()->get_full_name() + "." + *name;
-    } else {
-        hooked.name = method->get_declaring_type()->get_full_name() + "." + method->get_name();
+        m_jit_runtime.add(&hooked.jitted_function_post, &code);
     }
     
-    hooked.hook_id = g_hookman.add(method, (MT)hooked.jitted_function, nullptr);
+    using MT = HookManager::PreHookResult(*)(std::vector<uintptr_t>& args, std::vector<sdk::RETypeDefinition*>& arg_tys, uintptr_t ret_addr);
+    using MTPost = void (*)(uintptr_t& ret_val, sdk::RETypeDefinition* ret_ty, uintptr_t ret_addr);
+
+    hooked.hook_id = g_hookman.add(method, (MT)hooked.jitted_function, (MTPost)hooked.jitted_function_post);
 }
 
 void ObjectExplorer::hook_all_methods(sdk::RETypeDefinition* t) {
@@ -4621,3 +4773,30 @@ HookManager::PreHookResult ObjectExplorer::pre_hooked_method_internal(std::vecto
 HookManager::PreHookResult ObjectExplorer::pre_hooked_method(std::vector<uintptr_t>& args, std::vector<sdk::RETypeDefinition*>& arg_tys, uintptr_t ret_addr, sdk::REMethodDefinition* method) {
     return ObjectExplorer::get()->pre_hooked_method_internal(args, arg_tys, ret_addr, method);
 }
+
+void ObjectExplorer::post_hooked_method_internal(uintptr_t& ret_val, sdk::RETypeDefinition*& ret_ty, uintptr_t ret_addr, sdk::REMethodDefinition* method) {
+    auto it = std::find_if(m_hooked_methods.begin(), m_hooked_methods.end(), [method](auto& a) { return a.method == method; });
+
+    if (it == m_hooked_methods.end()) {
+        return;
+    }
+
+    auto& hooked_method = *it;
+
+    std::scoped_lock _{m_hooks_context.mtx};
+
+    // Reset the last call time if this is the first time we're calling it
+    // because in between this, there will be a large hitch
+    // that the game is not causing.
+    if (hooked_method.call_count <= 1) {
+        hooked_method.last_call_time = std::chrono::high_resolution_clock::now();
+    }
+
+    hooked_method.last_call_end_time = std::chrono::high_resolution_clock::now();
+    hooked_method.last_call_delta = hooked_method.last_call_end_time - hooked_method.last_call_time;
+    hooked_method.total_call_time += hooked_method.last_call_delta;
+}
+
+void ObjectExplorer::post_hooked_method(uintptr_t& ret_val, sdk::RETypeDefinition*& ret_ty, uintptr_t ret_addr, sdk::REMethodDefinition* method) {
+    ObjectExplorer::get()->post_hooked_method_internal(ret_val, ret_ty, ret_addr, method);
+}
diff --git a/src/mods/tools/ObjectExplorer.hpp b/src/mods/tools/ObjectExplorer.hpp
index feb959ccc..5b52c0f8d 100644
--- a/src/mods/tools/ObjectExplorer.hpp
+++ b/src/mods/tools/ObjectExplorer.hpp
@@ -161,6 +161,7 @@ class ObjectExplorer : public Tool {
     void display_reflection_properties(REManagedObject* obj, REType* type_info);
     void display_native_methods(REManagedObject* obj, sdk::RETypeDefinition* tdef);
     void display_native_fields(REManagedObject* obj, sdk::RETypeDefinition* tdef);
+    void populate_method_meta_info(sdk::REMethodDefinition& m);
     void attempt_display_method(REManagedObject* obj, sdk::REMethodDefinition& m, bool use_full_name = false);
     void attempt_display_field(REManagedObject* obj, VariableDescriptor* desc, REType* type_info);
     void display_data(void* data, void* real_data, std::string type_name, bool is_enum = false, bool managed_str = false, const sdk::RETypeDefinition* override_def = nullptr);
@@ -220,6 +221,9 @@ class ObjectExplorer : public Tool {
     HookManager::PreHookResult pre_hooked_method_internal(std::vector<uintptr_t>& args, std::vector<sdk::RETypeDefinition*>& arg_tys, uintptr_t ret_addr, sdk::REMethodDefinition* method);
     static HookManager::PreHookResult pre_hooked_method(std::vector<uintptr_t>& args, std::vector<sdk::RETypeDefinition*>& arg_tys, uintptr_t ret_addr, sdk::REMethodDefinition* method);
 
+    void post_hooked_method_internal(uintptr_t& ret_val, sdk::RETypeDefinition*& ret_ty, uintptr_t ret_addr, sdk::REMethodDefinition* method);
+    static void post_hooked_method(uintptr_t& ret_val, sdk::RETypeDefinition*& ret_ty, uintptr_t ret_addr, sdk::REMethodDefinition* method);
+
     struct PinnedObject {
         Address address{};
         std::string name{};
@@ -230,15 +234,19 @@ class ObjectExplorer : public Tool {
         enum class SortMethod : uint8_t {
             NONE,
             CALL_COUNT,
-            CALL_TIME,
+            CALL_TIME_LAST,
+            CALL_TIME_DELTA,
+            CALL_TIME_TOTAL,
             METHOD_NAME,
             NUMBER_OF_CALLERS
         };
 
-        static inline constexpr std::array<const char*, 5> s_sort_method_names {
+        static inline constexpr std::array<const char*, 7> s_sort_method_names {
             "None",
             "Call Count",
-            "Call Time",
+            "Call Time (Last)",
+            "Call Time (Delta)",
+            "Call Time (Total)",
             "Method Name",
             "Number of Callers"
         };
@@ -252,12 +260,26 @@ class ObjectExplorer : public Tool {
     std::vector<std::function<void()>> m_frame_jobs{};
 
     struct HookedMethod {
+        enum class SortCallersMethod : uint8_t {
+            NONE,
+            CALL_COUNT,
+            METHOD_NAME
+        };
+    
+        static inline constexpr std::array<const char*, 3> s_sort_callers_names {
+            "None",
+            "Call Count",
+            "Method Name"
+        };
+
         std::string name{};
         sdk::REMethodDefinition* method{nullptr};
         uintptr_t jitted_function{};
+        uintptr_t jitted_function_post{};
         bool skip{false};
         size_t hook_id{};
         uint32_t call_count{};
+        SortCallersMethod sort_callers_method{SortCallersMethod::NONE};
 
         std::unordered_set<uintptr_t> return_addresses{};
         std::unordered_map<uintptr_t, sdk::REMethodDefinition*> return_addresses_to_methods{};
@@ -267,9 +289,20 @@ class ObjectExplorer : public Tool {
         };
 
         std::unordered_map<sdk::REMethodDefinition*, CallerContext> callers_context{};
-        std::chrono::high_resolution_clock::time_point last_call_time{};
+        std::chrono::high_resolution_clock::time_point last_call_time{std::chrono::high_resolution_clock::now()};
+        std::chrono::high_resolution_clock::time_point last_call_end_time{std::chrono::high_resolution_clock::now()}; // assuming not recursive...
+        std::chrono::high_resolution_clock::duration last_call_delta{};
+        std::chrono::high_resolution_clock::duration total_call_time{};
     };
 
+    // Contains extra information about the method
+    struct MethodMetaInfo {
+        std::vector<sdk::REMethodDefinition*> called_functions{};
+    };
+
+    // Function address -> meta info (not REMethodDefinition, since method defs can share function addresses)
+    std::unordered_map<uintptr_t, std::unique_ptr<MethodMetaInfo>> m_method_meta_infos{};
+
     asmjit::JitRuntime m_jit_runtime;
 
     std::vector<PinnedObject> m_pinned_objects{};