diff --git a/src/client/component/discord.cpp b/src/client/component/discord.cpp
index 97c3a027..a567fa92 100644
--- a/src/client/component/discord.cpp
+++ b/src/client/component/discord.cpp
@@ -10,7 +10,6 @@
 #include "materials.hpp"
 #include "discord.hpp"
 
-#include "ui_scripting.hpp"
 #include "game/ui_scripting/execution.hpp"
 
 #include <utils/string.hpp>
@@ -187,13 +186,13 @@ namespace discord
 			handlers.ready = ready;
 			handlers.errored = errored;
 			handlers.disconnected = errored;
-			handlers.joinGame = nullptr; //join_game
+			handlers.joinGame = nullptr;
 			handlers.spectateGame = nullptr;
-			handlers.joinRequest = nullptr; //join_request
+			handlers.joinRequest = nullptr;
 
 			Discord_Initialize("947125042930667530", &handlers, 1, nullptr);
 
-			//scheduler::once(download_default_avatar, scheduler::pipeline::async);
+			scheduler::once(download_default_avatar, scheduler::pipeline::async);
 
 			scheduler::once([]()
 			{
diff --git a/src/client/component/input.cpp b/src/client/component/input.cpp
index 45f55e08..d31dc888 100644
--- a/src/client/component/input.cpp
+++ b/src/client/component/input.cpp
@@ -4,7 +4,6 @@
 #include "game/game.hpp"
 
 #include "game_console.hpp"
-#include "ui_scripting.hpp"
 #include "game/ui_scripting/execution.hpp"
 
 #include <utils/hook.hpp>
@@ -18,7 +17,6 @@ namespace input
 
 		void cl_char_event_stub(const int local_client_num, const int key)
 		{
-			/*
 			if (ui_scripting::lui_running())
 			{
 				ui_scripting::notify("keypress",
@@ -27,7 +25,6 @@ namespace input
 					{"key", game::Key_KeynumToString(key, 0, 1)},
 				});
 			}
-			*/
 
 			if (!game_console::console_char_event(local_client_num, key))
 			{
@@ -39,7 +36,6 @@ namespace input
 
 		void cl_key_event_stub(const int local_client_num, const int key, const int down)
 		{
-			/*
 			if (ui_scripting::lui_running())
 			{
 				ui_scripting::notify(down ? "keydown" : "keyup",
@@ -48,7 +44,6 @@ namespace input
 					{"key", game::Key_KeynumToString(key, 0, 1)},
 				});
 			}
-			*/
 
 			if (!game_console::console_key_event(local_client_num, key, down))
 			{
diff --git a/src/client/component/lui.cpp b/src/client/component/lui.cpp
index d8736114..53f652b4 100644
--- a/src/client/component/lui.cpp
+++ b/src/client/component/lui.cpp
@@ -15,14 +15,6 @@ namespace lui
 	public:
 		void post_unpack() override
 		{
-			// Don't show create cod account popup
-			//utils::hook::set<uint32_t>(0x14017C957, 0);
-
-//#ifdef _DEBUG
-			// Enable development menus (causes issues in sp)
-			//utils::hook::set<uint32_t>(SELECT_VALUE(0x1400B4ABC, 0x1401AB779), 1);
-//#endif
-
 			command::add("lui_open", [](const command::params& params)
 			{
 				if (params.size() <= 1)
@@ -55,4 +47,4 @@ namespace lui
 	};
 }
 
-//REGISTER_COMPONENT(lui::component)
+REGISTER_COMPONENT(lui::component)
diff --git a/src/client/component/scheduler.cpp b/src/client/component/scheduler.cpp
index abe01fff..a5ef6f97 100644
--- a/src/client/component/scheduler.cpp
+++ b/src/client/component/scheduler.cpp
@@ -89,7 +89,7 @@ namespace scheduler
 		utils::hook::detour r_end_frame_hook;
 		utils::hook::detour g_run_frame_hook;
 		utils::hook::detour main_frame_hook;
-		//utils::hook::detour hks_frame_hook; //no scripting for now
+		utils::hook::detour hks_frame_hook;
 
 		void execute(const pipeline type)
 		{
@@ -209,7 +209,7 @@ namespace scheduler
 
 			g_run_frame_hook.create(SELECT_VALUE(0x0, 0x417940_b), scheduler::server_frame_stub);
 			main_frame_hook.create(SELECT_VALUE(0x0, 0x3438B0_b), scheduler::main_frame_stub);
-			//hks_frame_hook.create(SELECT_VALUE(0x0, 0x0), scheduler::hks_frame_stub); // no scripting for now
+			hks_frame_hook.create(SELECT_VALUE(0x0, 0x2792E0_b), scheduler::hks_frame_stub);
 		}
 
 		void pre_destroy() override
diff --git a/src/client/component/stats.cpp b/src/client/component/stats.cpp
index 8da3fa78..2684feb1 100644
--- a/src/client/component/stats.cpp
+++ b/src/client/component/stats.cpp
@@ -88,4 +88,4 @@ namespace stats
 	};
 }
 
-// REGISTER_COMPONENT(stats::component)
+REGISTER_COMPONENT(stats::component)
diff --git a/src/client/component/ui_scripting.cpp b/src/client/component/ui_scripting.cpp
index 46bf5332..75b89a0b 100644
--- a/src/client/component/ui_scripting.cpp
+++ b/src/client/component/ui_scripting.cpp
@@ -7,164 +7,339 @@
 #include "scheduler.hpp"
 #include "command.hpp"
 
-#include "ui_scripting.hpp"
+#include "localized_strings.hpp"
+#include "console.hpp"
+#include "game_module.hpp"
+#include "fps.hpp"
+#include "server_list.hpp"
 
-#include "game/ui_scripting/lua/engine.hpp"
 #include "game/ui_scripting/execution.hpp"
-#include "game/ui_scripting/lua/error.hpp"
+#include "game/scripting/execution.hpp"
+
+#include "ui_scripting.hpp"
 
 #include <utils/string.hpp>
 #include <utils/hook.hpp>
+#include <utils/io.hpp>
 
 namespace ui_scripting
 {
 	namespace
 	{
-		std::unordered_map<game::hks::cclosure*, sol::protected_function> converted_functions;
+		std::unordered_map<game::hks::cclosure*, std::function<arguments(const function_arguments& args)>> converted_functions;
 
-		utils::hook::detour hksi_lual_error_hook;
-		utils::hook::detour hksi_lual_error_hook2;
 		utils::hook::detour hks_start_hook;
 		utils::hook::detour hks_shutdown_hook;
-		utils::hook::detour hks_allocator_hook;
-		utils::hook::detour hks_frame_hook;
-		utils::hook::detour lui_error_hook;
-		utils::hook::detour hksi_hks_error_hook;
+		utils::hook::detour hks_package_require_hook;
 
-		bool error_hook_enabled = false;
+		utils::hook::detour hks_load_hook;
+		utils::hook::detour db_find_xasset_header_hook;
 
-		void hksi_lual_error_stub(game::hks::lua_State* s, const char* fmt, ...)
+		struct script
 		{
-			char va_buffer[2048] = {0};
+			std::string name;
+			std::string root;
+		};
 
-			va_list ap;
-			va_start(ap, fmt);
-			vsprintf_s(va_buffer, fmt, ap);
-			va_end(ap);
+		struct globals_t
+		{
+			std::string in_require_script;
+			std::vector<script> loaded_scripts;
+			bool load_raw_script{};
+			std::string raw_script_name{};
+		};
 
-			const auto formatted = std::string(va_buffer);
+		globals_t globals{};
 
-			if (!error_hook_enabled)
+		bool is_loaded_script(const std::string& name)
+		{
+			for (auto i = globals.loaded_scripts.begin(); i != globals.loaded_scripts.end(); ++i)
 			{
-				return hksi_lual_error_hook.invoke<void>(s, formatted.data());
+				if (i->name == name)
+				{
+					return true;
+				}
 			}
 
-			throw std::runtime_error(formatted);
+			return false;
 		}
 
-		int hksi_hks_error_stub(game::hks::lua_State* s, int a2)
+		std::string get_root_script(const std::string& name)
 		{
-			if (!error_hook_enabled)
+			for (auto i = globals.loaded_scripts.begin(); i != globals.loaded_scripts.end(); ++i)
 			{
-				return hksi_hks_error_hook.invoke<int>(s, a2);
+				if (i->name == name)
+				{
+					return i->root;
+				}
 			}
 
-			throw std::runtime_error("unknown error");
+			return {};
 		}
 
-		void lui_error_stub(game::hks::lua_State* s)
+		table get_globals()
 		{
-			if (!error_hook_enabled)
+			const auto state = *game::hks::lua_state;
+			return state->globals.v.table;
+		}
+
+		void print_error(const std::string& error)
+		{
+			console::error("************** LUI script execution error **************\n");
+			console::error("%s\n", error.data());
+			console::error("********************************************************\n");
+		}
+
+		void print_loading_script(const std::string& name)
+		{
+			console::info("Loading LUI script '%s'\n", name.data());
+		}
+
+		std::string get_current_script()
+		{
+			const auto state = *game::hks::lua_state;
+			game::hks::lua_Debug info{};
+			game::hks::hksi_lua_getstack(state, 1, &info);
+			game::hks::hksi_lua_getinfo(state, "nSl", &info);
+			return info.short_src;
+		}
+
+		int load_buffer(const std::string& name, const std::string& data)
+		{
+			const auto state = *game::hks::lua_state;
+			const auto sharing_mode = state->m_global->m_bytecodeSharingMode;
+			state->m_global->m_bytecodeSharingMode = game::hks::HKS_BYTECODE_SHARING_ON;
+			const auto _0 = gsl::finally([&]()
 			{
-				lui_error_hook.invoke<void>(s);
+				state->m_global->m_bytecodeSharingMode = sharing_mode;
+			});
+
+			game::hks::HksCompilerSettings compiler_settings{};
+			return game::hks::hksi_hksL_loadbuffer(state, &compiler_settings, data.data(), data.size(), name.data());
+		}
+
+		void load_script(const std::string& name, const std::string& data)
+		{
+			globals.loaded_scripts.push_back({name, name});
+
+			const auto lua = get_globals();
+			const auto load_results = lua["loadstring"](data, name);
+
+			if (load_results[0].is<function>())
+			{
+				const auto results = lua["pcall"](load_results);
+				if (!results[0].as<bool>())
+				{
+					print_error(results[1].as<std::string>());
+				}
+			}
+			else if (load_results[1].is<std::string>())
+			{
+				print_error(load_results[1].as<std::string>());
+			}
+		}
+
+		void load_scripts(const std::string& script_dir)
+		{
+			if (!utils::io::directory_exists(script_dir))
+			{
+				return;
 			}
 
-			const auto count = static_cast<int>(s->m_apistack.top - s->m_apistack.base);
-			const auto arguments = get_return_values(count);
+			const auto scripts = utils::io::list_files(script_dir);
 
-			std::string error_str = "LUI Error";
-			if (count && arguments[0].is<std::string>())
+			for (const auto& script : scripts)
 			{
-				error_str = arguments[0].as<std::string>();
+				std::string data{};
+				if (std::filesystem::is_directory(script) && utils::io::read_file(script + "/__init__.lua", &data))
+				{
+					print_loading_script(script);
+					load_script(script + "/__init__.lua", data);
+				}
 			}
+		}
 
-			throw std::runtime_error(error_str);
+		void setup_functions()
+		{
+			const auto lua = get_globals();
+
+			lua["io"]["fileexists"] = utils::io::file_exists;
+			lua["io"]["writefile"] = utils::io::write_file;
+			lua["io"]["movefile"] = utils::io::move_file;
+			lua["io"]["filesize"] = utils::io::file_size;
+			lua["io"]["createdirectory"] = utils::io::create_directory;
+			lua["io"]["directoryexists"] = utils::io::directory_exists;
+			lua["io"]["directoryisempty"] = utils::io::directory_is_empty;
+			lua["io"]["listfiles"] = utils::io::list_files;
+			lua["io"]["removefile"] = utils::io::remove_file;
+			lua["io"]["readfile"] = static_cast<std::string(*)(const std::string&)>(utils::io::read_file);
+
+			using game = table;
+			auto game_type = game();
+			lua["game"] = game_type;
+
+			game_type["getfps"] = [](const game&)
+			{
+				return fps::get_fps();
+			};
+
+			game_type["getping"] = [](const game&)
+			{
+				//return *::game::mp::ping;
+			};
+
+			game_type["issingleplayer"] = [](const game&)
+			{
+				return ::game::environment::is_sp();
+			};
+
+			game_type["ismultiplayer"] = [](const game&)
+			{
+				return ::game::environment::is_mp();
+			};
+
+			game_type["addlocalizedstring"] = [](const game&, const std::string& string,
+				const std::string& value)
+			{
+				localized_strings::override(string, value);
+			};
+		}
+
+		void start()
+		{
+			globals = {};
+
+			const auto lua = get_globals();
+			lua["EnableGlobals"]();
+
+			setup_functions();
+
+			lua["print"] = function(reinterpret_cast<game::hks::lua_function>(0x209EB0_b));
+			lua["table"]["unpack"] = lua["unpack"];
+			lua["luiglobals"] = lua;
+
+			load_scripts("h1-mod/ui_scripts/");
+			load_scripts("data/ui_scripts/");
+		}
+
+		void try_start()
+		{
+			try
+			{
+				start();
+			}
+			catch (const std::exception& e)
+			{
+				console::error("Failed to load LUI scripts: %s\n", e.what());
+			}
 		}
 
 		void* hks_start_stub(char a1)
 		{
-			const auto _1 = gsl::finally([]()
-			{
-				ui_scripting::lua::engine::start();
-			});
-
+			const auto _0 = gsl::finally(&try_start);
 			return hks_start_hook.invoke<void*>(a1);
 		}
 
 		void hks_shutdown_stub()
 		{
 			converted_functions.clear();
-			ui_scripting::lua::engine::stop();
-			hks_shutdown_hook.invoke<void*>();
+			globals = {};
+			return hks_shutdown_hook.invoke<void>();
 		}
 
-		void* hks_allocator_stub(void* userData, void* oldMemory, unsigned __int64 oldSize, unsigned __int64 newSize)
+		void* hks_package_require_stub(game::hks::lua_State* state)
 		{
-			const auto closure = reinterpret_cast<game::hks::cclosure*>(oldMemory);
-			if (converted_functions.find(closure) != converted_functions.end())
+			const auto script = get_current_script();
+			const auto root = get_root_script(script);
+			globals.in_require_script = root;
+			return hks_package_require_hook.invoke<void*>(state);
+		}
+
+		game::XAssetHeader db_find_xasset_header_stub(game::XAssetType type, const char* name, int allow_create_default)
+		{
+			if (type != 0x3D || !is_loaded_script(globals.in_require_script))
 			{
-				converted_functions.erase(closure);
+				return db_find_xasset_header_hook.invoke<game::XAssetHeader>(type, name, allow_create_default);
 			}
 
-			return hks_allocator_hook.invoke<void*>(userData, oldMemory, oldSize, newSize);
-		}
-	}
+			const auto folder = globals.in_require_script.substr(0, globals.in_require_script.find_last_of("/\\"));
+			const std::string name_ = name;
+			const std::string target_script = folder + "/" + name_ + ".lua";
 
-	int main_function_handler(game::hks::lua_State* state)
-	{
-		const auto value = state->m_apistack.base[-1];
-		if (value.t != game::hks::TCFUNCTION)
+			if (utils::io::file_exists(target_script))
+			{
+				globals.load_raw_script = true;
+				globals.raw_script_name = target_script;
+				return static_cast<game::XAssetHeader>(reinterpret_cast<game::LuaFile*>(1));
+			}
+			else if (name_.starts_with("ui/LUI/"))
+			{
+				return db_find_xasset_header_hook.invoke<game::XAssetHeader>(type, name, allow_create_default);
+			}
+
+			return static_cast<game::XAssetHeader>(nullptr);
+		}
+
+		int hks_load_stub(game::hks::lua_State* state, void* compiler_options, 
+			void* reader, void* reader_data, const char* chunk_name)
 		{
+			if (globals.load_raw_script)
+			{
+				globals.load_raw_script = false;
+				globals.loaded_scripts.push_back({globals.raw_script_name, globals.in_require_script});
+				return load_buffer(globals.raw_script_name, utils::io::read_file(globals.raw_script_name));
+			}
+			else
+			{
+				return hks_load_hook.invoke<int>(state, compiler_options, reader,
+					reader_data, chunk_name);
+			}
+		}
+
+		int main_handler(game::hks::lua_State* state)
+		{
+			const auto value = state->m_apistack.base[-1];
+			if (value.t != game::hks::TCFUNCTION)
+			{
+				return 0;
+			}
+
+			const auto closure = value.v.cClosure;
+			if (converted_functions.find(closure) == converted_functions.end())
+			{
+				return 0;
+			}
+
+			const auto& function = converted_functions[closure];
+
+			try
+			{
+				const auto args = get_return_values();
+				const auto results = function(args);
+
+				for (const auto& result : results)
+				{
+					push_value(result);
+				}
+
+				return static_cast<int>(results.size());
+			}
+			catch (const std::exception& e)
+			{
+				game::hks::hksi_luaL_error(state, e.what());
+			}
+
 			return 0;
 		}
-
-		const auto closure = reinterpret_cast<game::hks::cclosure*>(value.v.cClosure);
-		if (converted_functions.find(closure) == converted_functions.end())
-		{
-			return 0;
-		}
-
-		const auto& function = converted_functions[closure];
-		const auto count = static_cast<int>(state->m_apistack.top - state->m_apistack.base);
-		const auto arguments = get_return_values(count);
-		const auto s = function.lua_state();
-
-		std::vector<sol::lua_value> converted_args;
-
-		for (const auto& argument : arguments)
-		{
-			converted_args.push_back(lua::convert(s, argument));
-		}
-
-		const auto results = function(sol::as_args(converted_args));
-		lua::handle_error(results);
-
-		for (const auto& result : results)
-		{
-			push_value(lua::convert({s, result}));
-		}
-
-		return results.return_count();
 	}
 
-	void add_converted_function(game::hks::cclosure* closure, const sol::protected_function& function)
+	template <typename F>
+	game::hks::cclosure* convert_function(F f)
 	{
-		converted_functions[closure] = function;
-	}
-
-	void clear_converted_functions()
-	{
-		converted_functions.clear();
-	}
-
-	void enable_error_hook()
-	{
-		error_hook_enabled = true;
-	}
-
-	void disable_error_hook()
-	{
-		error_hook_enabled = false;
+		const auto state = *game::hks::lua_state;
+		const auto closure = game::hks::cclosure_Create(state, main_handler, 0, 0, 0);
+		converted_functions[closure] = wrap_function(f);
+		return closure;
 	}
 
 	bool lui_running()
@@ -178,32 +353,25 @@ namespace ui_scripting
 
 		void post_unpack() override
 		{
-			if (game::environment::is_dedi())
+			if (!game::environment::is_mp())
 			{
 				return;
 			}
 
-			scheduler::loop(ui_scripting::lua::engine::run_frame, scheduler::pipeline::lui);
+			db_find_xasset_header_hook.create(game::DB_FindXAssetHeader, db_find_xasset_header_stub);
+			hks_load_hook.create(0x22C180_b, hks_load_stub);
 
-			hks_start_hook.create(SELECT_VALUE(0x0, 0x27A790_b), hks_start_stub); // 1.15
-			hks_shutdown_hook.create(SELECT_VALUE(0x0, 0x2707C0_b), hks_shutdown_stub); // 1.15
-			hksi_lual_error_hook.create(SELECT_VALUE(0x0, 0x22F930_b), hksi_lual_error_stub); // 1.15
-			hks_allocator_hook.create(SELECT_VALUE(0x0, 0x22C010_b), hks_allocator_stub); // 1.15
-			lui_error_hook.create(SELECT_VALUE(0x0, 0x20BA80_b), lui_error_stub); // 1.15
-			hksi_hks_error_hook.create(SELECT_VALUE(0x0, 0x22EA10_b), hksi_hks_error_stub); // 1.15
-
-			if (game::environment::is_mp())
-			{
-				hksi_lual_error_hook2.create(0x2365E0_b, hksi_lual_error_stub); // 1.15
-			}
+			hks_package_require_hook.create(0x214040_b, hks_package_require_stub);
+			hks_start_hook.create(0x27A790_b, hks_start_stub);
+			hks_shutdown_hook.create(0x2707C0_b, hks_shutdown_stub);
 
 			command::add("lui_restart", []()
 			{
-				utils::hook::invoke<void>(SELECT_VALUE(0x0, 0x2707C0_b)); // 1.15
-				utils::hook::invoke<void>(SELECT_VALUE(0x0, 0x27BEC0_b)); // 1.15
+				utils::hook::invoke<void>(0x2707C0_b);
+				utils::hook::invoke<void>(0x27BEC0_b);
 			});
 		}
 	};
 }
 
-//REGISTER_COMPONENT(ui_scripting::component)
\ No newline at end of file
+REGISTER_COMPONENT(ui_scripting::component)
diff --git a/src/client/component/ui_scripting.hpp b/src/client/component/ui_scripting.hpp
index b95710b3..804c8a14 100644
--- a/src/client/component/ui_scripting.hpp
+++ b/src/client/component/ui_scripting.hpp
@@ -1,14 +1,49 @@
 #pragma once
-#include "game/ui_scripting/lua/value_conversion.hpp"
 
 namespace ui_scripting
 {
-	int main_function_handler(game::hks::lua_State* state);
-	void add_converted_function(game::hks::cclosure* closure, const sol::protected_function& function);
-	void clear_converted_functions();
+	template <class... Args, std::size_t... I>
+	auto wrap_function(const std::function<void(Args...)>& f, std::index_sequence<I...>)
+	{
+		return [f](const function_arguments& args)
+		{
+			f(args[I]...);
+			return arguments{{}};
+		};
+	}
 
-	void enable_error_hook();
-	void disable_error_hook();
+	template <class... Args, std::size_t... I>
+	auto wrap_function(const std::function<arguments(Args...)>& f, std::index_sequence<I...>)
+	{
+		return [f](const function_arguments& args)
+		{
+			return f(args[I]...);
+		};
+	}
+
+	template <typename R, class... Args, std::size_t... I>
+	auto wrap_function(const std::function<R(Args...)>& f, std::index_sequence<I...>)
+	{
+		return [f](const function_arguments& args)
+		{
+			return arguments{f(args[I]...)};
+		};
+	}
+
+	template <typename R, class... Args>
+	auto wrap_function(const std::function<R(Args...)>& f)
+	{
+		return wrap_function(f, std::index_sequence_for<Args...>{});
+	}
+
+	template <class F>
+	auto wrap_function(F f)
+	{
+		return wrap_function(std::function(f));
+	}
+
+	template <typename F>
+	game::hks::cclosure* convert_function(F f);
 
 	bool lui_running();
-}
\ No newline at end of file
+}
diff --git a/src/client/game/structs.hpp b/src/client/game/structs.hpp
index ead2784b..e8570bbc 100644
--- a/src/client/game/structs.hpp
+++ b/src/client/game/structs.hpp
@@ -1566,6 +1566,10 @@ namespace game
 
 	namespace hks
 	{
+		struct lua_State;
+		struct HashTable;
+		struct cclosure;
+
 		struct GenericChunkHeader
 		{
 			unsigned __int64 m_flags;
@@ -1591,9 +1595,6 @@ namespace game
 			char m_data[30];
 		};
 
-		struct HashTable;
-		struct cclosure;
-
 		union HksValue
 		{
 			cclosure* cClosure;
@@ -1605,6 +1606,8 @@ namespace game
 			void* thread;
 			void* ptr;
 			float number;
+			long long i64;
+			unsigned long long ui64;
 			unsigned int native;
 			bool boolean;
 		};
@@ -1690,6 +1693,14 @@ namespace game
 
 		enum HksError
 		{
+			HKS_NO_ERROR = 0x0,
+			HKS_ERRSYNTAX = 0xFFFFFFFC,
+			HKS_ERRFILE = 0xFFFFFFFB,
+			HKS_ERRRUN = 0xFFFFFF9C,
+			HKS_ERRMEM = 0xFFFFFF38,
+			HKS_ERRERR = 0xFFFFFED4,
+			HKS_THROWING_ERROR = 0xFFFFFE0C,
+			HKS_GC_YIELD = 0x1,
 		};
 
 		struct lua_Debug
@@ -1710,24 +1721,6 @@ namespace game
 			int is_tail_call;
 		};
 
-		struct lua_State : ChunkHeader
-		{
-			void* m_global;
-			CallStack m_callStack;
-			ApiStack m_apistack;
-			UpValue* pending;
-			HksObject globals;
-			HksObject m_cEnv;
-			CallSite* m_callsites;
-			int m_numberOfCCalls;
-			void* m_context;
-			InternString* m_name;
-			lua_State* m_nextState;
-			lua_State* m_nextStateStack;
-			Status m_status;
-			HksError m_error;
-		};
-
 		using lua_function = int(__fastcall*)(lua_State*);
 
 		struct luaL_Reg
@@ -1766,5 +1759,231 @@ namespace game
 			InternString* m_name;
 			HksObject m_upvalues[1];
 		};
+
+		enum HksCompilerSettings_BytecodeSharingFormat
+		{
+			BYTECODE_DEFAULT = 0x0,
+			BYTECODE_INPLACE = 0x1,
+			BYTECODE_REFERENCED = 0x2,
+		};
+
+		enum HksCompilerSettings_IntLiteralOptions
+		{
+			INT_LITERALS_NONE = 0x0,
+			INT_LITERALS_LUD = 0x1,
+			INT_LITERALS_32BIT = 0x1,
+			INT_LITERALS_UI64 = 0x2,
+			INT_LITERALS_64BIT = 0x2,
+			INT_LITERALS_ALL = 0x3,
+		};
+
+		struct HksCompilerSettings
+		{
+			int m_emitStructCode;
+			const char** m_stripNames;
+			int m_emitGlobalMemoization;
+			int _m_isHksGlobalMemoTestingMode;
+			HksCompilerSettings_BytecodeSharingFormat m_bytecodeSharingFormat;
+			HksCompilerSettings_IntLiteralOptions m_enableIntLiterals;
+			int(__fastcall* m_debugMap)(const char*, int);
+		};
+
+		enum HksBytecodeSharingMode
+		{
+			HKS_BYTECODE_SHARING_OFF = 0x0,
+			HKS_BYTECODE_SHARING_ON = 0x1,
+			HKS_BYTECODE_SHARING_SECURE = 0x2,
+		};
+
+		struct HksGcWeights
+		{
+			int m_removeString;
+			int m_finalizeUserdataNoMM;
+			int m_finalizeUserdataGcMM;
+			int m_cleanCoroutine;
+			int m_removeWeak;
+			int m_markObject;
+			int m_traverseString;
+			int m_traverseUserdata;
+			int m_traverseCoroutine;
+			int m_traverseWeakTable;
+			int m_freeChunk;
+			int m_sweepTraverse;
+		};
+
+		struct GarbageCollector_Stack
+		{
+			void* m_storage;
+			unsigned int m_numEntries;
+			unsigned int m_numAllocated;
+		};
+
+		struct ProtoList
+		{
+			void** m_protoList;
+			unsigned __int16 m_protoSize;
+			unsigned __int16 m_protoAllocSize;
+		};
+
+		struct GarbageCollector
+		{
+			int m_target;
+			int m_stepsLeft;
+			int m_stepLimit;
+			HksGcWeights m_costs;
+			int m_unit;
+			_SETJMP_FLOAT128(*m_jumpPoint)[16];
+			lua_State* m_mainState;
+			lua_State* m_finalizerState;
+			void* m_memory;
+			int m_phase;
+			GarbageCollector_Stack m_resumeStack;
+			GarbageCollector_Stack m_greyStack;
+			GarbageCollector_Stack m_remarkStack;
+			GarbageCollector_Stack m_weakStack;
+			int m_finalizing;
+			HksObject m_safeTableValue;
+			lua_State* m_startOfStateStackList;
+			lua_State* m_endOfStateStackList;
+			lua_State* m_currentState;
+			HksObject m_safeValue;
+			void* m_compiler;
+			void* m_bytecodeReader;
+			void* m_bytecodeWriter;
+			int m_pauseMultiplier;
+			int m_stepMultiplier;
+			bool m_stopped;
+			int(__fastcall* m_gcPolicy)(lua_State*);
+			unsigned __int64 m_pauseTriggerMemoryUsage;
+			int m_stepTriggerCountdown;
+			unsigned int m_stringTableIndex;
+			unsigned int m_stringTableSize;
+			UserData* m_lastBlackUD;
+			UserData* m_activeUD;
+		};
+
+		enum MemoryManager_ChunkColor
+		{
+			RED = 0x0,
+			BLACK = 0x1,
+		};
+
+		struct ChunkList
+		{
+			ChunkHeader m_prevToStart;
+		};
+
+		enum Hks_DeleteCheckingMode
+		{
+			HKS_DELETE_CHECKING_OFF = 0x0,
+			HKS_DELETE_CHECKING_ACCURATE = 0x1,
+			HKS_DELETE_CHECKING_SAFE = 0x2,
+		};
+
+		struct MemoryManager
+		{
+			void* (__fastcall* m_allocator)(void*, void*, unsigned __int64, unsigned __int64);
+			void* m_allocatorUd;
+			MemoryManager_ChunkColor m_chunkColor;
+			unsigned __int64 m_used;
+			unsigned __int64 m_highwatermark;
+			ChunkList m_allocationList;
+			ChunkList m_sweepList;
+			ChunkHeader* m_lastKeptChunk;
+			lua_State* m_state;
+			ChunkList m_deletedList;
+			int m_deleteMode;
+			Hks_DeleteCheckingMode m_deleteCheckingMode;
+		};
+
+		struct StaticStringCache
+		{
+			HksObject m_objects[41];
+		};
+
+		enum HksBytecodeEndianness
+		{
+			HKS_BYTECODE_DEFAULT_ENDIAN = 0x0,
+			HKS_BYTECODE_BIG_ENDIAN = 0x1,
+			HKS_BYTECODE_LITTLE_ENDIAN = 0x2,
+		};
+
+		struct RuntimeProfileData_Stats
+		{
+			unsigned __int64 hksTime;
+			unsigned __int64 callbackTime;
+			unsigned __int64 gcTime;
+			unsigned __int64 cFinalizerTime;
+			unsigned __int64 compilerTime;
+			unsigned int hkssTimeSamples;
+			unsigned int callbackTimeSamples;
+			unsigned int gcTimeSamples;
+			unsigned int compilerTimeSamples;
+			unsigned int num_newuserdata;
+			unsigned int num_tablerehash;
+			unsigned int num_pushstring;
+			unsigned int num_pushcfunction;
+			unsigned int num_newtables;
+		};
+
+		struct RuntimeProfileData
+		{
+			__int64 stackDepth;
+			__int64 callbackDepth;
+			unsigned __int64 lastTimer;
+			RuntimeProfileData_Stats frameStats;
+			unsigned __int64 gcStartTime;
+			unsigned __int64 finalizerStartTime;
+			unsigned __int64 compilerStartTime;
+			unsigned __int64 compilerStartGCTime;
+			unsigned __int64 compilerStartGCFinalizerTime;
+			unsigned __int64 compilerCallbackStartTime;
+			__int64 compilerDepth;
+			void* outFile;
+			lua_State* rootState;
+		};
+
+		struct HksGlobal
+		{
+			MemoryManager m_memory;
+			GarbageCollector m_collector;
+			StringTable m_stringTable;
+			HksBytecodeSharingMode m_bytecodeSharingMode;
+			unsigned int m_tableVersionInitializer;
+			HksObject m_registry;
+			ProtoList m_protoList;
+			HashTable* m_structProtoByName;
+			ChunkList m_userDataList;
+			lua_State* m_root;
+			StaticStringCache m_staticStringCache;
+			void* m_debugger;
+			void* m_profiler;
+			RuntimeProfileData m_runProfilerData;
+			HksCompilerSettings m_compilerSettings;
+			int(__fastcall* m_panicFunction)(lua_State*);
+			void* m_luaplusObjectList;
+			int m_heapAssertionFrequency;
+			int m_heapAssertionCount;
+			void (*m_logFunction)(lua_State*, const char*, ...);
+			HksBytecodeEndianness m_bytecodeDumpEndianness;
+		};
+
+		struct lua_State : ChunkHeader
+		{
+			HksGlobal* m_global;
+			CallStack m_callStack;
+			ApiStack m_apistack;
+			UpValue* pending;
+			HksObject globals;
+			HksObject m_cEnv;
+			CallSite* m_callsites;
+			int m_numberOfCCalls;
+			void* m_context;
+			InternString* m_name;
+			lua_State* m_nextState;
+			lua_State* m_nextStateStack;
+			Status m_status;
+			HksError m_error;
+		};
 	}
 }
diff --git a/src/client/game/symbols.hpp b/src/client/game/symbols.hpp
index a99508f6..c602e6f1 100644
--- a/src/client/game/symbols.hpp
+++ b/src/client/game/symbols.hpp
@@ -99,7 +99,7 @@ namespace game
 
 	WEAK symbol<char*(char* string)> I_CleanStr{0x0, 0x0};
 
-	WEAK symbol<const char* (int, int, int)> Key_KeynumToString{0x0, 0x0};
+	WEAK symbol<const char* (int, int, int)> Key_KeynumToString{0x0, 0x199990};
 
 	WEAK symbol<unsigned int(int)> Live_SyncOnlineDataFlags{0x0, 0x1A5C10};
 
@@ -151,14 +151,14 @@ namespace game
 	WEAK symbol<const char*(const XAsset* asset)> DB_GetXAssetName{0x0, 0x0};
 	WEAK symbol<int(XAssetType type)> DB_GetXAssetTypeSize{0x0, 0x0};
 	WEAK symbol<XAssetHeader(XAssetType type, const char* name, 
-		int createDefault)> DB_FindXAssetHeader{0x0, 0x0};
+		int createDefault)> DB_FindXAssetHeader{0x0, 0x3950C0};
 
 	WEAK symbol<void(int clientNum, const char* menu, 
-		int a3, int a4, unsigned int a5)> LUI_OpenMenu{0x0, 0x0};
+		int a3, int a4, unsigned int a5)> LUI_OpenMenu{0x0, 0x1E1210};
 	WEAK symbol<bool(int clientNum, const char* name, hks::lua_State* s)> LUI_BeginEvent{0x0, 0x0};
 	WEAK symbol<void(hks::lua_State* s)> LUI_EndEvent{0x0, 0x0};
-	WEAK symbol<void()> LUI_EnterCriticalSection{0x0, 0x0};
-	WEAK symbol<void()> LUI_LeaveCriticalSection{0x0, 0x0};
+	WEAK symbol<void()> LUI_EnterCriticalSection{0x0, 0x2669B0};
+	WEAK symbol<void()> LUI_LeaveCriticalSection{0x0, 0x26BDC0};
 
 	WEAK symbol<bool(int clientNum, const char* menu)> Menu_IsMenuOpenAndVisible{0x0, 0x0};
 
@@ -266,17 +266,22 @@ namespace game
 
 	namespace hks
 	{
-		WEAK symbol<lua_State*> lua_state{0x0, 0x0};
-		WEAK symbol<void(lua_State* s, const char* str, unsigned int l)> hksi_lua_pushlstring{0x0, 0x0};
-		WEAK symbol<HksObject*(HksObject* result, lua_State* s, const HksObject* table, const HksObject* key)> hks_obj_getfield{0x0, 0x0};
-		WEAK symbol<void(lua_State* s, const HksObject* tbl, const HksObject* key, const HksObject* val)> hks_obj_settable{0x0, 0x0};
-		WEAK symbol<HksObject* (HksObject* result, lua_State* s, const HksObject* table, const HksObject* key)> hks_obj_gettable{0x0, 0x0};
-		WEAK symbol<void(lua_State* s, int nargs, int nresults, const unsigned int* pc)> vm_call_internal{0x0, 0x0};
-		WEAK symbol<HashTable*(lua_State* s, unsigned int arraySize, unsigned int hashSize)> Hashtable_Create{0x0, 0x0};
+		WEAK symbol<lua_State*> lua_state{0, 0x36647F8};
+		WEAK symbol<void(lua_State* s, const char* str, unsigned int l)> hksi_lua_pushlstring{0, 0x79800};
+		WEAK symbol<HksObject*(HksObject* result, lua_State* s, const HksObject* table, const HksObject* key)> hks_obj_getfield{0, 0x22CB90};
+		WEAK symbol<void(lua_State* s, const HksObject* tbl, const HksObject* key, const HksObject* val)> hks_obj_settable{0, 0x22DDB0};
+		WEAK symbol<HksObject* (HksObject* result, lua_State* s, const HksObject* table, const HksObject* key)> hks_obj_gettable{0, 0x22D070};
+		WEAK symbol<void(lua_State* s, int nargs, int nresults, const unsigned int* pc)> vm_call_internal{0, 0x25D2F0};
+		WEAK symbol<HashTable*(lua_State* s, unsigned int arraySize, unsigned int hashSize)> Hashtable_Create{0, 0x21B030};
 		WEAK symbol<cclosure*(lua_State* s, lua_function function, int num_upvalues, 
-			int internal_, int profilerTreatClosureAsFunc)> cclosure_Create{0x0, 0x0};
-		WEAK symbol<int(lua_State* s, int t)> hksi_luaL_ref{0x0, 0x0};
-		WEAK symbol<void(lua_State* s, int t, int ref)> hksi_luaL_unref{0x0, 0x0};
-		WEAK symbol<void(lua_State* s, HksObject* lfp)> closePendingUpvalues{0x0, 0x0};
+			int internal_, int profilerTreatClosureAsFunc)> cclosure_Create{0, 0x21B250};
+		WEAK symbol<int(lua_State* s, int t)> hksi_luaL_ref{0, 0x236CC0};
+		WEAK symbol<void(lua_State* s, int t, int ref)> hksi_luaL_unref{0, 0x22FC40};
+		WEAK symbol<int(lua_State* s, const HksCompilerSettings* options, const char* buff, 
+			unsigned __int64 sz, const char* name)> hksi_hksL_loadbuffer{0, 0x22E620};
+		WEAK symbol<int(lua_State* s, const char* what, lua_Debug* ar)> hksi_lua_getinfo{0, 0x22FFE0};
+		WEAK symbol<int(lua_State* s, int level, lua_Debug* ar)> hksi_lua_getstack{0, 0x2302B0};
+		WEAK symbol<void(lua_State* s, const char* fmt, ...)> hksi_luaL_error{0, 0x22F930};
+		WEAK symbol<const char*> typenames{0, 0x10AD750};
 	}
 }
diff --git a/src/client/game/ui_scripting/execution.cpp b/src/client/game/ui_scripting/execution.cpp
index 716fe1ca..44295d2b 100644
--- a/src/client/game/ui_scripting/execution.cpp
+++ b/src/client/game/ui_scripting/execution.cpp
@@ -1,16 +1,54 @@
 #include <std_include.hpp>
 #include "execution.hpp"
 #include "component/ui_scripting.hpp"
+#include "component/console.hpp"
 
 #include <utils/string.hpp>
 
 namespace ui_scripting
 {
+	namespace
+	{
+		script_value get_field(void* ptr, game::hks::HksObjectType type, const script_value& key)
+		{
+			const auto state = *game::hks::lua_state;
+			const auto top = state->m_apistack.top;
+
+			push_value(key);
+
+			game::hks::HksObject value{};
+			game::hks::HksObject obj{};
+			obj.t = type;
+			obj.v.ptr = ptr;
+
+			game::hks::hks_obj_gettable(&value, state, &obj, &state->m_apistack.top[-1]);
+			state->m_apistack.top = top;
+			return value;
+		}
+
+		void set_field(void* ptr, game::hks::HksObjectType type, const script_value& key, const script_value& value)
+		{
+			const auto state = *game::hks::lua_state;
+
+			game::hks::HksObject obj{};
+			obj.t = type;
+			obj.v.ptr = ptr;
+
+			game::hks::hks_obj_settable(state, &obj, &key.get_raw(), &value.get_raw());
+		}
+	}
+
 	void push_value(const script_value& value)
 	{
 		const auto state = *game::hks::lua_state;
-		const auto value_ = value.get_raw();
-		*state->m_apistack.top = value_;
+		*state->m_apistack.top = value.get_raw();
+		state->m_apistack.top++;
+	}
+
+	void push_value(const game::hks::HksObject& value)
+	{
+		const auto state = *game::hks::lua_state;
+		*state->m_apistack.top = value;
 		state->m_apistack.top++;
 	}
 
@@ -20,13 +58,36 @@ namespace ui_scripting
 		return state->m_apistack.top[-1 - offset];
 	}
 
-	arguments get_return_values(int count)
+	arguments get_return_values()
 	{
+		const auto state = *game::hks::lua_state;
+		const auto count = static_cast<int>(state->m_apistack.top - state->m_apistack.base);
 		arguments values;
 
 		for (auto i = count - 1; i >= 0; i--)
 		{
-			values.push_back(get_return_value(i));
+			const auto v = get_return_value(i);
+			values.push_back(v);
+		}
+
+		if (values.size() == 0)
+		{
+			values.push_back({});
+		}
+
+		return values;
+	}
+
+	arguments get_return_values(game::hks::HksObject* base)
+	{
+		const auto state = *game::hks::lua_state;
+		const auto count = static_cast<int>(state->m_apistack.top - base);
+		arguments values;
+
+		for (auto i = count - 1; i >= 0; i--)
+		{
+			const auto v = get_return_value(i);
+			values.push_back(v);
 		}
 
 		if (values.size() == 0)
@@ -40,7 +101,7 @@ namespace ui_scripting
 	bool notify(const std::string& name, const event_arguments& arguments)
 	{
 		const auto state = *game::hks::lua_state;
-		if (!state)
+		if (state == nullptr)
 		{
 			return false;
 		}
@@ -52,160 +113,63 @@ namespace ui_scripting
 		{
 			const auto globals = table((*::game::hks::lua_state)->globals.v.table);
 			const auto engine = globals.get("Engine").as<table>();
-			const auto root = engine.get("GetLuiRoot").as<function>().call({})[0].as<userdata>();
-			const auto process_event = root.get("processEvent").as<function>();
+			const auto root = engine.get("GetLuiRoot")()[0].as<userdata>();
+			const auto process_event = root.get("processEvent");
 
 			table event{};
 			event.set("name", name);
+			event.set("dispatchChildren", true);
 
 			for (const auto& arg : arguments)
 			{
 				event.set(arg.first, arg.second);
 			}
 
-			process_event.call({root, event});
+			process_event(root, event);
 			return true;
 		}
 		catch (const std::exception& e)
 		{
-			printf("Error processing event '%s' %s\n", name.data(), e.what());
-			return false;
+			console::error("Error processing event '%s' %s\n", name.data(), e.what());
 		}
+
+		return false;
 	}
 
 	arguments call_script_function(const function& function, const arguments& arguments)
 	{
 		const auto state = *game::hks::lua_state;
+		const auto top = state->m_apistack.top;
 
-		stack stack;
 		push_value(function);
 		for (auto i = arguments.begin(); i != arguments.end(); ++i)
 		{
 			push_value(*i);
 		}
 
-		const auto num_args = static_cast<int>(arguments.size());
-		stack.save(num_args + 1);
-
-		const auto _1 = gsl::finally(&disable_error_hook);
-		enable_error_hook();
-
-		try
-		{
-			game::hks::vm_call_internal(state, static_cast<int>(arguments.size()), -1, 0);
-			const auto count = static_cast<int>(state->m_apistack.top - state->m_apistack.base);
-			return get_return_values(count);
-		}
-		catch (const std::exception& e)
-		{
-			stack.fix();
-			throw std::runtime_error(std::string("Error executing script function: ") + e.what());
-		}
+		game::hks::vm_call_internal(state, static_cast<int>(arguments.size()), -1, 0);
+		const auto args = get_return_values(top);
+		state->m_apistack.top = top;
+		return args;
 	}
 
 	script_value get_field(const userdata& self, const script_value& key)
 	{
-		const auto state = *game::hks::lua_state;
-
-		stack stack;
-		push_value(key);
-		stack.save(1);
-
-		const auto _1 = gsl::finally(&disable_error_hook);
-		enable_error_hook();
-
-		game::hks::HksObject value{};
-		game::hks::HksObject userdata{};
-		userdata.t = game::hks::TUSERDATA;
-		userdata.v.ptr = self.ptr;
-
-		try
-		{
-			game::hks::hks_obj_gettable(&value, state, &userdata, &state->m_apistack.top[-1]);
-			return value;
-		}
-		catch (const std::exception& e)
-		{
-			stack.fix();
-			throw std::runtime_error("Error getting userdata field: "s + e.what());
-		}
+		return get_field(self.ptr, game::hks::TUSERDATA, key);
 	}
 
 	script_value get_field(const table& self, const script_value& key)
 	{
-		const auto state = *game::hks::lua_state;
-
-		stack stack;
-		push_value(key);
-		stack.save(1);
-
-		const auto _1 = gsl::finally(&disable_error_hook);
-		enable_error_hook();
-
-		game::hks::HksObject value{};
-		game::hks::HksObject userdata{};
-		userdata.t = game::hks::TTABLE;
-		userdata.v.ptr = self.ptr;
-
-		try
-		{
-			game::hks::hks_obj_gettable(&value, state, &userdata, &state->m_apistack.top[-1]);
-			return value;
-		}
-		catch (const std::exception& e)
-		{
-			stack.fix();
-			throw std::runtime_error("Error getting table field: "s + e.what());
-		}
+		return get_field(self.ptr, game::hks::TTABLE, key);
 	}
 
 	void set_field(const userdata& self, const script_value& key, const script_value& value)
 	{
-		const auto state = *game::hks::lua_state;
-
-		stack stack;
-		stack.save(0);
-
-		const auto _1 = gsl::finally(&disable_error_hook);
-		enable_error_hook();
-
-		game::hks::HksObject userdata{};
-		userdata.t = game::hks::TUSERDATA;
-		userdata.v.ptr = self.ptr;
-
-		try
-		{
-			game::hks::hks_obj_settable(state, &userdata, &key.get_raw(), &value.get_raw());
-		}
-		catch (const std::exception& e)
-		{
-			stack.fix();
-			throw std::runtime_error("Error setting userdata field: "s + e.what());
-		}
+		set_field(self.ptr, game::hks::TUSERDATA, key, value);
 	}
 
 	void set_field(const table& self, const script_value& key, const script_value& value)
 	{
-		const auto state = *game::hks::lua_state;
-
-		stack stack;
-		stack.save(0);
-
-		const auto _1 = gsl::finally(&disable_error_hook);
-		enable_error_hook();
-
-		game::hks::HksObject userdata{};
-		userdata.t = game::hks::TTABLE;
-		userdata.v.ptr = self.ptr;
-
-		try
-		{
-			game::hks::hks_obj_settable(state, &userdata, &key.get_raw(), &value.get_raw());
-		}
-		catch (const std::exception& e)
-		{
-			stack.fix();
-			throw std::runtime_error("Error setting table field: "s + e.what());
-		}
+		set_field(self.ptr, game::hks::TTABLE, key, value);
 	}
 }
diff --git a/src/client/game/ui_scripting/execution.hpp b/src/client/game/ui_scripting/execution.hpp
index 4a3d3562..bc39e7a0 100644
--- a/src/client/game/ui_scripting/execution.hpp
+++ b/src/client/game/ui_scripting/execution.hpp
@@ -6,8 +6,11 @@
 namespace ui_scripting
 {
 	void push_value(const script_value& value);
+	void push_value(const game::hks::HksObject& value);
+
 	script_value get_return_value(int offset);
-	arguments get_return_values(int count);
+	arguments get_return_values();
+	arguments get_return_values(game::hks::HksObject* base);
 
 	bool notify(const std::string& name, const event_arguments& arguments);
 
diff --git a/src/client/game/ui_scripting/lua/context.cpp b/src/client/game/ui_scripting/lua/context.cpp
deleted file mode 100644
index 4a6294b6..00000000
--- a/src/client/game/ui_scripting/lua/context.cpp
+++ /dev/null
@@ -1,428 +0,0 @@
-#include <std_include.hpp>
-#include "context.hpp"
-#include "error.hpp"
-#include "value_conversion.hpp"
-#include "../../scripting/execution.hpp"
-#include "../script_value.hpp"
-#include "../execution.hpp"
-
-#include "../../../component/ui_scripting.hpp"
-#include "../../../component/command.hpp"
-#include "../../../component/updater.hpp"
-#include "../../../component/fps.hpp"
-#include "../../../component/localized_strings.hpp"
-#include "../../../component/fastfiles.hpp"
-#include "../../../component/scripting.hpp"
-#include "../../../component/mods.hpp"
-#include "../../../component/discord.hpp"
-
-#include "component/game_console.hpp"
-#include "component/scheduler.hpp"
-
-#include <discord_rpc.h>
-
-#include <utils/string.hpp>
-#include <utils/nt.hpp>
-#include <utils/io.hpp>
-
-namespace ui_scripting::lua
-{
-	namespace
-	{
-		const auto json_script = utils::nt::load_resource(LUA_JSON);
-
-		void setup_json(sol::state& state)
-		{
-			const auto json = state.safe_script(json_script, &sol::script_pass_on_error);
-			handle_error(json);
-			state["json"] = json;
-		}
-
-		void setup_io(sol::state& state)
-		{
-			state["io"]["fileexists"] = utils::io::file_exists;
-			state["io"]["writefile"] = utils::io::write_file;
-			state["io"]["movefile"] = utils::io::move_file;
-			state["io"]["filesize"] = utils::io::file_size;
-			state["io"]["createdirectory"] = utils::io::create_directory;
-			state["io"]["directoryexists"] = utils::io::directory_exists;
-			state["io"]["directoryisempty"] = utils::io::directory_is_empty;
-			state["io"]["listfiles"] = utils::io::list_files;
-			state["io"]["copyfolder"] = utils::io::copy_folder;
-			state["io"]["removefile"] = utils::io::remove_file;
-			state["io"]["removedirectory"] = utils::io::remove_directory;
-			state["io"]["readfile"] = static_cast<std::string(*)(const std::string&)>(utils::io::read_file);
-		}
-
-		void setup_types(sol::state& state, scheduler& scheduler)
-		{
-			struct game
-			{
-			};
-			auto game_type = state.new_usertype<game>("game_");
-			state["game"] = game();
-
-			game_type["ontimeout"] = [&scheduler](const game&, const sol::protected_function& callback,
-			                                      const long long milliseconds)
-			{
-				return scheduler.add(callback, milliseconds, true);
-			};
-
-			game_type["oninterval"] = [&scheduler](const game&, const sol::protected_function& callback,
-			                                       const long long milliseconds)
-			{
-				return scheduler.add(callback, milliseconds, false);
-			};
-
-			game_type["getfps"] = [](const game&)
-			{
-				return fps::get_fps();
-			};
-
-			game_type["getping"] = [](const game&)
-			{
-				return *::game::mp::ping;
-			};
-
-			game_type["issingleplayer"] = [](const game&)
-			{
-				return ::game::environment::is_sp();
-			};
-
-			game_type["ismultiplayer"] = [](const game&)
-			{
-				return ::game::environment::is_mp();
-			};
-
-			game_type["addlocalizedstring"] = [](const game&, const std::string& string,
-				const std::string& value)
-			{
-				localized_strings::override(string, value);
-			};
-
-			game_type["sharedset"] = [](const game&, const std::string& key, const std::string& value)
-			{
-				scripting::shared_table.access([key, value](scripting::shared_table_t& table)
-				{
-					table[key] = value;
-				});
-			};
-
-			game_type["sharedget"] = [](const game&, const std::string& key)
-			{
-				std::string result;
-				scripting::shared_table.access([key, &result](scripting::shared_table_t& table)
-				{
-					result = table[key];
-				});
-				return result;
-			};
-
-			game_type["sharedclear"] = [](const game&)
-			{
-				scripting::shared_table.access([](scripting::shared_table_t& table)
-				{
-					table.clear();
-				});
-			};
-
-			game_type["assetlist"] = [](const game&, const sol::this_state s, const std::string& type_string)
-			{
-				auto table = sol::table::create(s.lua_state());
-				auto index = 1;
-				auto type_index = -1;
-
-				for (auto i = 0; i < ::game::XAssetType::ASSET_TYPE_COUNT; i++)
-				{
-					if (type_string == ::game::g_assetNames[i])
-					{
-						type_index = i;
-					}
-				}
-
-				if (type_index == -1)
-				{
-					throw std::runtime_error("Asset type does not exist");
-				}
-
-				const auto type = static_cast<::game::XAssetType>(type_index);
-				fastfiles::enum_assets(type, [type, &table, &index](const ::game::XAssetHeader header)
-				{
-					const auto asset = ::game::XAsset{type, header};
-					const std::string asset_name = ::game::DB_GetXAssetName(&asset);
-					table[index++] = asset_name;
-				}, true);
-
-				return table;
-			};
-
-			game_type["getweapondisplayname"] = [](const game&, const std::string& name)
-			{
-				const auto alternate = name.starts_with("alt_");
-				const auto weapon = ::game::G_GetWeaponForName(name.data());
-
-				char buffer[0x400] = {0};
-				::game::CG_GetWeaponDisplayName(weapon, alternate, buffer, 0x400);
-
-				return std::string(buffer);
-			};
-
-			game_type["getloadedmod"] = [](const game&)
-			{
-				return mods::mod_path;
-			};
-
-			auto userdata_type = state.new_usertype<userdata>("userdata_");
-
-			userdata_type["new"] = sol::property(
-				[](const userdata& userdata, const sol::this_state s)
-				{
-					return convert(s, userdata.get("new"));
-				},
-				[](const userdata& userdata, const sol::this_state s, const sol::lua_value& value)
-				{
-					userdata.set("new", convert({s, value}));
-				}
-			);
-			
-			userdata_type["get"] = [](const userdata& userdata, const sol::this_state s,
-				const sol::lua_value& key)
-			{
-				return convert(s, userdata.get(convert({s, key})));
-			};
-
-			userdata_type["set"] = [](const userdata& userdata, const sol::this_state s,
-				const sol::lua_value& key, const sol::lua_value& value)
-			{
-				userdata.set(convert({s, key}), convert({s, value}));
-			};
-
-			userdata_type[sol::meta_function::index] = [](const userdata& userdata, const sol::this_state s, 
-				const sol::lua_value& key)
-			{
-				return convert(s, userdata.get(convert({s, key})));
-			};
-
-			userdata_type[sol::meta_function::new_index] = [](const userdata& userdata, const sol::this_state s, 
-				const sol::lua_value& key, const sol::lua_value& value)
-			{
-				userdata.set(convert({s, key}), convert({s, value}));
-			};
-
-			auto table_type = state.new_usertype<table>("table_");
-
-			table_type["new"] = sol::property(
-				[](const table& table, const sol::this_state s)
-				{
-					return convert(s, table.get("new"));
-				},
-				[](const table& table, const sol::this_state s, const sol::lua_value& value)
-				{
-					table.set("new", convert({s, value}));
-				}
-			);
-
-			table_type["get"] = [](const table& table, const sol::this_state s,
-				const sol::lua_value& key)
-			{
-				return convert(s, table.get(convert({s, key})));
-			};
-
-			table_type["set"] = [](const table& table, const sol::this_state s,
-				const sol::lua_value& key, const sol::lua_value& value)
-			{
-				table.set(convert({s, key}), convert({s, value}));
-			};
-
-			table_type[sol::meta_function::index] = [](const table& table, const sol::this_state s,
-				const sol::lua_value& key)
-			{
-				return convert(s, table.get(convert({s, key})));
-			};
-
-			table_type[sol::meta_function::new_index] = [](const table& table, const sol::this_state s,
-				const sol::lua_value& key, const sol::lua_value& value)
-			{
-				table.set(convert({s, key}), convert({s, value}));
-			};
-
-			auto function_type = state.new_usertype<function>("function_");
-
-			function_type[sol::meta_function::call] = [](const function& function, const sol::this_state s, sol::variadic_args va)
-			{
-				arguments arguments{};
-
-				for (auto arg : va)
-				{
-					arguments.push_back(convert({s, arg}));
-				}
-
-				const auto values = function.call(arguments);
-				std::vector<sol::lua_value> returns;
-
-				for (const auto& value : values)
-				{
-					returns.push_back(convert(s, value));
-				}
-
-				return sol::as_returns(returns);
-			};
-
-			if (::game::environment::is_sp())
-			{
-				struct player
-				{
-				};
-				auto player_type = state.new_usertype<player>("player_");
-				state["player"] = player();
-
-				player_type["notify"] = [](const player&, const sol::this_state s, const std::string& name, sol::variadic_args va)
-				{
-					if (!::game::CL_IsCgameInitialized() || !::game::sp::g_entities[0].client)
-					{
-						throw std::runtime_error("Not in game");
-					}
-
-					const sol::state_view view{s};
-					const auto to_string = view["tostring"].get<sol::protected_function>();
-
-					std::vector<std::string> args{};
-					for (auto arg : va)
-					{
-						args.push_back(to_string.call(arg).get<std::string>());
-					}
-
-					::scheduler::once([s, name, args]()
-					{
-						try
-						{
-							std::vector<scripting::script_value> arguments{};
-
-							for (const auto& arg : args)
-							{
-								arguments.push_back(arg);
-							}
-
-							const auto player = scripting::call("getentbynum", {0}).as<scripting::entity>();
-							scripting::notify(player, name, arguments);
-						}
-						catch (...)
-						{
-						}
-					}, ::scheduler::pipeline::server);
-				};
-			}
-
-			state["luiglobals"] = table((*::game::hks::lua_state)->globals.v.table);
-			state["CoD"] = state["luiglobals"]["CoD"];
-			state["LUI"] = state["luiglobals"]["LUI"];
-			state["Engine"] = state["luiglobals"]["Engine"];
-			state["Game"] = state["luiglobals"]["Game"];
-
-			auto updater_table = sol::table::create(state.lua_state());
-
-			updater_table["relaunch"] = updater::relaunch;
-
-			updater_table["sethastriedupdate"] = updater::set_has_tried_update;
-			updater_table["gethastriedupdate"] = updater::get_has_tried_update;
-			updater_table["autoupdatesenabled"] = updater::auto_updates_enabled;
-
-			updater_table["startupdatecheck"] = updater::start_update_check;
-			updater_table["isupdatecheckdone"] = updater::is_update_check_done;
-			updater_table["getupdatecheckstatus"] = updater::get_update_check_status;
-			updater_table["isupdateavailable"] = updater::is_update_available;
-
-			updater_table["startupdatedownload"] = updater::start_update_download;
-			updater_table["isupdatedownloaddone"] = updater::is_update_download_done;
-			updater_table["getupdatedownloadstatus"] = updater::get_update_download_status;
-			updater_table["cancelupdate"] = updater::cancel_update;
-			updater_table["isrestartrequired"] = updater::is_restart_required;
-
-			updater_table["getlasterror"] = updater::get_last_error;
-			updater_table["getcurrentfile"] = updater::get_current_file;
-			
-			state["updater"] = updater_table;
-
-			auto discord_table = sol::table::create(state.lua_state());
-
-			discord_table["respond"] = discord::respond;
-			discord_table["getavatarmaterial"] = discord::get_avatar_material;
-			discord_table["reply"] = sol::table::create(state.lua_state());
-			discord_table["reply"]["yes"] = DISCORD_REPLY_YES;
-			discord_table["reply"]["ignore"] = DISCORD_REPLY_IGNORE;
-			discord_table["reply"]["no"] = DISCORD_REPLY_NO;
-
-			state["discord"] = discord_table;
-		}
-	}
-
-	context::context(std::string data, script_type type)
-		: scheduler_(state_)
-	{
-		this->state_.open_libraries(sol::lib::base,
-		                            sol::lib::package,
-		                            sol::lib::io,
-		                            sol::lib::string,
-		                            sol::lib::os,
-		                            sol::lib::math,
-		                            sol::lib::table);
-
-		setup_json(this->state_);
-		setup_io(this->state_);
-		setup_types(this->state_, this->scheduler_);
-
-		if (type == script_type::file)
-		{
-			this->folder_ = data;
-
-			this->state_["include"] = [this](const std::string& file)
-			{
-				this->load_script(file);
-			};
-
-			sol::function old_require = this->state_["require"];
-			auto base_path = utils::string::replace(this->folder_, "/", ".") + ".";
-			this->state_["require"] = [base_path, old_require](const std::string& path)
-			{
-				return old_require(base_path + path);
-			};
-
-			this->state_["scriptdir"] = [this]()
-			{
-				return this->folder_;
-			};
-
-			printf("Loading ui script '%s'\n", this->folder_.data());
-			this->load_script("__init__");
-		}
-
-		if (type == script_type::code)
-		{
-			handle_error(this->state_.safe_script(data, &sol::script_pass_on_error));
-		}
-	}
-
-	context::~context()
-	{
-		this->state_.collect_garbage();
-		this->scheduler_.clear();
-		this->state_ = {};
-	}
-
-	void context::run_frame()
-	{
-		this->scheduler_.run_frame();
-		this->state_.collect_garbage();
-	}
-
-	void context::load_script(const std::string& script)
-	{
-		if (!this->loaded_scripts_.emplace(script).second)
-		{
-			return;
-		}
-
-		const auto file = (std::filesystem::path{this->folder_} / (script + ".lua")).generic_string();
-		handle_error(this->state_.safe_script_file(file, &sol::script_pass_on_error));
-	}
-}
diff --git a/src/client/game/ui_scripting/lua/context.hpp b/src/client/game/ui_scripting/lua/context.hpp
deleted file mode 100644
index 866c601e..00000000
--- a/src/client/game/ui_scripting/lua/context.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-#pragma warning(push)
-#pragma warning(disable: 4702)
-
-#define SOL_ALL_SAFETIES_ON 1
-#define SOL_PRINT_ERRORS 0
-#include <sol/sol.hpp>
-
-#include "scheduler.hpp"
-
-namespace ui_scripting::lua
-{
-	enum script_type
-	{
-		file,
-		code
-	};
-
-	class context
-	{
-	public:
-		context(std::string folder, script_type type);
-		~context();
-
-		context(context&&) noexcept = delete;
-		context& operator=(context&&) noexcept = delete;
-
-		context(const context&) = delete;
-		context& operator=(const context&) = delete;
-
-		void run_frame();
-
-	private:
-		sol::state state_{};
-		std::string folder_;
-		std::unordered_set<std::string> loaded_scripts_;
-
-		scheduler scheduler_;
-
-		void load_script(const std::string& script);
-	};
-}
diff --git a/src/client/game/ui_scripting/lua/engine.cpp b/src/client/game/ui_scripting/lua/engine.cpp
deleted file mode 100644
index a52b1b9e..00000000
--- a/src/client/game/ui_scripting/lua/engine.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <std_include.hpp>
-#include "engine.hpp"
-#include "context.hpp"
-
-#include "../../../component/ui_scripting.hpp"
-#include "../../../component/filesystem.hpp"
-
-#include <utils/io.hpp>
-#include <utils/nt.hpp>
-
-namespace ui_scripting::lua::engine
-{
-	namespace
-	{
-		const auto lui_common = utils::nt::load_resource(LUI_COMMON);
-		const auto lui_updater = utils::nt::load_resource(LUI_UPDATER);
-
-		auto& get_scripts()
-		{
-			static std::vector<std::unique_ptr<context>> scripts{};
-			return scripts;
-		}
-
-		void load_scripts(const std::string& script_dir)
-		{
-			if (!utils::io::directory_exists(script_dir))
-			{
-				return;
-			}
-
-			const auto scripts = utils::io::list_files(script_dir);
-
-			for (const auto& script : scripts)
-			{
-				if (std::filesystem::is_directory(script) && utils::io::file_exists(script + "/__init__.lua"))
-				{
-					get_scripts().push_back(std::make_unique<context>(script, script_type::file));
-				}
-			}
-		}
-
-		void load_code(const std::string& code)
-		{
-			get_scripts().push_back(std::make_unique<context>(code, script_type::code));
-		}
-	}
-
-	void start()
-	{
-		clear_converted_functions();
-		get_scripts().clear();
-
-		load_code(lui_common);
-		load_code(lui_updater);
-
-		for (const auto& path : filesystem::get_search_paths())
-		{
-			load_scripts(path + "/ui_scripts/");
-			if (game::environment::is_sp())
-			{
-				load_scripts(path + "/ui_scripts/sp/");
-			}
-			else
-			{
-				load_scripts(path + "/ui_scripts/mp/");
-			}
-		}
-	}
-
-	void stop()
-	{
-		clear_converted_functions();
-		get_scripts().clear();
-	}
-
-	void run_frame()
-	{
-		for (auto& script : get_scripts())
-		{
-			script->run_frame();
-		}
-	}
-}
diff --git a/src/client/game/ui_scripting/lua/engine.hpp b/src/client/game/ui_scripting/lua/engine.hpp
deleted file mode 100644
index bbcf427c..00000000
--- a/src/client/game/ui_scripting/lua/engine.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-namespace ui_scripting::lua::engine
-{
-	void start();
-	void stop();
-	void run_frame();
-}
diff --git a/src/client/game/ui_scripting/lua/error.cpp b/src/client/game/ui_scripting/lua/error.cpp
deleted file mode 100644
index d13b4896..00000000
--- a/src/client/game/ui_scripting/lua/error.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <std_include.hpp>
-#include "error.hpp"
-
-namespace ui_scripting::lua
-{
-	void handle_error(const sol::protected_function_result& result)
-	{
-		if (!result.valid())
-		{
-			printf("************** UI Script execution error **************\n");
-
-			const sol::error err = result;
-			printf("%s\n", err.what());
-
-			printf("****************************************************\n");
-		}
-	}
-}
diff --git a/src/client/game/ui_scripting/lua/error.hpp b/src/client/game/ui_scripting/lua/error.hpp
deleted file mode 100644
index 28a5c453..00000000
--- a/src/client/game/ui_scripting/lua/error.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include "context.hpp"
-
-namespace ui_scripting::lua
-{
-	void handle_error(const sol::protected_function_result& result);
-}
diff --git a/src/client/game/ui_scripting/lua/scheduler.cpp b/src/client/game/ui_scripting/lua/scheduler.cpp
deleted file mode 100644
index 18e779b6..00000000
--- a/src/client/game/ui_scripting/lua/scheduler.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#include "std_include.hpp"
-#include "context.hpp"
-#include "error.hpp"
-
-namespace ui_scripting::lua
-{
-	scheduler::scheduler(sol::state& state)
-	{
-		auto task_handle_type = state.new_usertype<task_handle>("task_handle");
-
-		task_handle_type["clear"] = [this](const task_handle& handle)
-		{
-			this->remove(handle);
-		};
-	}
-
-	void scheduler::run_frame()
-	{
-		callbacks_.access([&](task_list& tasks)
-		{
-			this->merge_callbacks();
-
-			for (auto i = tasks.begin(); i != tasks.end();)
-			{
-				const auto now = std::chrono::high_resolution_clock::now();
-				const auto diff = now - i->last_call;
-
-				if (diff < i->delay)
-				{
-					++i;
-					continue;
-				}
-
-				i->last_call = now;
-
-				if (!i->is_deleted)
-				{
-					handle_error(i->callback());
-				}
-
-				if (i->is_volatile || i->is_deleted)
-				{
-					i = tasks.erase(i);
-				}
-				else
-				{
-					++i;
-				}
-			}
-		});
-	}
-
-	void scheduler::clear()
-	{
-		callbacks_.access([&](task_list& tasks)
-		{
-			new_callbacks_.access([&](task_list& new_tasks)
-			{
-				new_tasks.clear();
-				tasks.clear();
-			});
-		});
-	}
-
-	task_handle scheduler::add(const sol::protected_function& callback, const long long milliseconds,
-							   const bool is_volatile)
-	{
-		return this->add(callback, std::chrono::milliseconds(milliseconds), is_volatile);
-	}
-
-	task_handle scheduler::add(const sol::protected_function& callback, const std::chrono::milliseconds delay,
-							   const bool is_volatile)
-	{
-		const uint64_t id = ++this->current_task_id_;
-
-		task task;
-		task.is_volatile = is_volatile;
-		task.callback = callback;
-		task.delay = delay;
-		task.last_call = std::chrono::steady_clock::now();
-		task.id = id;
-		task.is_deleted = false;
-
-		new_callbacks_.access([&task](task_list& tasks)
-		{
-			tasks.emplace_back(std::move(task));
-		});
-
-		return {id};
-	}
-
-	void scheduler::remove(const task_handle& handle)
-	{
-		auto mask_as_deleted = [&](task_list& tasks)
-		{
-			for (auto& task : tasks)
-			{
-				if (task.id == handle.id)
-				{
-					task.is_deleted = true;
-					break;
-				}
-			}
-		};
-
-		callbacks_.access(mask_as_deleted);
-		new_callbacks_.access(mask_as_deleted);
-	}
-
-	void scheduler::merge_callbacks()
-	{
-		callbacks_.access([&](task_list& tasks)
-		{
-			new_callbacks_.access([&](task_list& new_tasks)
-			{
-				tasks.insert(tasks.end(), std::move_iterator<task_list::iterator>(new_tasks.begin()),
-							 std::move_iterator<task_list::iterator>(new_tasks.end()));
-				new_tasks = {};
-			});
-		});
-	}
-}
diff --git a/src/client/game/ui_scripting/lua/scheduler.hpp b/src/client/game/ui_scripting/lua/scheduler.hpp
deleted file mode 100644
index 1935e25e..00000000
--- a/src/client/game/ui_scripting/lua/scheduler.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-#include <utils/concurrency.hpp>
-
-namespace ui_scripting::lua
-{
-	class context;
-
-	class task_handle
-	{
-	public:
-		uint64_t id = 0;
-	};
-
-	class task final : public task_handle
-	{
-	public:
-		std::chrono::steady_clock::time_point last_call{};
-		sol::protected_function callback{};
-		std::chrono::milliseconds delay{};
-		bool is_volatile = false;
-		bool is_deleted = false;
-	};
-
-	class scheduler final
-	{
-	public:
-		scheduler(sol::state& state);
-
-		scheduler(scheduler&&) noexcept = delete;
-		scheduler& operator=(scheduler&&) noexcept = delete;
-
-		scheduler(const scheduler&) = delete;
-		scheduler& operator=(const scheduler&) = delete;
-
-		void run_frame();
-		void clear();
-
-		task_handle add(const sol::protected_function& callback, long long milliseconds, bool is_volatile);
-		task_handle add(const sol::protected_function& callback, std::chrono::milliseconds delay, bool is_volatile);
-
-	private:
-		using task_list = std::vector<task>;
-		utils::concurrency::container<task_list> new_callbacks_;
-		utils::concurrency::container<task_list, std::recursive_mutex> callbacks_;
-		std::atomic_int64_t current_task_id_ = 0;
-
-		void remove(const task_handle& handle);
-		void merge_callbacks();
-	};
-}
diff --git a/src/client/game/ui_scripting/lua/value_conversion.cpp b/src/client/game/ui_scripting/lua/value_conversion.cpp
deleted file mode 100644
index 38376cdf..00000000
--- a/src/client/game/ui_scripting/lua/value_conversion.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-#include <std_include.hpp>
-#include "value_conversion.hpp"
-#include "../execution.hpp"
-#include "../../../component/ui_scripting.hpp"
-
-namespace ui_scripting::lua
-{
-	namespace
-	{
-		table convert_table(const sol::table& t)
-		{
-			table res{};
-
-			t.for_each([res](const sol::object& key, const sol::object& value)
-			{
-				res.set(convert(key), convert(value));
-			});
-
-			return res;
-		}
-
-		script_value convert_function(const sol::protected_function& function)
-		{
-			const auto closure = game::hks::cclosure_Create(*game::hks::lua_state, main_function_handler, 0, 0, 0);
-			add_converted_function(closure, function);
-
-			game::hks::HksObject value{};
-			value.t = game::hks::TCFUNCTION;
-			value.v.cClosure = closure;
-
-			return value;
-		}
-	}
-
-	script_value convert(const sol::lua_value& value)
-	{
-		if (value.is<bool>())
-		{
-			return {value.as<bool>()};
-		}
-
-		if (value.is<int>())
-		{
-			return {value.as<int>()};
-		}
-
-		if (value.is<unsigned int>())
-		{
-			return {value.as<unsigned int>()};
-		}
-
-		if (value.is<double>())
-		{
-			return {value.as<double>()};
-		}
-
-		if (value.is<float>())
-		{
-			return {value.as<float>()};
-		}
-
-		if (value.is<std::string>())
-		{
-			return {value.as<std::string>()};
-		}
-
-		if (value.is<lightuserdata>())
-		{
-			return {value.as<lightuserdata>()};
-		}
-
-		if (value.is<userdata>())
-		{
-			return {value.as<userdata>()};
-		}
-
-		if (value.is<table>())
-		{
-			return {value.as<table>()};
-		}
-
-		if (value.is<function>())
-		{
-			return {value.as<function>()};
-		}
-
-		if (value.is<sol::table>())
-		{
-			return {convert_table(value.as<sol::table>())};
-		}
-
-		if (value.is<sol::protected_function>())
-		{
-			return {convert_function(value.as<sol::protected_function>())};
-		}
-
-		return {};
-	}
-
-	sol::lua_value convert(lua_State* state, const script_value& value)
-	{
-		if (value.is<int>())
-		{
-			return {state, value.as<int>()};
-		}
-
-		if (value.is<float>())
-		{
-			return {state, value.as<float>()};
-		}
-
-		if (value.is<bool>())
-		{
-			return {state, value.as<bool>()};
-		}
-
-		if (value.is<std::string>())
-		{
-			return {state, value.as<std::string>()};
-		}
-
-		if (value.is<lightuserdata>())
-		{
-			return {state, value.as<lightuserdata>()};
-		}
-
-		if (value.is<userdata>())
-		{
-			return {state, value.as<userdata>()};
-		}
-
-		if (value.is<table>())
-		{
-			return {state, value.as<table>()};
-		}
-
-		if (value.is<function>())
-		{
-			return {state, value.as<function>()};
-		}
-
-		return {state, sol::lua_nil};
-	}
-}
diff --git a/src/client/game/ui_scripting/lua/value_conversion.hpp b/src/client/game/ui_scripting/lua/value_conversion.hpp
deleted file mode 100644
index 21a67e33..00000000
--- a/src/client/game/ui_scripting/lua/value_conversion.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-#include "context.hpp"
-#include "../script_value.hpp"
-
-namespace ui_scripting::lua
-{
-	script_value convert(const sol::lua_value& value);
-	sol::lua_value convert(lua_State* state, const script_value& value);
-}
diff --git a/src/client/game/ui_scripting/script_value.cpp b/src/client/game/ui_scripting/script_value.cpp
index 34d17020..5f728f75 100644
--- a/src/client/game/ui_scripting/script_value.cpp
+++ b/src/client/game/ui_scripting/script_value.cpp
@@ -2,9 +2,79 @@
 #include "execution.hpp"
 #include "types.hpp"
 #include "script_value.hpp"
+#include "../../component/ui_scripting.hpp"
 
 namespace ui_scripting
 {
+	hks_object::hks_object(const game::hks::HksObject& value)
+	{
+		this->assign(value);
+	}
+
+	hks_object::hks_object(const hks_object& other) noexcept
+	{
+		this->operator=(other);
+	}
+
+	hks_object::hks_object(hks_object&& other) noexcept
+	{
+		this->operator=(std::move(other));
+	}
+
+	hks_object& hks_object::operator=(const hks_object& other) noexcept
+	{
+		if (this != &other)
+		{
+			this->release();
+			this->assign(other.value_);
+		}
+
+		return *this;
+	}
+
+	hks_object& hks_object::operator=(hks_object&& other) noexcept
+	{
+		if (this != &other)
+		{
+			this->release();
+			this->value_ = other.value_;
+			other.value_.t = game::hks::TNONE;
+		}
+
+		return *this;
+	}
+
+	hks_object::~hks_object()
+	{
+		this->release();
+	}
+
+	const game::hks::HksObject& hks_object::get() const
+	{
+		return this->value_;
+	}
+
+	void hks_object::assign(const game::hks::HksObject& value)
+	{
+		this->value_ = value;
+
+		const auto state = *game::hks::lua_state;
+		const auto top = state->m_apistack.top;
+
+		push_value(this->value_);
+		this->ref_ = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
+		state->m_apistack.top = top;
+	}
+
+	void hks_object::release()
+	{
+		if (this->ref_)
+		{
+			game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref_);
+			this->value_.t = game::hks::TNONE;
+		}
+	}
+
 	/***************************************************************
 	 * Constructors
 	 **************************************************************/
@@ -32,6 +102,24 @@ namespace ui_scripting
 		this->value_ = obj;
 	}
 
+	script_value::script_value(const long long value)
+	{
+		game::hks::HksObject obj{};
+		obj.t = game::hks::TUI64;
+		obj.v.i64 = value;
+
+		this->value_ = obj;
+	}
+
+	script_value::script_value(const unsigned long long value)
+	{
+		game::hks::HksObject obj{};
+		obj.t = game::hks::TUI64;
+		obj.v.ui64 = value;
+
+		this->value_ = obj;
+	}
+
 	script_value::script_value(const bool value)
 	{
 		game::hks::HksObject obj{};
@@ -55,46 +143,68 @@ namespace ui_scripting
 	{
 	}
 
-	script_value::script_value(const char* value)
+	script_value::script_value(const char* value, const size_t len)
 	{
 		game::hks::HksObject obj{};
 
 		const auto state = *game::hks::lua_state;
-		state->m_apistack.top = state->m_apistack.base;
+		if (state == nullptr)
+		{
+			return;
+		}
 
-		game::hks::hksi_lua_pushlstring(state, value, (unsigned int)strlen(value));
+		const auto top = state->m_apistack.top;
+		game::hks::hksi_lua_pushlstring(state, value, static_cast<unsigned int>(len));
 		obj = state->m_apistack.top[-1];
+		state->m_apistack.top = top;
 
 		this->value_ = obj;
 	}
 
+	script_value::script_value(const char* value)
+		: script_value(value, strlen(value))
+	{
+	}
+
 	script_value::script_value(const std::string& value)
-		: script_value(value.data())
+		: script_value(value.data(), value.size())
 	{
 	}
 
 	script_value::script_value(const lightuserdata& value)
 	{
-		this->value_.t = game::hks::TLIGHTUSERDATA;
-		this->value_.v.ptr = value.ptr;
+		game::hks::HksObject obj{};
+		obj.t = game::hks::TLIGHTUSERDATA;
+		obj.v.ptr = value.ptr;
+
+		this->value_ = obj;
 	}
 
 	script_value::script_value(const userdata& value)
 	{
-		this->value_.t = game::hks::TUSERDATA;
-		this->value_.v.ptr = value.ptr;
+		game::hks::HksObject obj{};
+		obj.t = game::hks::TUSERDATA;
+		obj.v.ptr = value.ptr;
+
+		this->value_ = obj;
 	}
 
 	script_value::script_value(const table& value)
 	{
-		this->value_.t = game::hks::TTABLE;
-		this->value_.v.ptr = value.ptr;
+		game::hks::HksObject obj{};
+		obj.t = game::hks::TTABLE;
+		obj.v.ptr = value.ptr;
+
+		this->value_ = obj;
 	}
 
 	script_value::script_value(const function& value)
 	{
-		this->value_.t = value.type;
-		this->value_.v.ptr = value.ptr;
+		game::hks::HksObject obj{};
+		obj.t = value.type;
+		obj.v.ptr = value.ptr;
+
+		this->value_ = obj;
 	}
 
 	/***************************************************************
@@ -126,6 +236,34 @@ namespace ui_scripting
 		return static_cast<unsigned int>(this->get_raw().v.number);
 	}
 
+	/***************************************************************
+	 * Integer 64
+	 **************************************************************/
+
+	template <>
+	bool script_value::is<long long>() const
+	{
+		return this->get_raw().t == game::hks::TUI64;
+	}
+
+	template <>
+	bool script_value::is<unsigned long long>() const
+	{
+		return this->is<long long>();
+	}
+
+	template <>
+	long long script_value::get() const
+	{
+		return static_cast<long long>(this->get_raw().v.ui64);
+	}
+
+	template <>
+	unsigned long long script_value::get() const
+	{
+		return static_cast<unsigned long long>(this->get_raw().v.ui64);
+	}
+
 	/***************************************************************
 	 * Boolean
 	 **************************************************************/
@@ -260,7 +398,7 @@ namespace ui_scripting
 	template <>
 	function script_value::get() const
 	{
-		return { this->get_raw().v.cClosure, this->get_raw().t };
+		return {this->get_raw().v.cClosure, this->get_raw().t};
 	}
 
 	/***************************************************************
@@ -269,6 +407,43 @@ namespace ui_scripting
 
 	const game::hks::HksObject& script_value::get_raw() const
 	{
-		return this->value_;
+		return this->value_.get();
+	}
+
+	bool script_value::operator==(const script_value& other) const
+	{
+		if (this->get_raw().t != other.get_raw().t)
+		{
+			return false;
+		}
+
+		if (this->get_raw().t == game::hks::TSTRING)
+		{
+			return this->get<std::string>() == other.get<std::string>();
+		}
+
+		return this->get_raw().v.native == other.get_raw().v.native;
+	}
+
+	arguments script_value::operator()() const
+	{
+		return this->as<function>()();
+	}
+
+	arguments script_value::operator()(const arguments& arguments) const
+	{
+		return this->as<function>()(arguments);
+	}
+
+	function_argument::function_argument(const arguments& args, const script_value& value, const int index)
+		: values_(args)
+		  , value_(value)
+		  , index_(index)
+	{
+	}
+
+	function_arguments::function_arguments(const arguments& values)
+		: values_(values)
+	{
 	}
 }
diff --git a/src/client/game/ui_scripting/script_value.hpp b/src/client/game/ui_scripting/script_value.hpp
index a16d2622..309be980 100644
--- a/src/client/game/ui_scripting/script_value.hpp
+++ b/src/client/game/ui_scripting/script_value.hpp
@@ -1,12 +1,92 @@
 #pragma once
 #include "game/game.hpp"
 
+#include <utils/string.hpp>
+
 namespace ui_scripting
 {
 	class lightuserdata;
+	class userdata_value;
 	class userdata;
+	class table_value;
 	class table;
 	class function;
+	class script_value;
+
+	namespace
+	{
+		template <typename T>
+		std::string get_typename()
+		{
+			auto& info = typeid(T);
+
+			if (info == typeid(std::string) ||
+				info == typeid(const char*))
+			{
+				return "string";
+			}
+
+			if (info == typeid(lightuserdata))
+			{
+				return "lightuserdata";
+			}
+
+			if (info == typeid(userdata))
+			{
+				return "userdata";
+			}
+
+			if (info == typeid(table))
+			{
+				return "table";
+			}
+
+			if (info == typeid(function))
+			{
+				return "function";
+			}
+
+			if (info == typeid(int) || 
+				info == typeid(float) || 
+				info == typeid(unsigned int))
+			{
+				return "number";
+			}
+
+			if (info == typeid(bool))
+			{
+				return "boolean";
+			}
+
+			return info.name();
+		}
+	}
+
+	class hks_object
+	{
+	public:
+		hks_object() = default;
+		hks_object(const game::hks::HksObject& value);
+		hks_object(const hks_object& other) noexcept;
+		hks_object(hks_object&& other) noexcept;
+
+		hks_object& operator=(const hks_object& other) noexcept;
+		hks_object& operator=(hks_object&& other) noexcept;
+
+		~hks_object();
+
+		const game::hks::HksObject& get() const;
+
+	private:
+		void assign(const game::hks::HksObject& value);
+		void release();
+
+		game::hks::HksObject value_{game::hks::TNONE, {}};
+		int ref_{};
+	};
+
+	using arguments = std::vector<script_value>;
+	using event_arguments = std::unordered_map<std::string, script_value>;
 
 	class script_value
 	{
@@ -16,12 +96,15 @@ namespace ui_scripting
 
 		script_value(int value);
 		script_value(unsigned int value);
+		script_value(long long value);
+		script_value(unsigned long long value);
 		script_value(bool value);
 
 		script_value(float value);
 		script_value(double value);
 
 		script_value(const char* value);
+		script_value(const char* value, const size_t len);
 		script_value(const std::string& value);
 
 		script_value(const lightuserdata& value);
@@ -29,6 +112,53 @@ namespace ui_scripting
 		script_value(const table& value);
 		script_value(const function& value);
 
+		template <template<class, class> class C, class T, typename TableType = table>
+		script_value(const C<T, std::allocator<T>>& container)
+		{
+			TableType table_{};
+			int index = 1;
+
+			for (const auto& value : container)
+			{
+				table_.set(index++, value);
+			}
+
+			game::hks::HksObject obj{};
+			obj.t = game::hks::TTABLE;
+			obj.v.ptr = table_.ptr;
+
+			this->value_ = obj;
+		}
+
+		template <typename F>
+		script_value(F f)
+			: script_value(function(f))
+		{
+		}
+
+		bool operator==(const script_value& other) const;
+
+		arguments operator()() const;
+		arguments operator()(const arguments& arguments) const;
+
+		template<class ...T>
+		arguments operator()(T... arguments) const
+		{
+			return this->as<function>().call({arguments...});
+		}
+
+		template <size_t Size>
+		table_value operator[](const char(&key)[Size]) const
+		{
+			return {this->as<table>(), key};
+		}
+
+		template <typename T = script_value>
+		table_value operator[](const T& key) const
+		{
+			return {this->as<table>(), key};
+		}
+
 		template <typename T>
 		bool is() const;
 
@@ -37,21 +167,93 @@ namespace ui_scripting
 		{
 			if (!this->is<T>())
 			{
-				throw std::runtime_error("Invalid type");
+				const auto hks_typename = game::hks::typenames[this->get_raw().t + 2];
+				const auto typename_ = get_typename<T>();
+
+				throw std::runtime_error(utils::string::va("%s expected, got %s",
+					typename_.data(), hks_typename));
 			}
 
 			return get<T>();
 		}
 
+		template <typename T>
+		operator T() const
+		{
+			return this->as<T>();
+		}
+
 		const game::hks::HksObject& get_raw() const;
 
+		hks_object value_{};
+
 	private:
 		template <typename T>
 		T get() const;
 
-		game::hks::HksObject value_{};
 	};
 
-	using arguments = std::vector<script_value>;
-	using event_arguments = std::unordered_map<std::string, script_value>;
+	class variadic_args : public arguments
+	{
+	};
+
+	class function_argument
+	{
+	public:
+		function_argument(const arguments& args, const script_value& value, const int index);
+
+		template <typename T>
+		T as() const
+		{
+			try
+			{
+				return this->value_.as<T>();
+			}
+			catch (const std::exception& e)
+			{
+				throw std::runtime_error(utils::string::va("bad argument #%d (%s)",
+					this->index_ + 1, e.what()));
+			}
+		}
+
+		template <>
+		variadic_args as() const
+		{
+			variadic_args args{};
+			for (auto i = this->index_; i < this->values_.size(); i++)
+			{
+				args.push_back(this->values_[i]);
+			}
+			return args;
+		}
+
+		template <typename T>
+		operator T() const
+		{
+			return this->as<T>();
+		}
+
+	private:
+		arguments values_{};
+		script_value value_{};
+		int index_{};
+	};
+
+	class function_arguments
+	{
+	public:
+		function_arguments(const arguments& values);
+
+		function_argument operator[](const int index) const
+		{
+			if (index >= values_.size())
+			{
+				return {values_, {}, index};
+			}
+
+			return {values_, values_[index], index};
+		}
+	private:
+		arguments values_{};
+	};
 }
diff --git a/src/client/game/ui_scripting/types.cpp b/src/client/game/ui_scripting/types.cpp
index 4323df0a..125bf380 100644
--- a/src/client/game/ui_scripting/types.cpp
+++ b/src/client/game/ui_scripting/types.cpp
@@ -1,350 +1,355 @@
 #include <std_include.hpp>
 #include "types.hpp"
 #include "execution.hpp"
+#include "../../component/ui_scripting.hpp"
 
 namespace ui_scripting
 {
-	/***************************************************************
-	 * Lightuserdata
-	 **************************************************************/
-
-	lightuserdata::lightuserdata(void* ptr_)
-		: ptr(ptr_)
-	{
-	}
-
-	bool lightuserdata::operator==(const lightuserdata& other)
-	{
-		return this->ptr == other.ptr;
-	}
-
-	bool lightuserdata::operator!=(const lightuserdata& other)
-	{
-		return this->ptr != other.ptr;
-	}
-
-	/***************************************************************
-	 * Userdata
-	 **************************************************************/
-
-	userdata::userdata(void* ptr_)
-		: ptr(ptr_)
-	{
-		this->add();
-	}
-
-	userdata::userdata(const userdata& other)
-	{
-		this->operator=(other);
-	}
-
-	userdata::userdata(userdata&& other) noexcept
-	{
-		this->ptr = other.ptr;
-		this->ref = other.ref;
-		other.ref = 0;
-	}
-
-	userdata::~userdata()
-	{
-		this->release();
-	}
-
-	userdata& userdata::operator=(const userdata& other)
-	{
-		if (&other != this)
-		{
-			this->release();
-			this->ptr = other.ptr;
-			this->ref = other.ref;
-			this->add();
-		}
-
-		return *this;
-	}
-
-	userdata& userdata::operator=(userdata&& other) noexcept
-	{
-		if (&other != this)
-		{
-			this->release();
-			this->ptr = other.ptr;
-			this->ref = other.ref;
-			other.ref = 0;
-		}
-
-		return *this;
-	}
-
-	bool userdata::operator==(const userdata& other)
-	{
-		return this->ptr == other.ptr;
-	}
-
-	bool userdata::operator!=(const userdata& other)
-	{
-		return this->ptr != other.ptr;
-	}
-
-	void userdata::add()
-	{
-		game::hks::HksObject value{};
-		value.v.ptr = this->ptr;
-		value.t = game::hks::TUSERDATA;
-
-		const auto state = *game::hks::lua_state;
-		state->m_apistack.top = state->m_apistack.base;
-
-		push_value(value);
-
-		this->ref = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
-	}
-
-	void userdata::release()
-	{
-		if (this->ref)
-		{
-			game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref);
-		}
-	}
-
-	void userdata::set(const script_value& key, const script_value& value) const
-	{
-		set_field(*this, key, value);
-	}
-
-	script_value userdata::get(const script_value& key) const
-	{
-		return get_field(*this, key);
-	}
-
-	/***************************************************************
-	 * Table
-	 **************************************************************/
-
-	table::table()
-	{
-		const auto state = *game::hks::lua_state;
-		this->ptr = game::hks::Hashtable_Create(state, 0, 0);
-		this->add();
-	}
-
-	table::table(game::hks::HashTable* ptr_)
-		: ptr(ptr_)
-	{
-		this->add();
-	}
-
-	table::table(const table& other)
-	{
-		this->operator=(other);
-	}
-
-	table::table(table&& other) noexcept
-	{
-		this->ptr = other.ptr;
-		this->ref = other.ref;
-		other.ref = 0;
-	}
-
-	table::~table()
-	{
-		this->release();
-	}
-
-	table& table::operator=(const table& other)
-	{
-		if (&other != this)
-		{
-			this->release();
-			this->ptr = other.ptr;
-			this->ref = other.ref;
-			this->add();
-		}
-
-		return *this;
-	}
-
-	table& table::operator=(table&& other) noexcept
-	{
-		if (&other != this)
-		{
-			this->release();
-			this->ptr = other.ptr;
-			this->ref = other.ref;
-			other.ref = 0;
-		}
-
-		return *this;
-	}
-
-	bool table::operator==(const table& other)
-	{
-		return this->ptr == other.ptr;
-	}
-
-	bool table::operator!=(const table& other)
-	{
-		return this->ptr != other.ptr;
-	}
-
-	void table::add()
-	{
-		game::hks::HksObject value{};
-		value.v.table = this->ptr;
-		value.t = game::hks::TTABLE;
-
-		const auto state = *game::hks::lua_state;
-		state->m_apistack.top = state->m_apistack.base;
-
-		push_value(value);
-
-		this->ref = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
-	}
-
-	void table::release()
-	{
-		if (this->ref)
-		{
-			game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref);
-		}
-	}
-
-	void table::set(const script_value& key, const script_value& value) const
-	{
-		set_field(*this, key, value);
-	}
-
-	script_value table::get(const script_value& key) const
-	{
-		return get_field(*this, key);
-	}
-
-	/***************************************************************
-	 * Function
-	 **************************************************************/
-
-	function::function(game::hks::cclosure* ptr_, game::hks::HksObjectType type_)
-		: ptr(ptr_)
-		, type(type_)
-	{
-		this->add();
-	}
-
-	function::function(const function& other)
-	{
-		this->operator=(other);
-	}
-
-	function::function(function&& other) noexcept
-	{
-		this->ptr = other.ptr;
-		this->type = other.type;
-		this->ref = other.ref;
-		other.ref = 0;
-	}
-
-	function::~function()
-	{
-		this->release();
-	}
-
-	function& function::operator=(const function& other)
-	{
-		if (&other != this)
-		{
-			this->release();
-			this->ptr = other.ptr;
-			this->type = other.type;
-			this->ref = other.ref;
-			this->add();
-		}
-
-		return *this;
-	}
-
-	function& function::operator=(function&& other) noexcept
-	{
-		if (&other != this)
-		{
-			this->release();
-			this->ptr = other.ptr;
-			this->type = other.type;
-			this->ref = other.ref;
-			other.ref = 0;
-		}
-
-		return *this;
-	}
-
-	bool function::operator==(const function& other)
-	{
-		return this->ptr == other.ptr;
-	}
-
-	bool function::operator!=(const function& other)
-	{
-		return this->ptr != other.ptr;
-	}
-
-	void function::add()
-	{
-		game::hks::HksObject value{};
-		value.v.cClosure = this->ptr;
-		value.t = this->type;
-
-		const auto state = *game::hks::lua_state;
-		state->m_apistack.top = state->m_apistack.base;
-
-		push_value(value);
-
-		this->ref = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
-	}
-
-	void function::release()
-	{
-		if (this->ref)
-		{
-			game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref);
-		}
-	}
-
-	arguments function::call(const arguments& arguments) const
-	{
-		return call_script_function(*this, arguments);
-	}
-
-	/***************************************************************
-     * Stack
+    /***************************************************************
+     * Lightuserdata
      **************************************************************/
 
-    stack::stack()
+    lightuserdata::lightuserdata(void* ptr_)
+        : ptr(ptr_)
     {
-        this->state = *game::hks::lua_state;
-        this->state->m_apistack.top = this->state->m_apistack.base;
     }
 
-    void stack::save(int num_args)
+    /***************************************************************
+     * Userdata
+     **************************************************************/
+
+    userdata::userdata(void* ptr_)
+        : ptr(ptr_)
     {
-        this->num_args_ = num_args;
-        this->num_calls_ = state->m_numberOfCCalls;
-        this->base_bottom_ = state->m_apistack.base - state->m_apistack.bottom;
-        this->top_bottom_ = state->m_apistack.top - state->m_apistack.bottom;
-        this->callstack_ = state->m_callStack.m_current - state->m_callStack.m_records;
+        this->add();
     }
 
-    void stack::fix()
+    userdata::userdata(const userdata& other)
     {
-        this->state->m_numberOfCCalls = this->num_calls_;
+        this->operator=(other);
+    }
 
-        game::hks::closePendingUpvalues(this->state, &this->state->m_apistack.bottom[this->top_bottom_ - this->num_args_]);
-        this->state->m_callStack.m_current = &this->state->m_callStack.m_records[this->callstack_];
+    userdata::userdata(userdata&& other) noexcept
+    {
+        this->ptr = other.ptr;
+        this->ref = other.ref;
+        other.ref = 0;
+    }
 
-        this->state->m_apistack.base = &this->state->m_apistack.bottom[this->base_bottom_];
-        this->state->m_apistack.top = &this->state->m_apistack.bottom[this->top_bottom_ - static_cast<uint64_t>(this->num_args_ + 1)];
+    userdata::~userdata()
+    {
+        this->release();
+    }
 
-        this->state->m_apistack.bottom[this->top_bottom_].t = this->state->m_apistack.top[-1].t;
-        this->state->m_apistack.bottom[this->top_bottom_].v.ptr = this->state->m_apistack.top[-1].v.ptr;
-        this->state->m_apistack.top = &this->state->m_apistack.bottom[this->top_bottom_ + 1];
+    userdata& userdata::operator=(const userdata& other)
+    {
+        if (&other != this)
+        {
+            this->release();
+            this->ptr = other.ptr;
+            this->ref = other.ref;
+            this->add();
+        }
+
+        return *this;
+    }
+
+    userdata& userdata::operator=(userdata&& other) noexcept
+    {
+        if (&other != this)
+        {
+            this->release();
+            this->ptr = other.ptr;
+            this->ref = other.ref;
+            other.ref = 0;
+        }
+
+        return *this;
+    }
+
+    void userdata::add()
+    {
+        game::hks::HksObject value{};
+        value.v.ptr = this->ptr;
+        value.t = game::hks::TUSERDATA;
+
+        const auto state = *game::hks::lua_state;
+        const auto top = state->m_apistack.top;
+
+        push_value(value);
+
+        this->ref = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
+        state->m_apistack.top = top;
+    }
+
+    void userdata::release()
+    {
+        if (this->ref)
+        {
+            game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref);
+        }
+    }
+
+    void userdata::set(const script_value& key, const script_value& value) const
+    {
+        set_field(*this, key, value);
+    }
+
+    script_value userdata::get(const script_value& key) const
+    {
+        return get_field(*this, key);
+    }
+
+    userdata_value userdata::operator[](const script_value& key) const
+    {
+        return {*this, key};
+    }
+
+    userdata_value::userdata_value(const userdata& table, const script_value& key)
+        : userdata_(table)
+        , key_(key)
+    {
+        this->value_ = this->userdata_.get(key).get_raw();
+    }
+
+    void userdata_value::operator=(const script_value& value)
+    {
+        this->userdata_.set(this->key_, value);
+        this->value_ = value.get_raw();
+    }
+
+    bool userdata_value::operator==(const script_value& value)
+    {
+        return this->userdata_.get(this->key_) == value;
+    }
+
+    /***************************************************************
+     * Table
+     **************************************************************/
+
+    table::table()
+    {
+        const auto state = *game::hks::lua_state;
+        this->ptr = game::hks::Hashtable_Create(state, 0, 0);
+        this->add();
+    }
+
+    table::table(game::hks::HashTable* ptr_)
+        : ptr(ptr_)
+    {
+        this->add();
+    }
+
+    table::table(const table& other)
+    {
+        this->operator=(other);
+    }
+
+    table::table(table&& other) noexcept
+    {
+        this->ptr = other.ptr;
+        this->ref = other.ref;
+        other.ref = 0;
+    }
+
+    table::~table()
+    {
+        this->release();
+    }
+
+    table& table::operator=(const table& other)
+    {
+        if (&other != this)
+        {
+            this->release();
+            this->ptr = other.ptr;
+            this->ref = other.ref;
+            this->add();
+        }
+
+        return *this;
+    }
+
+    table& table::operator=(table&& other) noexcept
+    {
+        if (&other != this)
+        {
+            this->release();
+            this->ptr = other.ptr;
+            this->ref = other.ref;
+            other.ref = 0;
+        }
+
+        return *this;
+    }
+
+    void table::add()
+    {
+        game::hks::HksObject value{};
+        value.v.table = this->ptr;
+        value.t = game::hks::TTABLE;
+
+        const auto state = *game::hks::lua_state;
+        const auto top = state->m_apistack.top;
+
+        push_value(value);
+
+        this->ref = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
+        state->m_apistack.top = top;
+    }
+
+    void table::release()
+    {
+        if (this->ref)
+        {
+            game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref);
+        }
+    }
+
+    void table::set(const script_value& key, const script_value& value) const
+    {
+        set_field(*this, key, value);
+    }
+
+    table_value table::operator[](const script_value& key) const
+    {
+        return {*this, key};
+    }
+
+    script_value table::get(const script_value& key) const
+    {
+        return get_field(*this, key);
+    }
+
+    table_value::table_value(const table& table, const script_value& key)
+        : table_(table)
+        , key_(key)
+    {
+        this->value_ = this->table_.get(key).get_raw();
+    }
+
+    void table_value::operator=(const script_value& value)
+    {
+        this->table_.set(this->key_, value);
+        this->value_ = value.get_raw();
+    }
+
+    void table_value::operator=(const table_value& value)
+    {
+        this->table_.set(this->key_, value);
+        this->value_ = value.get_raw();
+    }
+
+    bool table_value::operator==(const script_value& value)
+    {
+        return this->table_.get(this->key_) == value;
+    }
+
+    bool table_value::operator==(const table_value& value)
+    {
+        return this->table_.get(this->key_) == value;
+    }
+
+    /***************************************************************
+     * Function
+     **************************************************************/
+
+    function::function(game::hks::lua_function func)
+    {
+        const auto state = *game::hks::lua_state;
+        this->ptr = game::hks::cclosure_Create(state, func, 0, 0, 0);
+        this->type = game::hks::HksObjectType::TCFUNCTION;
+        this->add();
+    }
+
+    function::function(game::hks::cclosure* ptr_, game::hks::HksObjectType type_)
+        : ptr(ptr_)
+        , type(type_)
+    {
+        this->add();
+    }
+
+    function::function(const function& other)
+    {
+        this->operator=(other);
+    }
+
+    function::function(function&& other) noexcept
+    {
+        this->ptr = other.ptr;
+        this->type = other.type;
+        this->ref = other.ref;
+        other.ref = 0;
+    }
+
+    function::~function()
+    {
+        this->release();
+    }
+
+    function& function::operator=(const function& other)
+    {
+        if (&other != this)
+        {
+            this->release();
+            this->ptr = other.ptr;
+            this->type = other.type;
+            this->ref = other.ref;
+            this->add();
+        }
+
+        return *this;
+    }
+
+    function& function::operator=(function&& other) noexcept
+    {
+        if (&other != this)
+        {
+            this->release();
+            this->ptr = other.ptr;
+            this->type = other.type;
+            this->ref = other.ref;
+            other.ref = 0;
+        }
+
+        return *this;
+    }
+
+    void function::add()
+    {
+        game::hks::HksObject value{};
+        value.v.cClosure = this->ptr;
+        value.t = this->type;
+
+        const auto state = *game::hks::lua_state;
+        const auto top = state->m_apistack.top;
+
+        push_value(value);
+
+        this->ref = game::hks::hksi_luaL_ref(*game::hks::lua_state, -10000);
+        state->m_apistack.top = top;
+    }
+
+    void function::release()
+    {
+        if (this->ref)
+        {
+            game::hks::hksi_luaL_unref(*game::hks::lua_state, -10000, this->ref);
+        }
+    }
+
+    arguments function::call(const arguments& arguments) const
+    {
+        return call_script_function(*this, arguments);
+    }
+
+    arguments function::operator()(const arguments& arguments) const
+    {
+        return this->call(arguments);
+    }
+
+    arguments function::operator()() const
+    {
+        return this->call({});
     }
 }
diff --git a/src/client/game/ui_scripting/types.hpp b/src/client/game/ui_scripting/types.hpp
index 0eb4aeda..d5e94b4b 100644
--- a/src/client/game/ui_scripting/types.hpp
+++ b/src/client/game/ui_scripting/types.hpp
@@ -1,126 +1,140 @@
 #pragma once
 #include "game/game.hpp"
 #include "script_value.hpp"
+#include "../../component/ui_scripting.hpp"
 
 namespace ui_scripting
 {
-	class lightuserdata
-	{
-	public:
-		lightuserdata(void*);
+    class lightuserdata
+    {
+    public:
+        lightuserdata(void*);
+        void* ptr;
+    };
 
-		bool operator==(const lightuserdata& other);
-		bool operator!=(const lightuserdata& other);
+    class userdata_value;
 
-		void* ptr;
-	};
+    class userdata
+    {
+    public:
+        userdata(void*);
 
-	class userdata
-	{
-	public:
-		userdata(void*);
+        userdata(const userdata& other);
+        userdata(userdata&& other) noexcept;
 
-		userdata(const userdata& other);
-		userdata(userdata&& other) noexcept;
+        ~userdata();
 
-		~userdata();
+        userdata& operator=(const userdata& other);
+        userdata& operator=(userdata&& other) noexcept;
 
-		userdata& operator=(const userdata& other);
-		userdata& operator=(userdata&& other) noexcept;
+        script_value get(const script_value& key) const;
+        void set(const script_value& key, const script_value& value) const;
 
-		bool operator==(const userdata& other);
-		bool operator!=(const userdata& other);
+        userdata_value operator[](const script_value& key) const;
 
-		script_value get(const script_value& key) const;
-		void set(const script_value& key, const script_value& value) const;
+        void* ptr;
 
-		void* ptr;
+    private:
+        void add();
+        void release();
 
-	private:
-		void add();
-		void release();
+        int ref{};
+    };
 
-		int ref{};
-	};
+    class userdata_value : public script_value
+    {
+    public:
+        userdata_value(const userdata& table, const script_value& key);
+        void operator=(const script_value& value);
+        bool operator==(const script_value& value);
+    private:
+        userdata userdata_;
+        script_value key_;
+    };
 
-	class table
-	{
-	public:
-		table();
-		table(game::hks::HashTable* ptr_);
+    class table_value;
 
-		table(const table& other);
-		table(table&& other) noexcept;
+    class table
+    {
+    public:
+        table();
+        table(game::hks::HashTable* ptr_);
 
-		~table();
+        table(const table& other);
+        table(table&& other) noexcept;
 
-		table& operator=(const table& other);
-		table& operator=(table&& other) noexcept;
+        ~table();
 
-		bool operator==(const table& other);
-		bool operator!=(const table& other);
+        table& operator=(const table& other);
+        table& operator=(table&& other) noexcept;
 
-		script_value get(const script_value& key) const;
-		void set(const script_value& key, const script_value& value) const;
+        script_value get(const script_value& key) const;
+        void set(const script_value& key, const script_value& value) const;
 
-		game::hks::HashTable* ptr;
+        table_value operator[](const script_value& key) const;
 
-	private:
-		void add();
-		void release();
+        game::hks::HashTable* ptr;
 
-		int ref{};
-	};
+    private:
+        void add();
+        void release();
 
-	class function
-	{
-	public:
-		function(game::hks::cclosure*, game::hks::HksObjectType);
+        int ref{};
+    };
 
-		function(const function& other);
-		function(function&& other) noexcept;
+    class table_value : public script_value
+    {
+    public:
+        table_value(const table& table, const script_value& key);
+        void operator=(const script_value& value);
+        void operator=(const table_value& value);
+        bool operator==(const script_value& value);
+        bool operator==(const table_value& value);
+    private:
+        table table_;
+        script_value key_;
+    };
 
-		~function();
+    class function
+    {
+    public:
+        function(game::hks::lua_function);
+        function(game::hks::cclosure*, game::hks::HksObjectType);
 
-		function& operator=(const function& other);
-		function& operator=(function&& other) noexcept;
+        template <typename F>
+        function(F f)
+        {
+            this->ptr = ui_scripting::convert_function(f);
+            this->type = game::hks::TCFUNCTION;
+        }
 
-		bool operator==(const function& other);
-		bool operator!=(const function& other);
+        function(const function& other);
+        function(function&& other) noexcept;
 
-		arguments call(const arguments& arguments) const;
+        ~function();
 
-		game::hks::cclosure* ptr;
-		game::hks::HksObjectType type;
+        function& operator=(const function& other);
+        function& operator=(function&& other) noexcept;
 
-	private:
-		void add();
-		void release();
+        arguments call(const arguments& arguments) const;
 
-		int ref{};
-	};
+        arguments operator()(const arguments& arguments) const;
 
-	class stack final
-	{
-	public:
-		stack();
+        template<class ...T>
+        arguments operator()(T... arguments) const
+        {
+            return this->call({arguments...});
+        }
 
-		void save(int num_args);
-		void fix();
+        arguments operator()() const;
 
-		stack(stack&&) = delete;
-		stack(const stack&) = delete;
-		stack& operator=(stack&&) = delete;
-		stack& operator=(const stack&) = delete;
+        game::hks::cclosure* ptr;
+        game::hks::HksObjectType type;
 
-	private:
-		game::hks::lua_State* state;
+    private:
+        void add();
+        void release();
 
-		int num_args_;
-		int num_calls_;
-
-		uint64_t base_bottom_;
-		uint64_t top_bottom_;
-		uint64_t callstack_;
-	};
+        int ref{};
+    };
 }