diff --git a/SlipeServer.Console/AdditionalResources/Parachute/ServerBuilderExtensions.cs b/SlipeServer.Console/AdditionalResources/Parachute/ServerBuilderExtensions.cs
index fbed20f7..41e7012b 100644
--- a/SlipeServer.Console/AdditionalResources/Parachute/ServerBuilderExtensions.cs
+++ b/SlipeServer.Console/AdditionalResources/Parachute/ServerBuilderExtensions.cs
@@ -2,7 +2,7 @@
 using SlipeServer.Server.ServerBuilders;
 
 namespace SlipeServer.Console.AdditionalResources;
-public static class ServerBuilderExtensions
+public static partial class ServerBuilderExtensions
 {
     public static void AddParachuteResource(this ServerBuilder builder)
     {
diff --git a/SlipeServer.Console/Logic/LuaTestLogic.cs b/SlipeServer.Console/Logic/LuaTestLogic.cs
index 5b2e1577..c283f1fc 100644
--- a/SlipeServer.Console/Logic/LuaTestLogic.cs
+++ b/SlipeServer.Console/Logic/LuaTestLogic.cs
@@ -24,23 +24,24 @@ ILogger logger
         this.eventRuntime = eventRuntime;
         this.luaService = luaService;
         this.logger = logger;
-        commandService.AddCommand("lua").Triggered += (source, args) => Init();
+        //commandService.AddCommand("lua").Triggered += (source, args) => Init();
+        Init();
     }
 
     private void Init()
     {
         this.eventRuntime.LoadDefaultEvents();
 
-        this.luaService.LoadDefaultDefinitions();
-
-        this.luaService.LoadDefinitions<CustomMathDefinition>();
-        this.luaService.LoadDefinitions<TestDefinition>();
-
         using FileStream testLua = File.OpenRead("test.lua");
         using StreamReader reader = new StreamReader(testLua);
         try
         {
-            this.luaService.LoadScript("test.lua", reader.ReadToEnd());
+            Script createdScript = this.luaService.LoadScript("test.lua", reader.ReadToEnd());
+
+            this.luaService.LoadDefaultDefinitions(createdScript);
+            this.luaService.LoadDefinitions<CustomMathDefinition>(createdScript);
+            this.luaService.LoadDefinitions<TestDefinition>(createdScript);
+
         }
         catch (InterpreterException ex)
         {
diff --git a/SlipeServer.Console/Program.cs b/SlipeServer.Console/Program.cs
index c83cbddb..b2d6dc1e 100644
--- a/SlipeServer.Console/Program.cs
+++ b/SlipeServer.Console/Program.cs
@@ -14,6 +14,7 @@
 using SlipeServer.Server;
 using SlipeServer.Server.Loggers;
 using SlipeServer.Server.PacketHandling.Handlers.Middleware;
+using SlipeServer.Server.Resources.Providers;
 using SlipeServer.Server.ServerBuilders;
 using System;
 using System.Threading;
diff --git a/SlipeServer.Console/Resources/SecondTestResource/test.lua b/SlipeServer.Console/Resources/SecondTestResource/test.lua
index 0a529bba..51183cc1 100644
--- a/SlipeServer.Console/Resources/SecondTestResource/test.lua
+++ b/SlipeServer.Console/Resources/SecondTestResource/test.lua
@@ -1 +1 @@
-outputChatBox("I am a second resource")
+outputChatBox("This is the second resource")
diff --git a/SlipeServer.Console/test.lua b/SlipeServer.Console/test.lua
index 024097cc..6bdbf7bc 100644
--- a/SlipeServer.Console/test.lua
+++ b/SlipeServer.Console/test.lua
@@ -1,4 +1,16 @@
 if(isSlipeServer)then
+
+	iprint("This is a message on server printed using iprint", "This is the second Argument from iprint")
+
+	local customElement = createElement("MyCustomType")
+	iprint("Custom Element ", customElement)
+
+	--setElementData(customElement, "dummyKey", "dummyValue")
+
+	--local elementData = getElementData(customElement, "dummyKey")
+
+	--iprint("Element Data Is ", elementData)
+
 	local object = createObject(321, 5, 5, 5)
 	setElementPosition(object, 50, 50, 250)
 	setElementRotation(object, 180, 180, 90)
@@ -20,6 +32,8 @@
 
 	outputDebugString("Debug message, elapsed time: "..getTickCount())
 
+	print("iprint is ", iprint)
+
 	print("base64 test:", base64Encode("sample text"), base64Decode(base64Encode("sample text")))
 	print("Some color: ", tocolor(235,23,77,159), tocolor(235,23,77,159) == -1611983027)
 	print("getColorFromString: ", getColorFromString("#ff0000"));
@@ -81,4 +95,5 @@ addCommandHandler("foo3", commandHandler3)
 addCommandHandler("foo4", commandHandler2)
 addCommandHandler("foo4", commandHandler3)
 removeCommandHandler("foo3", commandHandler2)
-removeCommandHandler("foo4")
\ No newline at end of file
+removeCommandHandler("foo4")
+
diff --git a/SlipeServer.Lua/LuaService.cs b/SlipeServer.Lua/LuaService.cs
index 9a0069d9..0c887637 100644
--- a/SlipeServer.Lua/LuaService.cs
+++ b/SlipeServer.Lua/LuaService.cs
@@ -19,7 +19,7 @@ public class LuaService
     private readonly ILogger logger;
     private readonly RootElement root;
     private readonly Dictionary<string, Script> scripts;
-    private readonly Dictionary<string, LuaMethod> methods;
+    private readonly Dictionary<Script, Dictionary<string, LuaMethod>> methods;
     private readonly LuaTranslator translator;
 
     public LuaService(MtaServer server, ILogger logger, RootElement root)
@@ -28,11 +28,11 @@ public LuaService(MtaServer server, ILogger logger, RootElement root)
         this.logger = logger;
         this.root = root;
         this.scripts = new Dictionary<string, Script>();
-        this.methods = new Dictionary<string, LuaMethod>();
+        this.methods = new Dictionary<Script, Dictionary<string, LuaMethod>>();
         this.translator = new LuaTranslator();
     }
 
-    public void LoadDefinitions(object methodSet)
+    public void LoadDefinitions(object methodSet, Script owner)
     {
         foreach (var method in methodSet.GetType().GetMethods()
                 .Where(method => method.CustomAttributes
@@ -40,11 +40,12 @@ public void LoadDefinitions(object methodSet)
         {
             var attribute = method.GetCustomAttribute<ScriptFunctionDefinitionAttribute>();
 
-            if (this.methods.ContainsKey(attribute!.NiceName))
+            if (methods.TryGetValue(owner, out Dictionary<string, LuaMethod>? _) && this.methods[owner].ContainsKey(attribute!.NiceName))
                 throw new Exception($"Lua name conflict for '{attribute.NiceName}'");
 
             var methodParameters = method.GetParameters();
-            this.methods[attribute.NiceName] = (values) =>
+            this.methods.TryAdd(owner, new Dictionary<string, LuaMethod>());
+            this.methods[owner][attribute.NiceName] = (values) =>
             {
                 var valueQueue = new Queue<DynValue>(values.AsEnumerable());
 
@@ -55,7 +56,7 @@ public void LoadDefinitions(object methodSet)
                     {
                         if (valueQueue.Any())
                         {
-                            parameters[i] = this.translator.FromDynValue(methodParameters[i].ParameterType, valueQueue);
+                            parameters[i] = this.translator.FromDynValue(methodParameters[i].ParameterType, valueQueue, owner);
                         } else
                         {
                             if (!methodParameters[i].IsOptional)
@@ -74,40 +75,43 @@ public void LoadDefinitions(object methodSet)
                 }
                 var result = method.Invoke(methodSet, parameters);
 
-                return this.translator.ToDynValues(result).ToArray();
+                return this.translator.ToDynValues(result, owner).ToArray();
             };
         }
     }
 
-    public void LoadDefinitions<T>()
+    public void LoadDefinitions<T>(Script script)
     {
-        LoadDefinitions(this.server.Instantiate<T>()!);
+        LoadDefinitions(this.server.Instantiate<T>()!, script);
     }
 
-    public void LoadDefaultDefinitions()
+    public void LoadDefaultDefinitions(Script script)
     {
         foreach (var type in typeof(ScriptFunctionDefinitionAttribute).Assembly.DefinedTypes
             .Where(type => type.GetMethods()
                 .Any(method => method.CustomAttributes
                     .Any(attribute => attribute.AttributeType == typeof(ScriptFunctionDefinitionAttribute)))))
         {
-            LoadDefinitions(this.server.Instantiate(type));
+            LoadDefinitions(this.server.Instantiate(type), script);
         }
     }
 
-    public void LoadScript(string identifier, string code)
+    public Script LoadScript(string identifier, string code)
     {
         var script = new Script(CoreModules.Preset_SoftSandbox);
         script.Options.DebugPrint = (value) => this.logger.LogInformation(value);
         this.scripts[identifier] = script;
 
         LoadGlobals(script);
+        LoadDefaultDefinitions(script);
         LoadDefinitions(script);
 
         script.DoString(code, codeFriendlyName: identifier);
+
+        return script;
     }
 
-    public void LoadScript(string identifier, string[] codes)
+    public Script LoadScript(string identifier, string[] codes)
     {
         var script = new Script(CoreModules.Preset_SoftSandbox);
         script.Options.DebugPrint = (value) =>
@@ -118,18 +122,22 @@ public void LoadScript(string identifier, string[] codes)
         this.scripts[identifier] = script;
 
         LoadGlobals(script);
+        LoadDefaultDefinitions(script);
         LoadDefinitions(script);
 
         foreach (var code in codes)
             script.DoString(code, codeFriendlyName: identifier);
+
+        return script;
     }
 
-    public async Task LoadScriptFromPath(string path) => LoadScript(path, await File.ReadAllTextAsync(path));
-    public async Task LoadScriptFromPaths(string identifier, string[] paths)
+    public async Task<Script> LoadScriptFromPath(string path) => LoadScript(path, await File.ReadAllTextAsync(path));
+    public async Task<Script> LoadScriptFromPaths(string identifier, string[] paths)
     {
         var codeTasks = paths.Select(path => File.ReadAllTextAsync(path));
         await Task.WhenAll(codeTasks);
-        LoadScript(identifier, codeTasks.Select(task => task.Result).ToArray());
+        var script = LoadScript(identifier, codeTasks.Select(task => task.Result).ToArray());
+        return script;
     }
 
     public void UnloadScript(string identifier)
@@ -140,18 +148,20 @@ public void UnloadScript(string identifier)
     private void LoadDefinitions(Script script)
     {
         StringBuilder stringBuilder = new StringBuilder();
-        foreach (var definition in this.methods)
+        foreach (var definition in this.methods[script])
         {
             script.Globals["real" + definition.Key] = definition.Value;
             stringBuilder.AppendLine($"function {definition.Key}(...) return table.unpack(real{definition.Key}({{...}})) end");
         }
+        //LoadDefaultDefinitions(script);
+
         script.DoString(stringBuilder.ToString(), codeFriendlyName: "SlipeDefinitions");
     }
 
     private void LoadGlobals(Script script)
     {
-        script.Globals["root"] = this.translator.ToDynValues(this.root).First();
-        script.Globals["isSlipeServer"] = this.translator.ToDynValues(true).First();
+        script.Globals["root"] = this.translator.ToDynValues(this.root, script).First();
+        script.Globals["isSlipeServer"] = this.translator.ToDynValues(true, script).First();
     }
 
     public delegate DynValue[] LuaMethod(params DynValue[] values);
diff --git a/SlipeServer.Lua/LuaTranslator.cs b/SlipeServer.Lua/LuaTranslator.cs
index cace3cbc..79fa723c 100644
--- a/SlipeServer.Lua/LuaTranslator.cs
+++ b/SlipeServer.Lua/LuaTranslator.cs
@@ -16,7 +16,7 @@ public LuaTranslator()
         UserData.RegisterType<Element>(InteropAccessMode.Hardwired);
     }
 
-    public IEnumerable<DynValue> ToDynValues(object? obj)
+    public IEnumerable<DynValue> ToDynValues(object? obj, Script owner)
     {
         if (obj == null)
             return new DynValue[] { DynValue.Nil };
@@ -66,7 +66,7 @@ public IEnumerable<DynValue> ToDynValues(object? obj)
                     DynValue.NewNumber(vector3.Z)
             };
         if (obj is Delegate del)
-            return new DynValue[] { DynValue.NewCallback((context, arguments) => ToDynValues(del.DynamicInvoke(arguments.GetArray())!).First()) };
+            return new DynValue[] { DynValue.NewCallback((context, arguments) => ToDynValues(del.DynamicInvoke(arguments.GetArray())!, owner).First()) };
         if (obj is Table table)
             return new DynValue[] { DynValue.NewTable(table) };
         if (obj is DynValue dynValue)
@@ -75,7 +75,8 @@ public IEnumerable<DynValue> ToDynValues(object? obj)
         if (obj is IEnumerable<string> stringEnumerable)
             return stringEnumerable.Select(x => DynValue.NewString(x)).ToArray();
         if (obj is IEnumerable<object> enumerable)
-            return enumerable.Select(x => ToDynValues(x)).SelectMany(x => x).ToArray();
+            return enumerable.Select(x => ToDynValues(x, owner)).SelectMany(x => x).ToArray();
+
 
         throw new NotImplementedException($"Conversion to Lua for {obj.GetType()} not implemented");
     }
@@ -93,7 +94,7 @@ public IEnumerable<DynValue> ToDynValues(object? obj)
     public bool GetBooleanFromDynValue(DynValue dynValue) => dynValue.Boolean;
     public Table GetTableFromDynValue(DynValue dynValue) => dynValue.Table;
 
-    public object FromDynValue(Type targetType, Queue<DynValue> dynValues)
+    public object FromDynValue(Type targetType, Queue<DynValue> dynValues, Script owner)
     {
         if (targetType == typeof(Color) || targetType == typeof(Color?))
         {
@@ -133,17 +134,51 @@ public object FromDynValue(Type targetType, Queue<DynValue> dynValues)
             return GetTableFromDynValue(dynValues.Dequeue());
         if (typeof(Element).IsAssignableFrom(targetType))
             return dynValues.Dequeue().UserData.Object;
+        if (targetType == typeof(IEnumerable<string>))
+        {
+            List<string> args = new List<string> { };
+
+            foreach (DynValue arg in dynValues)
+            {
+                args.Add(GetStringFromDynValue(arg));
+            }
+            return args;
+        }
+        if (targetType == typeof(IEnumerable<object>))
+        {
+            List<object> args = new List<object>();
+
+            foreach (DynValue arg in dynValues)
+            {
+                switch (arg.Type)
+                {
+                    case DataType.String:
+                        args.Add(GetStringFromDynValue(arg));
+                        break;
+                    case DataType.UserData:
+                        var obj = (Element)arg.UserData.Object;
+                        args.Add(obj.Name + ":" + obj.GetHashCode());
+                        break;
+                    case DataType.Number:
+                        // TODO: This may result in data loss [Add more cases of number conversion]
+                        args.Add(GetInt32FromDynValue(arg));
+                        break;
+                }
+            }
+            return args;
+        }
         if (targetType == typeof(ScriptCallbackDelegateWrapper))
         {
             var callback = dynValues.Dequeue().Function;
-            return new ScriptCallbackDelegateWrapper(parameters => callback.Call(ToDynValues(parameters)), callback);
+            return new ScriptCallbackDelegateWrapper(parameters => callback.Call(ToDynValues(parameters, owner)), callback);
         }
         if (targetType == typeof(EventDelegate))
         {
             var callback = dynValues.Dequeue().Function;
-            return (EventDelegate)((element, parameters) => callback.Call(new DynValue[] { UserData.Create(element) }.Concat(ToDynValues(parameters))));
+            return (EventDelegate)((element, parameters) => callback.Call(new DynValue[] { UserData.Create(element) }.Concat(ToDynValues(parameters, owner))));
         }
 
+
         throw new NotImplementedException($"Conversion from Lua for {targetType} not implemented");
     }
 }
diff --git a/SlipeServer.Scripting/Definitions/DebugScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/DebugScriptDefinitions.cs
index ad97134b..efc061f0 100644
--- a/SlipeServer.Scripting/Definitions/DebugScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/DebugScriptDefinitions.cs
@@ -1,5 +1,10 @@
 using Microsoft.Extensions.Logging;
+using MoonSharp.Interpreter;
 using SlipeServer.Server.Services;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 
 namespace SlipeServer.Scripting.Definitions;
 
@@ -21,5 +26,25 @@ public void OutputDebugString(string message)
         this.logger.LogDebug(message);
     }
 
-
+    [ScriptFunctionDefinition("iprint")]
+    public void Print(IEnumerable<object> toPrint)
+    {
+        toPrint = (List<object>)toPrint;
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        int len = toPrint.Count();
+        foreach (var printable in toPrint)
+        {
+            string? stringRepresentation = printable.ToString();
+            sb.Append(stringRepresentation ?? "NoStringRepresentation");
+            if (i != len-1)
+            {
+                sb.Append(", ");
+            }
+            i++;
+        }
+        string message = sb.ToString();
+        this.debugLog.Output(message);
+        this.logger.LogInformation(message);
+    }
 }
diff --git a/SlipeServer.Scripting/Definitions/ElementScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/ElementScriptDefinitions.cs
index 218f2e7b..632f1c79 100644
--- a/SlipeServer.Scripting/Definitions/ElementScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/ElementScriptDefinitions.cs
@@ -1,10 +1,50 @@
 using SlipeServer.Server.Elements;
 using System.Numerics;
+using MoonSharp.Interpreter;
+using SlipeServer.Server.ElementCollections;
+using System.Collections.Generic;
+using SlipeServer.Server;
+using System;
+using SlipeServer.Server.Elements.ColShapes;
+using SlipeServer.Server.Elements.Enums;
+using SlipeServer.Packets.Definitions.Lua;
+using System.Linq;
+using SlipeServer.Server.Concepts;
 
 namespace SlipeServer.Scripting.Definitions;
 
 public class ElementScriptDefinitions
 {
+    private readonly MtaServer server;
+    private readonly IDictionary<ElementType, object> elementsForVariants;
+    private readonly IElementCollection elementCollection;
+
+    public ElementScriptDefinitions(MtaServer _server, IElementCollection elementCollection)
+    {
+        this.server = _server;
+        this.elementCollection = (RTreeCompoundElementCollection)elementCollection;
+        this.elementsForVariants = new Dictionary<ElementType, object>(Enum.GetNames(typeof(ElementType)).Length)
+        {
+            [ElementType.Player] = typeof(Player),
+            [ElementType.Weapon] = typeof(WeaponObject),
+            [ElementType.Pickup] = typeof(Pickup),
+            [ElementType.Blip] = typeof(Blip),
+            [ElementType.Colshape] = typeof(CollisionShape),
+            [ElementType.Console] = typeof(Console),
+            [ElementType.Dummy] = typeof(DummyElement),
+            [ElementType.Marker] = typeof(Marker),
+            [ElementType.Object] = typeof(Object),
+            [ElementType.Ped] = typeof(Ped),
+            [ElementType.RadarArea] = typeof(RadarArea),
+            [ElementType.Team] = typeof(Team),
+            [ElementType.Vehicle] = typeof(Vehicle),
+            [ElementType.Water] = typeof(Water),
+            // TBD: [ElementType.WorldMeshUnused] = ?
+            // TBD: [ElementType.PathNodeUnused] = 
+            // TBD: [ElementType.DatabaseConnection] = ?
+        };
+    }
+
     [ScriptFunctionDefinition("destroyElement")]
     public void DestroyElement(Element element) => element.Destroy();
 
@@ -25,4 +65,69 @@ public class ElementScriptDefinitions
 
     [ScriptFunctionDefinition("getElementType")]
     public string GetElementType(Element element) => element.ElementType.ToString().ToLower();
+
+    [ScriptFunctionDefinition("createElement")]
+    public Element CreateElement(string type, int? elementID = null)
+    {
+        //BasicCompoundElementCollection elementCollection = (BasicCompoundElementCollection)this.server.GetRequiredService<IElementCollection>();
+
+        Element newElement;
+
+        if (Enum.IsDefined(typeof(ElementType), type))
+        {
+            Type classType = (Type)this.elementsForVariants[Enum.Parse<ElementType>(type)];
+            newElement = (Element)Activator.CreateInstance(classType);
+            // TODO: Maybe there's a better alternative to handle this
+            if (newElement is null)
+                newElement = new CustomElement(type);
+        } else
+        {
+            newElement = new CustomElement(type);
+        }
+
+        elementCollection.Add(newElement);
+
+        return newElement;
+    }
+
+    [ScriptFunctionDefinition("detachElements")]
+    public void DeatchElements(Element childElement, Element? detachFrom = null)
+    {
+        childElement.DetachFrom(detachFrom ?? null);
+    }
+
+    [ScriptFunctionDefinition("getAllElementData")]
+    public IDictionary<string, ElementData> GetAllElementData(Element element)
+    {
+        /*var elementDatas = element.GetAllElementData();
+        DynValue theTable = DynValue.NewTable();
+        
+        foreach ( var elementData in elementDatas )
+        {
+            theTable.Table.Set(elementData.Key, DynValue.FromObject(, elementData.Value));
+        }
+
+        */
+        return new object() as Dictionary<string, ElementData>;
+    }
+
+    [ScriptFunctionDefinition("setElementData")]
+    public void SetElementData(Element element, string key, DynValue dynValue, bool synchronizeType = true)
+    {
+        Dictionary<bool, DataSyncType> syncTypes = new()
+        {
+            [true] = DataSyncType.Broadcast,
+            [false] = DataSyncType.Local,
+        };
+        element.SetData(key, dynValue.String, syncTypes[synchronizeType]);
+    }
+
+    [ScriptFunctionDefinition("getElementData")]
+    public DynValue GetElementData(Element element, string key, bool inherit = true)
+    {
+        LuaValue? data = element.GetData(key);
+        var result = LuaTranslatorUtility.ToDynValues(data).First();
+
+        return result ?? DynValue.NewBoolean(false);
+    }
 }
diff --git a/SlipeServer.Scripting/Definitions/EventScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/EventScriptDefinitions.cs
index 78718131..c80ce5a9 100644
--- a/SlipeServer.Scripting/Definitions/EventScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/EventScriptDefinitions.cs
@@ -1,4 +1,5 @@
-using SlipeServer.Server.Elements;
+using MoonSharp.Interpreter;
+using SlipeServer.Server.Elements;
 
 namespace SlipeServer.Scripting.Definitions;
 
diff --git a/SlipeServer.Scripting/Definitions/ExplosionScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/ExplosionScriptDefinitions.cs
index a7675d2d..4e91dc86 100644
--- a/SlipeServer.Scripting/Definitions/ExplosionScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/ExplosionScriptDefinitions.cs
@@ -1,4 +1,5 @@
-using SlipeServer.Server.Elements;
+using MoonSharp.Interpreter;
+using SlipeServer.Server.Elements;
 using SlipeServer.Server.Enums;
 using SlipeServer.Server.Services;
 using System;
diff --git a/SlipeServer.Scripting/Definitions/InputScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/InputScriptDefinitions.cs
index a49efb92..b0657c10 100644
--- a/SlipeServer.Scripting/Definitions/InputScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/InputScriptDefinitions.cs
@@ -1,4 +1,6 @@
-namespace SlipeServer.Scripting.Definitions;
+using MoonSharp.Interpreter;
+
+namespace SlipeServer.Scripting.Definitions;
 
 public class InputScriptDefinitions
 {
diff --git a/SlipeServer.Scripting/Definitions/ObjectScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/ObjectScriptDefinitions.cs
index 4b3cf6c1..1c0bf910 100644
--- a/SlipeServer.Scripting/Definitions/ObjectScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/ObjectScriptDefinitions.cs
@@ -1,4 +1,5 @@
-using SlipeServer.Server;
+using MoonSharp.Interpreter;
+using SlipeServer.Server;
 using SlipeServer.Server.Elements;
 using System.Numerics;
 
diff --git a/SlipeServer.Scripting/Definitions/RadarAreaScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/RadarAreaScriptDefinitions.cs
index 3704d58c..f02356f8 100644
--- a/SlipeServer.Scripting/Definitions/RadarAreaScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/RadarAreaScriptDefinitions.cs
@@ -1,4 +1,5 @@
-using SlipeServer.Server;
+using MoonSharp.Interpreter;
+using SlipeServer.Server;
 using SlipeServer.Server.Elements;
 using System.Drawing;
 using System.Numerics;
diff --git a/SlipeServer.Scripting/Definitions/UtilityScriptDefinitions.cs b/SlipeServer.Scripting/Definitions/UtilityScriptDefinitions.cs
index 9e81c858..9920e05c 100644
--- a/SlipeServer.Scripting/Definitions/UtilityScriptDefinitions.cs
+++ b/SlipeServer.Scripting/Definitions/UtilityScriptDefinitions.cs
@@ -1,4 +1,5 @@
-using SlipeServer.Server;
+using MoonSharp.Interpreter;
+using SlipeServer.Server;
 using System;
 using System.Drawing;
 using System.Security.Cryptography;
diff --git a/SlipeServer.Scripting/LuaTranslatorUtility.cs b/SlipeServer.Scripting/LuaTranslatorUtility.cs
new file mode 100644
index 00000000..23618ced
--- /dev/null
+++ b/SlipeServer.Scripting/LuaTranslatorUtility.cs
@@ -0,0 +1,177 @@
+using MoonSharp.Interpreter;
+using SlipeServer.Server.Elements;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Numerics;
+
+namespace SlipeServer.Scripting;
+public static class LuaTranslatorUtility
+{
+    public static IEnumerable<DynValue> ToDynValues(object? obj)
+    {
+        if (obj == null)
+            return new DynValue[] { DynValue.Nil };
+        if (obj is Element element)
+            return new DynValue[] { UserData.Create(element) };
+        if (obj is byte int8)
+            return new DynValue[] { DynValue.NewNumber(int8) };
+        if (obj is short int16)
+            return new DynValue[] { DynValue.NewNumber(int16) };
+        if (obj is int int32)
+            return new DynValue[] { DynValue.NewNumber(int32) };
+        if (obj is long int64)
+            return new DynValue[] { DynValue.NewNumber(int64) };
+        if (obj is ushort uint16)
+            return new DynValue[] { DynValue.NewNumber(uint16) };
+        if (obj is uint uint32)
+            return new DynValue[] { DynValue.NewNumber(uint32) };
+        if (obj is ulong uint64)
+            return new DynValue[] { DynValue.NewNumber(uint64) };
+        if (obj is float single)
+            return new DynValue[] { DynValue.NewNumber(single) };
+        if (obj is double dub)
+            return new DynValue[] { DynValue.NewNumber(dub) };
+        if (obj is bool boolean)
+            return new DynValue[] { DynValue.NewBoolean(boolean) };
+        if (obj is string str)
+            return new DynValue[] { DynValue.NewString(str) };
+        if (obj is Color color)
+            return new DynValue[]
+            {
+                    DynValue.NewNumber(color.R),
+                    DynValue.NewNumber(color.G),
+                    DynValue.NewNumber(color.B),
+                    DynValue.NewNumber(color.A),
+            };
+        if (obj is Vector2 vector2)
+            return new DynValue[]
+            {
+                    DynValue.NewNumber(vector2.X),
+                    DynValue.NewNumber(vector2.Y)
+            };
+        if (obj is Vector3 vector3)
+            return new DynValue[]
+            {
+                    DynValue.NewNumber(vector3.X),
+                    DynValue.NewNumber(vector3.Y),
+                    DynValue.NewNumber(vector3.Z)
+            };
+        if (obj is Delegate del)
+            return new DynValue[] { DynValue.NewCallback((context, arguments) => ToDynValues(del.DynamicInvoke(arguments.GetArray())!).First()) };
+        if (obj is Table table)
+            return new DynValue[] { DynValue.NewTable(table) };
+        if (obj is DynValue dynValue)
+            return new DynValue[] { dynValue };
+
+        if (obj is IEnumerable<string> stringEnumerable)
+            return stringEnumerable.Select(x => DynValue.NewString(x)).ToArray();
+        if (obj is IEnumerable<object> enumerable)
+            return enumerable.Select(x => ToDynValues(x)).SelectMany(x => x).ToArray();
+
+
+        throw new NotImplementedException($"Conversion to Lua for {obj.GetType()} not implemented");
+    }
+
+    public static float GetSingleFromDynValue(DynValue dynValue) => (float)dynValue.Number;
+    public static double GetDoubleFromDynValue(DynValue dynValue) => dynValue.Number;
+    public static byte GetByteFromDynValue(DynValue dynValue) => (byte)dynValue.Number;
+    public static short GetInt16FromDynValue(DynValue dynValue) => (short)dynValue.Number;
+    public static int GetInt32FromDynValue(DynValue dynValue) => (int)dynValue.Number;
+    public static long GetInt64FromDynValue(DynValue dynValue) => (long)dynValue.Number;
+    public static ushort GetUInt16FromDynValue(DynValue dynValue) => (ushort)dynValue.Number;
+    public static uint GetUInt32FromDynValue(DynValue dynValue) => (uint)dynValue.Number;
+    public static ulong GetUInt64FromDynValue(DynValue dynValue) => (ulong)dynValue.Number;
+    public static string GetStringFromDynValue(DynValue dynValue) => dynValue.String;
+    public static bool GetBooleanFromDynValue(DynValue dynValue) => dynValue.Boolean;
+    public static Table GetTableFromDynValue(DynValue dynValue) => dynValue.Table;
+
+    public static object FromDynValue(Type targetType, Queue<DynValue> dynValues)
+    {
+        if (targetType == typeof(Color) || targetType == typeof(Color?))
+        {
+            byte red = GetByteFromDynValue(dynValues.Dequeue());
+            byte green = GetByteFromDynValue(dynValues.Dequeue());
+            byte blue = GetByteFromDynValue(dynValues.Dequeue());
+            byte alpha = GetByteFromDynValue(dynValues.Dequeue());
+            return Color.FromArgb(alpha, red, green, blue);
+        }
+        if (targetType == typeof(Vector3))
+            return new Vector3(GetSingleFromDynValue(dynValues.Dequeue()), GetSingleFromDynValue(dynValues.Dequeue()), GetSingleFromDynValue(dynValues.Dequeue()));
+        if (targetType == typeof(Vector2))
+            return new Vector2(GetSingleFromDynValue(dynValues.Dequeue()), GetSingleFromDynValue(dynValues.Dequeue()));
+        if (targetType == typeof(float))
+            return GetSingleFromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(double))
+            return GetDoubleFromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(byte))
+            return GetByteFromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(short))
+            return GetInt16FromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(ushort))
+            return GetUInt16FromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(int))
+            return GetInt32FromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(uint))
+            return GetUInt32FromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(long))
+            return GetInt64FromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(ulong))
+            return GetUInt64FromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(string))
+            return GetStringFromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(bool))
+            return GetBooleanFromDynValue(dynValues.Dequeue());
+        if (targetType == typeof(Table))
+            return GetTableFromDynValue(dynValues.Dequeue());
+        if (typeof(Element).IsAssignableFrom(targetType))
+            return dynValues.Dequeue().UserData.Object;
+        if (targetType == typeof(IEnumerable<string>))
+        {
+            List<string> args = new List<string> { };
+
+            foreach (DynValue arg in dynValues)
+            {
+                args.Add(GetStringFromDynValue(arg));
+            }
+            return args;
+        }
+        if (targetType == typeof(IEnumerable<object>))
+        {
+            List<object> args = new List<object>();
+
+            foreach (DynValue arg in dynValues)
+            {
+                switch (arg.Type)
+                {
+                    case DataType.String:
+                        args.Add(GetStringFromDynValue(arg));
+                        break;
+                    case DataType.UserData:
+                        var obj = (Element)arg.UserData.Object;
+                        args.Add(obj.Name + ":" + obj.GetHashCode());
+                        break;
+                    case DataType.Number:
+                        // TODO: This may result in data loss [Add more cases of number conversion]
+                        args.Add(GetInt32FromDynValue(arg));
+                        break;
+                }
+            }
+            return args;
+        }
+        if (targetType == typeof(ScriptCallbackDelegateWrapper))
+        {
+            var callback = dynValues.Dequeue().Function;
+            return new ScriptCallbackDelegateWrapper(parameters => callback.Call(ToDynValues(parameters)), callback);
+        }
+        if (targetType == typeof(EventDelegate))
+        {
+            var callback = dynValues.Dequeue().Function;
+            return (EventDelegate)((element, parameters) => callback.Call(new DynValue[] { UserData.Create(element) }.Concat(ToDynValues(parameters))));
+        }
+
+
+        throw new NotImplementedException($"Conversion from Lua for {targetType} not implemented");
+    }
+}
diff --git a/SlipeServer.Scripting/SlipeServer.Scripting.csproj b/SlipeServer.Scripting/SlipeServer.Scripting.csproj
index 6bd82fcc..1882fd37 100644
--- a/SlipeServer.Scripting/SlipeServer.Scripting.csproj
+++ b/SlipeServer.Scripting/SlipeServer.Scripting.csproj
@@ -31,4 +31,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="MoonSharp" Version="2.0.0" />
+  </ItemGroup>
+
 </Project>
diff --git a/SlipeServer.Server/Elements/CustomElement.cs b/SlipeServer.Server/Elements/CustomElement.cs
new file mode 100644
index 00000000..359f2f0b
--- /dev/null
+++ b/SlipeServer.Server/Elements/CustomElement.cs
@@ -0,0 +1,31 @@
+using SlipeServer.Server.Elements.Events;
+using System.Drawing;
+using System.Numerics;
+
+namespace SlipeServer.Server.Elements;
+
+/// <summary>
+/// A radar area element
+/// Radar areas are visual rectangles on the F11 map and ingame radar.
+/// </summary>
+public class CustomElement : Element
+{
+    public override ElementType ElementType => ElementType.Custom;
+
+    public CustomElement()
+    {
+        this.Name = "UnknownCustom";
+    }
+
+    public CustomElement(string type)
+    {
+        this.Name = type;
+    }
+
+    public new CustomElement AssociateWith(MtaServer server)
+    {
+        base.AssociateWith(server);
+        return this;
+    }
+
+}
diff --git a/SlipeServer.Server/Elements/Element.cs b/SlipeServer.Server/Elements/Element.cs
index 914423e9..2c9c8b88 100644
--- a/SlipeServer.Server/Elements/Element.cs
+++ b/SlipeServer.Server/Elements/Element.cs
@@ -83,7 +83,7 @@ public ElementId Id
 
     private string name = "";
     /// <summary>
-    /// The element name, for Player's this is the nickname, for other elements it's mostly unused.
+    /// The element name, for Player's this is the nickname, for custom elements this will be used as type
     /// </summary>
     public string Name
     {
@@ -679,6 +679,11 @@ public void SetData(string key, LuaValue value, DataSyncType syncType = DataSync
         return null;
     }
 
+    public IDictionary<string, ElementData> GetAllElementData()
+    {
+        return this.ElementData;
+    }
+
     /// <summary>
     /// Subscribes a player to changes to a specific element data value
     /// </summary>
diff --git a/SlipeServer.Server/Elements/Enums/ElementType.cs b/SlipeServer.Server/Elements/Enums/ElementType.cs
index ef8cb7cf..20a467d7 100644
--- a/SlipeServer.Server/Elements/Enums/ElementType.cs
+++ b/SlipeServer.Server/Elements/Enums/ElementType.cs
@@ -23,5 +23,6 @@ public enum ElementType
     Weapon,
     DatabaseConnection,
     Root,
-    Unknown
+    Unknown,
+    Custom,
 }
diff --git a/SlipeServer.Server/Extensions/StringExtensions.cs b/SlipeServer.Server/Extensions/StringExtensions.cs
index 2f198efb..7ebec467 100644
--- a/SlipeServer.Server/Extensions/StringExtensions.cs
+++ b/SlipeServer.Server/Extensions/StringExtensions.cs
@@ -1,4 +1,7 @@
-using System.Text.RegularExpressions;
+using System;
+using System.Drawing;
+using System.Reflection.PortableExecutable;
+using System.Text.RegularExpressions;
 
 namespace SlipeServer.Server.Extensions;
 
@@ -16,4 +19,139 @@ public static string StripColorCode(this string value)
             temp = Regex.Replace(temp, colorCodeRegex, "");
         return temp;
     }
+    /// <summary>
+    /// Calculate and return this strings hash
+    /// </summary>
+    /// <returns>Returns Hash for this string</returns>
+    public static nuint GetHash(this string value)
+    {
+        UIntPtr a, b, c; // Temporary variables
+        int len = value.Length; // Length of the string left
+
+        a = b = 0x9e3779b9;
+        c = 0xabcdef89;
+
+        int start = 0;
+        int end = 12;
+
+
+        while (len >= 12)
+        {
+            var _values = value.ToCharArray(start, end);
+            a += (_values[0] + ((uint)_values[1] << 8) + (uint)(_values[2] << 16) + (uint)(_values[3] << 24));
+            b += (_values[4] + ((uint)_values[5] << 8) + (uint)(_values[6] << 16) + (uint)(_values[7] << 24));
+            c += (_values[8] + ((uint)_values[9] << 8) + (uint)(_values[10] << 16) + (uint)(_values[11] << 24));
+
+            // Mix
+            a -= b;
+            a -= c;
+            a ^= (c >> 13);
+            b -= c;
+            b -= a;
+            b ^= (a << 8);
+            c -= a;
+            c -= b;
+            c ^= (b >> 13);
+            a -= b;
+            a -= c;
+            a ^= (c >> 12);
+            b -= c;
+            b -= a;
+            b ^= (a << 16);
+            c -= a;
+            c -= b;
+            c ^= (b >> 5);
+            a -= b;
+            a -= c;
+            a ^= (c >> 3);
+            b -= c;
+            b -= a;
+            b ^= (a << 10);
+            c -= a;
+            c -= b;
+            c ^= (b >> 15);
+
+            start += 12;
+            end += 12;
+            len -= 12;
+        }
+
+        // Handle the last 11 remaining bytes
+        // Note: All cases fall through
+
+        c += (nuint)value.Length;            // Lower byte of c gets used for length
+
+        var values = value.ToCharArray(0, 12);
+
+        switch (len)
+        {
+            case 11:
+                c += ((uint)values[10] << 24);
+                goto case 10;
+            case 10:
+                c += ((uint)values[9] << 16);
+                goto case 9;
+            case 9:
+                c += ((uint)values[8] << 8);
+                goto case 8;
+            case 8:
+                b += ((uint)values[7] << 24);
+                goto case 7;
+            case 7:
+                b += ((uint)values[6] << 16);
+                goto case 6;
+            case 6:
+                b += ((uint)values[5] << 8);
+                goto case 5;
+            case 5:
+                b += values[4];
+                goto case 4;
+            case 4:
+                a += ((uint)values[3] << 24);
+                goto case 3;
+            case 3:
+                a += ((uint)values[2] << 16);
+                goto case 2;
+            case 2:
+                a += ((uint)values[1] << 8);
+                goto case 1;
+            case 1:
+                a += values[0];
+                goto default;
+            default:
+                break;
+        }
+
+
+        // Mix
+        a -= b;
+        a -= c;
+        a ^= (c >> 13);
+        b -= c;
+        b -= a;
+        b ^= (a << 8);
+        c -= a;
+        c -= b;
+        c ^= (b >> 13);
+        a -= b;
+        a -= c;
+        a ^= (c >> 12);
+        b -= c;
+        b -= a;
+        b ^= (a << 16);
+        c -= a;
+        c -= b;
+        c ^= (b >> 5);
+        a -= b;
+        a -= c;
+        a ^= (c >> 3);
+        b -= c;
+        b -= a;
+        b ^= (a << 10);
+        c -= a;
+        c -= b;
+        c ^= (b >> 15);
+
+        return c;
+    }
 }