diff --git a/Include/Aurora/Async/Async.hpp b/Include/Aurora/Async/Async.hpp
index 22208098..a593836c 100644
--- a/Include/Aurora/Async/Async.hpp
+++ b/Include/Aurora/Async/Async.hpp
@@ -44,10 +44,10 @@ namespace Aurora::Async
         AuFunction<void()> callback;
         AuFunction<void()> shutdown; // error
     
-        BasicWorkStdFunc(AuFunction<void()> &&callback, AuFunction<void()> &&shutdown) : callback(std::move(callback)),  shutdown(std::move(shutdown))
+        BasicWorkStdFunc(AuFunction<void()> &&callback, AuFunction<void()> &&shutdown) : callback(AuMove(callback)),  shutdown(AuMove(shutdown))
         {}
 
-        BasicWorkStdFunc(AuFunction<void()> &&callback) : callback(std::move(callback))
+        BasicWorkStdFunc(AuFunction<void()> &&callback) : callback(AuMove(callback))
         {}
         
         BasicWorkStdFunc(const AuFunction<void()> &callback) : callback(callback)
diff --git a/Include/Aurora/Async/WorkPairImpl.hpp b/Include/Aurora/Async/WorkPairImpl.hpp
index db2bc884..9800f3dc 100644
--- a/Include/Aurora/Async/WorkPairImpl.hpp
+++ b/Include/Aurora/Async/WorkPairImpl.hpp
@@ -34,10 +34,10 @@ namespace Aurora::Async
         WorkPairImpl() : caller_(Async::GetCurrentWorkerPId())
         {}
         
-        WorkPairImpl(Task_t &&task) : task(std::move(task)), caller_(Async::GetCurrentWorkerPId())
+        WorkPairImpl(Task_t &&task) : task(AuMove(task)), caller_(Async::GetCurrentWorkerPId())
         {}
         
-        WorkPairImpl(Task_t &&task, Job_t &&callback) : task(std::move(task)), callback(std::move(callback)), caller_(Async::GetCurrentWorkerPId())
+        WorkPairImpl(Task_t &&task, Job_t &&callback) : task(AuMove(task)), callback(AuMove(callback)), caller_(Async::GetCurrentWorkerPId())
         {}
 
         WorkPairImpl(const Task_t &task) : task(task), caller_(Async::GetCurrentWorkerPId())
@@ -49,13 +49,13 @@ namespace Aurora::Async
         WorkPairImpl(const Task_t &task, const Job_t &callback, const Info_t &info) : task(task), callback(callback), input(info), caller_(Async::GetCurrentWorkerPId())
         {}
         
-        WorkPairImpl(Task_t &&task, const Job_t &callback, const Info_t &info) : task(std::move(task)), callback(callback), input(info), caller_(Async::GetCurrentWorkerPId())
+        WorkPairImpl(Task_t &&task, const Job_t &callback, const Info_t &info) : task(AuMove(task)), callback(callback), input(info), caller_(Async::GetCurrentWorkerPId())
         {}
         
-        WorkPairImpl(Task_t &&task, Job_t &&callback, const Info_t &info) : task(std::move(task)), callback(std::move(callback)), input(info), caller_(Async::GetCurrentWorkerPId())
+        WorkPairImpl(Task_t &&task, Job_t &&callback, const Info_t &info) : task(AuMove(task)), callback(AuMove(callback)), input(info), caller_(Async::GetCurrentWorkerPId())
         {}
         
-        WorkPairImpl(Task_t &&task, Job_t &&callback, Info_t &&info) : task(std::move(task)), callback(std::move(callback)), input(std::move(info)), caller_(Async::GetCurrentWorkerPId())
+        WorkPairImpl(Task_t &&task, Job_t &&callback, Info_t &&info) : task(AuMove(task)), callback(AuMove(callback)), input(AuMove(info)), caller_(Async::GetCurrentWorkerPId())
         {}
         
         WorkPairImpl(const Task_t &task, const Job_t &callback, Info_t &&info) : task(task), callback(callback), input(info), caller_(Async::GetCurrentWorkerPId())
diff --git a/Include/Aurora/Memory/Heap.hpp b/Include/Aurora/Memory/Heap.hpp
index d0ddd85e..ff7d71ae 100644
--- a/Include/Aurora/Memory/Heap.hpp
+++ b/Include/Aurora/Memory/Heap.hpp
@@ -103,7 +103,7 @@ namespace Aurora::Memory
         {
             if (in == nullptr) return {};
             auto heapHandle = pinThis ? GetSelfReference() : AuSPtr<Heap> {};
-            return std::shared_ptr<T>(in,
+            return AuSPtr<T>(in,
                    [heapHandle, in, this](T *delt)
                    {
                        if constexpr (AuIsClass_v<T>)
@@ -119,7 +119,7 @@ namespace Aurora::Memory
         {
             auto handle = pinHeap ? heap : AuSPtr<Heap> {};
             auto ptr = heap.get(); // so long as in is a valid pointer within the heap, this is fine
-            return std::shared_ptr<T>(in,
+            return AuSPtr<T>(in,
                    [handle,  ptr](T *delt)
                    {
                        ptr->Free(delt);
diff --git a/Include/Aurora/Memory/MemoryView.hpp b/Include/Aurora/Memory/MemoryView.hpp
index 5b934dda..e4464bff 100644
--- a/Include/Aurora/Memory/MemoryView.hpp
+++ b/Include/Aurora/Memory/MemoryView.hpp
@@ -12,10 +12,10 @@ namespace Aurora::Memory
     template<bool Readonly_b>
     struct MemoryView
     {
-        using Void_t = std::conditional_t<Readonly_b, const void *, void *>;
+        using Void_t = AuConditional_t<Readonly_b, const void *, void *>;
 
         template<typename T, int Z>
-        using StdArray_t = std::conditional_t<Readonly_b, const AuArray<T, Z>, AuArray<T, Z>>;
+        using StdArray_t = AuConditional_t<Readonly_b, const AuArray<T, Z>, AuArray<T, Z>>;
         
         /*
             YadaYada(MemoryView(tempstring/array/etc)) should be legal, right?
@@ -119,7 +119,6 @@ namespace Aurora::Memory
     template<bool Readonly_b>
     struct MemoryViewStream : MemoryView<Readonly_b>
     {
-       // template<typename T, typename std::enable_if<AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, T>::value>::type* = nullptr>
         template<typename T, AU_TEMPLATE_ENABLE_WHEN(AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, T>::value)>
         constexpr MemoryViewStream(T &list, AuUInt &length) : MemoryView<Readonly_b>(list), outVariable(length)
         {
@@ -143,7 +142,7 @@ namespace Aurora::Memory
             outVariable = 0;
         }
 
-        template<typename T, typename std::enable_if<AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, T>::value>::type* = nullptr>
+        template<typename T, typename AuEnableIf<AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, T>::value>::type* = nullptr>
         constexpr MemoryViewStream(T &list) : MemoryView<Readonly_b>(list), outVariable(unused)
         {
             outVariable = 0;
diff --git a/Include/Aurora/Parse/Parser.hpp b/Include/Aurora/Parse/Parser.hpp
index a9c805b9..9cadced0 100644
--- a/Include/Aurora/Parse/Parser.hpp
+++ b/Include/Aurora/Parse/Parser.hpp
@@ -135,7 +135,7 @@ namespace Aurora::Parse
         ParseState(ConsumeStream_cb &str) : stringstream(str)
         {}
 
-        ParseState(ConsumeStream_cb &&str) : stringstream(std::move(str))
+        ParseState(ConsumeStream_cb &&str) : stringstream(AuMove(str))
         {}
 
         ConsumeStream_cb stringstream;
diff --git a/Include/Aurora/Telemetry/BlackBox.hpp b/Include/Aurora/Telemetry/BlackBox.hpp
index 319c7276..c6b7dfba 100644
--- a/Include/Aurora/Telemetry/BlackBox.hpp
+++ b/Include/Aurora/Telemetry/BlackBox.hpp
@@ -158,8 +158,9 @@ namespace Aurora::Telemetry
         NewBlackboxEntryUpdateMap map;
     };
 
-    using StreamWriter = std::function<void(AuUInt8 stream, const AuUInt8 *buffer, AuUInt32 length)>;
-    using StreamReader = std::function<void(AuUInt8 stream, AuUInt8 *buffer, AuUInt32 &length)>;
+    // TODO: port to lui
+    using StreamWriter = AuFunction<void(AuUInt8 stream, const AuUInt8 *buffer, AuUInt32 length)>;
+    using StreamReader = AuFunction<void(AuUInt8 stream, AuUInt8 *buffer, AuUInt32 &length)>;
 
     AUKN_SYM AuList<NewBlockboxEntry> ReadBlackboxStream(const StreamReader &reader);
     AUKN_SYM void                     WriteBlackboxStream(const AuList<NewBlockboxEntry> &, StreamWriter writer);
diff --git a/Include/Aurora/Threading/LockGuard.hpp b/Include/Aurora/Threading/LockGuard.hpp
index c9acb135..387d2368 100644
--- a/Include/Aurora/Threading/LockGuard.hpp
+++ b/Include/Aurora/Threading/LockGuard.hpp
@@ -13,7 +13,7 @@ namespace Aurora::Threading
     class LockGuard
     {
     private:
-        using Internal_t = std::remove_pointer_t<T>;
+        using Internal_t = AuRemovePointer_t<T>;
 
     public:
         
diff --git a/Include/Aurora/Threading/LockGuardTry.hpp b/Include/Aurora/Threading/LockGuardTry.hpp
index 10612faf..b915ed85 100644
--- a/Include/Aurora/Threading/LockGuardTry.hpp
+++ b/Include/Aurora/Threading/LockGuardTry.hpp
@@ -13,7 +13,7 @@ namespace Aurora::Threading
     class TryLockGuard
     {
     private:
-        using Internal_t = std::remove_pointer_t<T>;
+        using Internal_t = AuRemovePointer_t<T>;
         bool bLockSuccessful;
         
     public:
diff --git a/Include/Aurora/Threading/Threads/IAuroraThread.hpp b/Include/Aurora/Threading/Threads/IAuroraThread.hpp
index 9df583a1..7f80237c 100644
--- a/Include/Aurora/Threading/Threads/IAuroraThread.hpp
+++ b/Include/Aurora/Threading/Threads/IAuroraThread.hpp
@@ -69,6 +69,6 @@ namespace Aurora::Threading::Threads
         // UPDATE: DONE
         virtual void              Detach()                      = 0;
 
-        virtual void              ExecuteInDeadThread(std::function<void()> callback) = 0;
+        virtual void              ExecuteInDeadThread(AuFunction<void()> callback) = 0;
     };
 }
\ No newline at end of file
diff --git a/Include/AuroraTypedefs.hpp b/Include/AuroraTypedefs.hpp
index 765703a5..13acd8ec 100644
--- a/Include/AuroraTypedefs.hpp
+++ b/Include/AuroraTypedefs.hpp
@@ -131,6 +131,64 @@ using AuIsVoid = AuIsSame<void, T>;
 template <class T>
 inline constexpr bool AuIsVoid_v = AuIsVoid<T>::value;
 
+template <class T>
+struct AuRemoveReference
+{
+    using type = T;
+};
+
+template <class T>
+struct AuRemoveReference<T &>
+{
+    using type = T;
+};
+
+template <class T>
+struct AuRemoveReference<T &&>
+{
+    using type = T;
+};
+
+template <class T>
+using AuRemoveReference_t = typename AuRemoveReference<T>::type;
+
+template <class T>
+constexpr AuRemoveReference_t<T> &&AuMove(T &&arg) noexcept
+{
+    return static_cast<AuRemoveReference_t<T> &&>(arg);
+}
+
+
+template<bool Test, class T = void>
+struct AuEnableIf
+{
+};
+
+template<class T>
+struct AuEnableIf<true, T>
+{
+    using type = T;
+};
+
+template<bool Test, class T = void>
+using AuEnableIf_t = typename AuEnableIf<Test, T>::type;
+
+
+template<bool Test, class T, class T2>
+struct AuConditional
+{
+    using type = T;
+};
+
+template<class T, class T2>
+struct AuConditional<false, T, T2>
+{
+    using type = T2;
+};
+
+template<bool Test, class T, class T2>
+using AuConditional_t = typename AuConditional<Test, T, T2>::type;
+
 
 #if !defined(AURORA_RUNTIME_AU_LIST)
     #define AURORA_RUNTIME_AU_LIST std::vector
diff --git a/Source/Async/AsyncRunnable.hpp b/Source/Async/AsyncRunnable.hpp
index 4c9590a0..75598d28 100644
--- a/Source/Async/AsyncRunnable.hpp
+++ b/Source/Async/AsyncRunnable.hpp
@@ -26,10 +26,10 @@ namespace Aurora::Async
         AuFunction<void()> fail;
         AuThreadPrimitives::SpinLock lock;
         
-        AsyncFuncRunnable(AuFunction<void()> &&callback) : callback(std::move(callback))
+        AsyncFuncRunnable(AuFunction<void()> &&callback) : callback(AuMove(callback))
         {}
         
-        AsyncFuncRunnable(AuFunction<void()> &&callback, AuFunction<void()> &&fail) : callback(std::move(callback)), fail(std::move(fail))
+        AsyncFuncRunnable(AuFunction<void()> &&callback, AuFunction<void()> &&fail) : callback(AuMove(callback)), fail(AuMove(fail))
         {}
         
         AsyncFuncRunnable(const AuFunction<void()> &callback) : callback(callback)
diff --git a/Source/Async/Schedular.cpp b/Source/Async/Schedular.cpp
index 2dfbb45a..43270766 100644
--- a/Source/Async/Schedular.cpp
+++ b/Source/Async/Schedular.cpp
@@ -35,7 +35,7 @@ namespace Aurora::Async
         {
             if (itr->ns <= time)
             {
-                if (!AuTryInsert(pending, std::move(*itr)))
+                if (!AuTryInsert(pending, AuMove(*itr)))
                 {
                     break;
                 }
diff --git a/Source/Console/Commands/Commands.cpp b/Source/Console/Commands/Commands.cpp
index d0f40132..8f0e0437 100644
--- a/Source/Console/Commands/Commands.cpp
+++ b/Source/Console/Commands/Commands.cpp
@@ -27,7 +27,7 @@ namespace Aurora::Console::Commands
         AuSPtr<ICommandSubscriber> callback;
 
         Command(AuString tag, Parse::ParseObject commandStructure, const AuSPtr<ICommandSubscriber> &callback) : tag(tag), commandStructure(commandStructure), callback(callback) {}
-        Command(AuString tag, Parse::ParseObject commandStructure, AuSPtr<ICommandSubscriber> &&callback) : tag(tag), commandStructure(commandStructure), callback(std::move(callback)) {}
+        Command(AuString tag, Parse::ParseObject commandStructure, AuSPtr<ICommandSubscriber> &&callback) : tag(tag), commandStructure(commandStructure), callback(AuMove(callback)) {}
     };
 
     struct CommandDispatch